RTEMS 4.10.2Annotated Report
Tue Dec 13 20:08:41 2011
00009208 <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 ) {
9208: e5903000 ldr r3, [r0]
920c: e593204c ldr r2, [r3, #76] ; 0x4c
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
9210: e5903010 ldr r3, [r0, #16]
switch( node->type ) {
9214: e2422001 sub r2, r2, #1
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
9218: e5933034 ldr r3, [r3, #52] ; 0x34
switch( node->type ) {
921c: e3520006 cmp r2, #6
9220: 979ff102 ldrls pc, [pc, r2, lsl #2]
9224: ea000010 b 926c <IMFS_Set_handlers+0x64> <== NOT EXECUTED
9228: 00009244 .word 0x00009244 <== NOT EXECUTED
922c: 0000924c .word 0x0000924c <== NOT EXECUTED
9230: 00009254 .word 0x00009254 <== NOT EXECUTED
9234: 00009254 .word 0x00009254 <== NOT EXECUTED
9238: 0000925c .word 0x0000925c <== NOT EXECUTED
923c: 0000925c .word 0x0000925c <== NOT EXECUTED
9240: 00009264 .word 0x00009264 <== NOT EXECUTED
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
9244: e593300c ldr r3, [r3, #12]
9248: ea000006 b 9268 <IMFS_Set_handlers+0x60>
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
924c: e59f3020 ldr r3, [pc, #32] ; 9274 <IMFS_Set_handlers+0x6c>
9250: ea000004 b 9268 <IMFS_Set_handlers+0x60>
break;
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
9254: e59f301c ldr r3, [pc, #28] ; 9278 <IMFS_Set_handlers+0x70>
9258: ea000002 b 9268 <IMFS_Set_handlers+0x60>
break;
case IMFS_LINEAR_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
925c: e5933008 ldr r3, [r3, #8]
9260: ea000000 b 9268 <IMFS_Set_handlers+0x60>
break;
case IMFS_FIFO:
loc->handlers = &IMFS_fifo_handlers;
9264: e59f3010 ldr r3, [pc, #16] ; 927c <IMFS_Set_handlers+0x74>
9268: e5803008 str r3, [r0, #8]
break;
}
return 0;
}
926c: e3a00000 mov r0, #0
9270: e12fff1e bx lr
000090cc <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
90cc: 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 )
90d0: e2504000 subs r4, r0, #0
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
90d4: e1a05001 mov r5, r1
90d8: e59d6014 ldr r6, [sp, #20]
90dc: e1a01002 mov r1, r2
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
90e0: 01a07004 moveq r7, r4
90e4: 0a000041 beq 91f0 <IMFS_create_node+0x124>
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
90e8: e59f2108 ldr r2, [pc, #264] ; 91f8 <IMFS_create_node+0x12c>
90ec: e5922000 ldr r2, [r2]
90f0: e592202c ldr r2, [r2, #44] ; 0x2c
90f4: e1a00005 mov r0, r5
90f8: e1c32002 bic r2, r3, r2
90fc: ebffffc5 bl 9018 <IMFS_allocate_node>
if ( !node )
9100: e2507000 subs r7, r0, #0
9104: 0a000039 beq 91f0 <IMFS_create_node+0x124>
return NULL;
/*
* Set the type specific information
*/
switch (type) {
9108: e2455001 sub r5, r5, #1
910c: e3550006 cmp r5, #6
9110: 979ff105 ldrls pc, [pc, r5, lsl #2]
9114: ea000025 b 91b0 <IMFS_create_node+0xe4> <== NOT EXECUTED
9118: 00009134 .word 0x00009134 <== NOT EXECUTED
911c: 00009158 .word 0x00009158 <== NOT EXECUTED
9120: 00009150 .word 0x00009150 <== NOT EXECUTED
9124: 00009150 .word 0x00009150 <== NOT EXECUTED
9128: 00009180 .word 0x00009180 <== NOT EXECUTED
912c: 00009168 .word 0x00009168 <== NOT EXECUTED
9130: 000091a4 .word 0x000091a4 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
9134: e2872054 add r2, r7, #84 ; 0x54
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
9138: e2873050 add r3, r7, #80 ; 0x50
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
913c: e5872050 str r2, [r7, #80] ; 0x50
the_chain->permanent_null = NULL;
9140: e3a02000 mov r2, #0
9144: e5872054 str r2, [r7, #84] ; 0x54
the_chain->last = _Chain_Head(the_chain);
9148: e5873058 str r3, [r7, #88] ; 0x58
914c: ea00001c b 91c4 <IMFS_create_node+0xf8>
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;
9150: e5963000 ldr r3, [r6]
9154: ea000013 b 91a8 <IMFS_create_node+0xdc>
break;
case IMFS_DEVICE:
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
9158: 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;
915c: e5963000 ldr r3, [r6]
node->info.device.minor = info->device.minor;
9160: e5872054 str r2, [r7, #84] ; 0x54
9164: ea00000f b 91a8 <IMFS_create_node+0xdc>
break;
case IMFS_LINEAR_FILE:
node->info.linearfile.size = 0;
9168: e3a03000 mov r3, #0 <== NOT EXECUTED
916c: e3a02000 mov r2, #0 <== NOT EXECUTED
9170: e5872050 str r2, [r7, #80] ; 0x50 <== NOT EXECUTED
9174: e5873054 str r3, [r7, #84] ; 0x54 <== NOT EXECUTED
node->info.linearfile.direct = 0;
9178: e3a03000 mov r3, #0 <== NOT EXECUTED
917c: e5873058 str r3, [r7, #88] ; 0x58 <== NOT EXECUTED
case IMFS_MEMORY_FILE:
node->info.file.size = 0;
node->info.file.indirect = 0;
9180: 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;
9184: e3a01000 mov r1, #0
9188: e3a02000 mov r2, #0
918c: e5871050 str r1, [r7, #80] ; 0x50
9190: e5872054 str r2, [r7, #84] ; 0x54
node->info.file.indirect = 0;
node->info.file.doubly_indirect = 0;
node->info.file.triply_indirect = 0;
9194: 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;
9198: e5873058 str r3, [r7, #88] ; 0x58
node->info.file.doubly_indirect = 0;
919c: e587305c str r3, [r7, #92] ; 0x5c
node->info.file.triply_indirect = 0;
break;
91a0: ea000007 b 91c4 <IMFS_create_node+0xf8>
case IMFS_FIFO:
node->info.fifo.pipe = NULL;
91a4: e3a03000 mov r3, #0
91a8: e5873050 str r3, [r7, #80] ; 0x50
break;
91ac: ea000004 b 91c4 <IMFS_create_node+0xf8>
default:
assert(0);
91b0: e59f0044 ldr r0, [pc, #68] ; 91fc <IMFS_create_node+0x130> <== NOT EXECUTED
91b4: e3a0105c mov r1, #92 ; 0x5c <== NOT EXECUTED
91b8: e59f2040 ldr r2, [pc, #64] ; 9200 <IMFS_create_node+0x134> <== NOT EXECUTED
91bc: e59f3040 ldr r3, [pc, #64] ; 9204 <IMFS_create_node+0x138> <== NOT EXECUTED
91c0: eb000391 bl a00c <__assert_func> <== NOT EXECUTED
/*
* 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;
91c4: e5943010 ldr r3, [r4, #16]
91c8: e5932034 ldr r2, [r3, #52] ; 0x34
node->Parent = parent;
node->st_ino = ++fs_info->ino_count;
91cc: e5923004 ldr r3, [r2, #4]
}
/*
* This node MUST have a parent, so put it in that directory list.
*/
parent = parent_loc->node_access;
91d0: e5940000 ldr r0, [r4]
fs_info = parent_loc->mt_entry->fs_info;
node->Parent = parent;
node->st_ino = ++fs_info->ino_count;
91d4: e2833001 add r3, r3, #1
91d8: 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;
91dc: e5870008 str r0, [r7, #8]
node->st_ino = ++fs_info->ino_count;
91e0: e5873038 str r3, [r7, #56] ; 0x38
91e4: e2800050 add r0, r0, #80 ; 0x50
91e8: e1a01007 mov r1, r7
91ec: ebfff215 bl 5a48 <_Chain_Append>
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
}
91f0: e1a00007 mov r0, r7
91f4: e8bd80f0 pop {r4, r5, r6, r7, pc}
00003e30 <IMFS_dump_directory>:
rtems_chain_node *the_node;
rtems_chain_control *the_chain;
IMFS_jnode_t *the_jnode;
int i;
assert( the_directory );
3e30: e3500000 cmp r0, #0
void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
3e34: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
3e38: e1a05001 mov r5, r1
rtems_chain_node *the_node;
rtems_chain_control *the_chain;
IMFS_jnode_t *the_jnode;
int i;
assert( the_directory );
3e3c: 059f00a4 ldreq r0, [pc, #164] ; 3ee8 <IMFS_dump_directory+0xb8>
3e40: 03a01084 moveq r1, #132 ; 0x84
3e44: 059f20a0 ldreq r2, [pc, #160] ; 3eec <IMFS_dump_directory+0xbc>
3e48: 059f30a0 ldreq r3, [pc, #160] ; 3ef0 <IMFS_dump_directory+0xc0>
3e4c: 0a000005 beq 3e68 <IMFS_dump_directory+0x38>
assert( level >= 0 );
3e50: e3510000 cmp r1, #0
3e54: aa000004 bge 3e6c <IMFS_dump_directory+0x3c>
3e58: e59f0088 ldr r0, [pc, #136] ; 3ee8 <IMFS_dump_directory+0xb8><== NOT EXECUTED
3e5c: e59f2088 ldr r2, [pc, #136] ; 3eec <IMFS_dump_directory+0xbc><== NOT EXECUTED
3e60: e59f308c ldr r3, [pc, #140] ; 3ef4 <IMFS_dump_directory+0xc4><== NOT EXECUTED
3e64: e3a01086 mov r1, #134 ; 0x86 <== NOT EXECUTED
3e68: eb000216 bl 46c8 <__assert_func> <== NOT EXECUTED
assert( the_directory->type == IMFS_DIRECTORY );
3e6c: e590304c ldr r3, [r0, #76] ; 0x4c
3e70: e3530001 cmp r3, #1
3e74: 159f006c ldrne r0, [pc, #108] ; 3ee8 <IMFS_dump_directory+0xb8>
3e78: 13a01088 movne r1, #136 ; 0x88
3e7c: 159f2068 ldrne r2, [pc, #104] ; 3eec <IMFS_dump_directory+0xbc>
3e80: 159f3070 ldrne r3, [pc, #112] ; 3ef8 <IMFS_dump_directory+0xc8>
3e84: 1afffff7 bne 3e68 <IMFS_dump_directory+0x38>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
3e88: e280a054 add sl, r0, #84 ; 0x54
the_chain = &the_directory->info.directory.Entries;
for ( the_node = the_chain->first;
3e8c: e5904050 ldr r4, [r0, #80] ; 0x50
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
3e90: e59f8064 ldr r8, [pc, #100] ; 3efc <IMFS_dump_directory+0xcc>
IMFS_print_jnode( the_jnode );
if ( the_jnode->type == IMFS_DIRECTORY )
IMFS_dump_directory( the_jnode, level + 1 );
3e94: e2817001 add r7, r1, #1
assert( the_directory->type == IMFS_DIRECTORY );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = the_chain->first;
3e98: ea00000f b 3edc <IMFS_dump_directory+0xac>
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
3e9c: e3a06000 mov r6, #0
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
3ea0: e5983000 ldr r3, [r8]
!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++ )
3ea4: e2866001 add r6, r6, #1
fprintf(stdout, "...." );
3ea8: e5931008 ldr r1, [r3, #8]
3eac: e59f004c ldr r0, [pc, #76] ; 3f00 <IMFS_dump_directory+0xd0>
3eb0: eb0036d4 bl 11a08 <fputs>
!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++ )
3eb4: e1560005 cmp r6, r5
3eb8: dafffff8 ble 3ea0 <IMFS_dump_directory+0x70>
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
3ebc: e1a00004 mov r0, r4
3ec0: ebffff7e bl 3cc0 <IMFS_print_jnode>
if ( the_jnode->type == IMFS_DIRECTORY )
3ec4: e594304c ldr r3, [r4, #76] ; 0x4c
3ec8: e3530001 cmp r3, #1
IMFS_dump_directory( the_jnode, level + 1 );
3ecc: 01a00004 moveq r0, r4
3ed0: 01a01007 moveq r1, r7
3ed4: 0bffffd5 bleq 3e30 <IMFS_dump_directory>
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 ) {
3ed8: e5944000 ldr r4, [r4]
assert( the_directory->type == IMFS_DIRECTORY );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = the_chain->first;
3edc: e154000a cmp r4, sl
3ee0: 1affffed bne 3e9c <IMFS_dump_directory+0x6c>
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( the_jnode->type == IMFS_DIRECTORY )
IMFS_dump_directory( the_jnode, level + 1 );
}
}
3ee4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
000093cc <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
93cc: 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 ) ) {
93d0: e3d27007 bics r7, r2, #7
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
93d4: e24dd028 sub sp, sp, #40 ; 0x28
93d8: e1a0a002 mov sl, r2
93dc: e1a08000 mov r8, r0
93e0: e1a06001 mov r6, r1
93e4: e1a04003 mov r4, r3
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
93e8: 05935000 ldreq r5, [r3]
93ec: 03a09001 moveq r9, #1
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 ) ) {
93f0: 0a000084 beq 9608 <IMFS_eval_path+0x23c>
assert( 0 );
93f4: e59f02b4 ldr r0, [pc, #692] ; 96b0 <IMFS_eval_path+0x2e4> <== NOT EXECUTED
93f8: e3a01f82 mov r1, #520 ; 0x208 <== NOT EXECUTED
93fc: e59f22b0 ldr r2, [pc, #688] ; 96b4 <IMFS_eval_path+0x2e8> <== NOT EXECUTED
9400: e59f32b0 ldr r3, [pc, #688] ; 96b8 <IMFS_eval_path+0x2ec> <== NOT EXECUTED
9404: eb000300 bl a00c <__assert_func> <== NOT EXECUTED
* 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 );
9408: e28d3024 add r3, sp, #36 ; 0x24
940c: e0880007 add r0, r8, r7
9410: e1a01006 mov r1, r6
9414: e1a0200d mov r2, sp
9418: eb000260 bl 9da0 <IMFS_get_token>
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
941c: e5943000 ldr r3, [r4]
9420: 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 );
9424: e1a09000 mov r9, r0
pathnamelen -= len;
9428: e59db024 ldr fp, [sp, #36] ; 0x24
i += len;
if ( !pathloc->node_access )
942c: 0a000044 beq 9544 <IMFS_eval_path+0x178>
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
9430: e3500000 cmp r0, #0
9434: 0a000006 beq 9454 <IMFS_eval_path+0x88>
if ( node->type == IMFS_DIRECTORY )
9438: e595104c ldr r1, [r5, #76] ; 0x4c
943c: e3510001 cmp r1, #1
9440: 1a000003 bne 9454 <IMFS_eval_path+0x88>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
9444: e1a00004 mov r0, r4
9448: ebffff8c bl 9280 <IMFS_evaluate_permission>
944c: e3500000 cmp r0, #0
9450: 0a00008f beq 9694 <IMFS_eval_path+0x2c8>
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
9454: e3590003 cmp r9, #3
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
i += len;
9458: e087700b add r7, r7, fp
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
945c: e06b6006 rsb r6, fp, r6
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;
9460: e5945000 ldr r5, [r4]
switch( type ) {
9464: 0a000018 beq 94cc <IMFS_eval_path+0x100>
9468: e3590004 cmp r9, #4
946c: 0a000062 beq 95fc <IMFS_eval_path+0x230>
9470: e3590002 cmp r9, #2
9474: 1a000063 bne 9608 <IMFS_eval_path+0x23c>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
9478: e59f223c ldr r2, [pc, #572] ; 96bc <IMFS_eval_path+0x2f0>
947c: e5923000 ldr r3, [r2]
9480: e5933018 ldr r3, [r3, #24]
9484: e1550003 cmp r5, r3
9488: 0a00005e beq 9608 <IMFS_eval_path+0x23c>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
pathloc->mt_entry->mt_fs_root.node_access) {
948c: e594c010 ldr ip, [r4, #16]
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
9490: e59c301c ldr r3, [ip, #28]
9494: e1550003 cmp r5, r3
9498: 1a000005 bne 94b4 <IMFS_eval_path+0xe8>
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
949c: e28cc008 add ip, ip, #8
94a0: e8bc000f ldm ip!, {r0, r1, r2, r3}
94a4: e1a05004 mov r5, r4
94a8: e8a5000f stmia r5!, {r0, r1, r2, r3}
94ac: e1a03005 mov r3, r5
94b0: ea000062 b 9640 <IMFS_eval_path+0x274>
return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
94b4: e5955008 ldr r5, [r5, #8]
94b8: e3550000 cmp r5, #0
94bc: 1a00004c bne 95f4 <IMFS_eval_path+0x228>
rtems_set_errno_and_return_minus_one( ENOENT );
94c0: eb000fbf bl d3c4 <__errno>
94c4: e5809000 str r9, [r0]
94c8: ea000074 b 96a0 <IMFS_eval_path+0x2d4>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
94cc: e595304c ldr r3, [r5, #76] ; 0x4c
94d0: e3530003 cmp r3, #3
94d4: 1a000006 bne 94f4 <IMFS_eval_path+0x128>
IMFS_evaluate_hard_link( pathloc, 0 );
94d8: e1a00004 mov r0, r4
94dc: e3a01000 mov r1, #0
94e0: ebffff76 bl 92c0 <IMFS_evaluate_hard_link>
node = pathloc->node_access;
94e4: e5945000 ldr r5, [r4]
if ( !node )
94e8: e3550000 cmp r5, #0
94ec: 1a000009 bne 9518 <IMFS_eval_path+0x14c>
94f0: ea00000b b 9524 <IMFS_eval_path+0x158> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTDIR );
} else if ( node->type == IMFS_SYM_LINK ) {
94f4: e3530004 cmp r3, #4
94f8: 1a000006 bne 9518 <IMFS_eval_path+0x14c>
result = IMFS_evaluate_sym_link( pathloc, 0 );
94fc: e1a00004 mov r0, r4
9500: e3a01000 mov r1, #0
9504: ebffff84 bl 931c <IMFS_evaluate_sym_link>
node = pathloc->node_access;
if ( result == -1 )
9508: 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 );
950c: e1a0b000 mov fp, r0
node = pathloc->node_access;
9510: e5945000 ldr r5, [r4]
if ( result == -1 )
9514: 0a000062 beq 96a4 <IMFS_eval_path+0x2d8>
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
9518: e595304c ldr r3, [r5, #76] ; 0x4c
951c: e3530001 cmp r3, #1
9520: 0a000002 beq 9530 <IMFS_eval_path+0x164>
rtems_set_errno_and_return_minus_one( ENOTDIR );
9524: eb000fa6 bl d3c4 <__errno>
9528: e3a03014 mov r3, #20
952c: ea00005a b 969c <IMFS_eval_path+0x2d0>
/*
* Find the token name in the current node.
*/
node = IMFS_find_match_in_dir( node, token );
9530: e1a00005 mov r0, r5
9534: e1a0100d mov r1, sp
9538: eb0001f0 bl 9d00 <IMFS_find_match_in_dir>
if ( !node )
953c: e2505000 subs r5, r0, #0
9540: 1a000002 bne 9550 <IMFS_eval_path+0x184>
rtems_set_errno_and_return_minus_one( ENOENT );
9544: eb000f9e bl d3c4 <__errno>
9548: e3a03002 mov r3, #2
954c: ea000052 b 969c <IMFS_eval_path+0x2d0>
* 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 )) {
9550: e595304c ldr r3, [r5, #76] ; 0x4c
9554: e3530001 cmp r3, #1
9558: 1a000025 bne 95f4 <IMFS_eval_path+0x228>
955c: e595305c ldr r3, [r5, #92] ; 0x5c
9560: e3530000 cmp r3, #0
9564: 1088b007 addne fp, r8, r7
9568: 1a000002 bne 9578 <IMFS_eval_path+0x1ac>
956c: ea000020 b 95f4 <IMFS_eval_path+0x228>
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
++(*index);
9570: e2877001 add r7, r7, #1
--(*len);
9574: e2466001 sub r6, r6, #1
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
9578: e5db0000 ldrb r0, [fp]
957c: ebffe60b bl 2db0 <rtems_filesystem_is_separator>
9580: e3500000 cmp r0, #0
++(*index);
--(*len);
9584: 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 ) {
9588: 0a000005 beq 95a4 <IMFS_eval_path+0x1d8>
958c: e5db3000 ldrb r3, [fp]
9590: e3530000 cmp r3, #0
9594: 0a000002 beq 95a4 <IMFS_eval_path+0x1d8>
9598: e3560000 cmp r6, #0
959c: e28bb001 add fp, fp, #1
95a0: 1afffff2 bne 9570 <IMFS_eval_path+0x1a4>
* 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] != '.')) {
95a4: e5dc3000 ldrb r3, [ip]
95a8: e353002e cmp r3, #46 ; 0x2e
95ac: 1a000003 bne 95c0 <IMFS_eval_path+0x1f4>
95b0: e0883007 add r3, r8, r7
95b4: e5d33001 ldrb r3, [r3, #1]
95b8: e353002e cmp r3, #46 ; 0x2e
95bc: 0a000009 beq 95e8 <IMFS_eval_path+0x21c>
*pathloc = node->info.directory.mt_fs->mt_fs_root;
95c0: e595e05c ldr lr, [r5, #92] ; 0x5c
95c4: e28ee01c add lr, lr, #28
95c8: e8be000f ldm lr!, {r0, r1, r2, r3}
95cc: e1a05004 mov r5, r4
95d0: e8a5000f stmia r5!, {r0, r1, r2, r3}
95d4: e59e2000 ldr r2, [lr]
return (*pathloc->ops->evalpath_h)( &pathname[i],
95d8: 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;
95dc: e5852000 str r2, [r5]
return (*pathloc->ops->evalpath_h)( &pathname[i],
95e0: e1a01006 mov r1, r6
95e4: ea00001b b 9658 <IMFS_eval_path+0x28c>
pathnamelen,
flags, pathloc );
}
i += 2;
pathnamelen -= 2;
node = node->Parent;
95e8: e5955008 ldr r5, [r5, #8]
*pathloc = node->info.directory.mt_fs->mt_fs_root;
return (*pathloc->ops->evalpath_h)( &pathname[i],
pathnamelen,
flags, pathloc );
}
i += 2;
95ec: e2877002 add r7, r7, #2
pathnamelen -= 2;
95f0: e2466002 sub r6, r6, #2
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
95f4: e5845000 str r5, [r4]
95f8: ea000002 b 9608 <IMFS_eval_path+0x23c>
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
95fc: eb000f70 bl d3c4 <__errno>
9600: e3a0305b mov r3, #91 ; 0x5b
9604: ea000024 b 969c <IMFS_eval_path+0x2d0>
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
9608: e3590004 cmp r9, #4
960c: 13590000 cmpne r9, #0
9610: 1affff7c bne 9408 <IMFS_eval_path+0x3c>
* 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 ) {
9614: e595304c ldr r3, [r5, #76] ; 0x4c
9618: e3530001 cmp r3, #1
961c: 1a000014 bne 9674 <IMFS_eval_path+0x2a8>
if ( node->info.directory.mt_fs != NULL ) {
9620: e595c05c ldr ip, [r5, #92] ; 0x5c
9624: e35c0000 cmp ip, #0
9628: 0a000011 beq 9674 <IMFS_eval_path+0x2a8>
*pathloc = node->info.directory.mt_fs->mt_fs_root;
962c: e28cc01c add ip, ip, #28 <== NOT EXECUTED
9630: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
9634: e1a0e004 mov lr, r4 <== NOT EXECUTED
9638: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
963c: e1a0300e mov r3, lr <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
9640: e59d1024 ldr r1, [sp, #36] ; 0x24
* 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;
9644: e59c2000 ldr r2, [ip]
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
9648: e0610007 rsb r0, r1, r7
* 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;
964c: e5832000 str r2, [r3]
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
9650: e0880000 add r0, r8, r0
9654: e0861001 add r1, r6, r1
9658: e1a0200a mov r2, sl
965c: e1a03004 mov r3, r4
9660: e594c00c ldr ip, [r4, #12]
9664: e1a0e00f mov lr, pc
9668: e59cf000 ldr pc, [ip]
966c: e1a0b000 mov fp, r0
9670: ea00000b b 96a4 <IMFS_eval_path+0x2d8>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
9674: e1a00004 mov r0, r4
9678: ebfffee2 bl 9208 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
967c: e1a0100a mov r1, sl
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
9680: e1a0b000 mov fp, r0
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
9684: e1a00004 mov r0, r4
9688: ebfffefc bl 9280 <IMFS_evaluate_permission>
968c: e3500000 cmp r0, #0
9690: 1a000003 bne 96a4 <IMFS_eval_path+0x2d8>
rtems_set_errno_and_return_minus_one( EACCES );
9694: eb000f4a bl d3c4 <__errno>
9698: e3a0300d mov r3, #13
969c: e5803000 str r3, [r0]
96a0: e3e0b000 mvn fp, #0
return result;
}
96a4: e1a0000b mov r0, fp
96a8: e28dd028 add sp, sp, #40 ; 0x28
96ac: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00009774 <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 */
)
{
9774: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
9778: e24dd028 sub sp, sp, #40 ; 0x28
977c: e1a04001 mov r4, r1
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
9780: 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 */
)
{
9784: e1a0a002 mov sl, r2
9788: e1a08000 mov r8, r0
node = pathloc->node_access;
/*
* Get the path length.
*/
pathlen = strlen( path );
978c: eb001311 bl e3d8 <strlen>
9790: e3a05000 mov r5, #0
9794: e1a07000 mov r7, r0
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
9798: e28d3024 add r3, sp, #36 ; 0x24
979c: e0880005 add r0, r8, r5
97a0: e1a01007 mov r1, r7
97a4: e1a0200d mov r2, sp
97a8: eb00017c bl 9da0 <IMFS_get_token>
pathlen -= len;
i += len;
if ( !pathloc->node_access )
97ac: e5943000 ldr r3, [r4]
97b0: 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 );
97b4: e1a09000 mov r9, r0
pathlen -= len;
97b8: e59db024 ldr fp, [sp, #36] ; 0x24
i += len;
if ( !pathloc->node_access )
97bc: 0a000080 beq 99c4 <IMFS_evaluate_for_make+0x250>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
97c0: e3500000 cmp r0, #0
97c4: 0a000006 beq 97e4 <IMFS_evaluate_for_make+0x70>
if ( node->type == IMFS_DIRECTORY )
97c8: e596104c ldr r1, [r6, #76] ; 0x4c
97cc: e3510001 cmp r1, #1
97d0: 1a000003 bne 97e4 <IMFS_evaluate_for_make+0x70>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
97d4: e1a00004 mov r0, r4
97d8: ebfffea8 bl 9280 <IMFS_evaluate_permission>
97dc: e3500000 cmp r0, #0
97e0: 0a00008c beq 9a18 <IMFS_evaluate_for_make+0x2a4>
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
97e4: e5943000 ldr r3, [r4]
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
97e8: e085500b add r5, r5, fp
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
97ec: e06b7007 rsb r7, fp, r7
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;
97f0: e1a06003 mov r6, r3
switch( type ) {
97f4: e3590004 cmp r9, #4
97f8: 979ff109 ldrls pc, [pc, r9, lsl #2]
97fc: eaffffe5 b 9798 <IMFS_evaluate_for_make+0x24> <== NOT EXECUTED
9800: 00009984 .word 0x00009984 <== NOT EXECUTED
9804: 00009798 .word 0x00009798 <== NOT EXECUTED
9808: 00009814 .word 0x00009814 <== NOT EXECUTED
980c: 00009870 .word 0x00009870 <== NOT EXECUTED
9810: 00009990 .word 0x00009990 <== NOT EXECUTED
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
9814: e59f1218 ldr r1, [pc, #536] ; 9a34 <IMFS_evaluate_for_make+0x2c0>
9818: e5912000 ldr r2, [r1]
981c: e5922018 ldr r2, [r2, #24]
9820: e1530002 cmp r3, r2
9824: 0affffdb beq 9798 <IMFS_evaluate_for_make+0x24>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
9828: e594c010 ldr ip, [r4, #16]
982c: e59c201c ldr r2, [ip, #28]
9830: e1530002 cmp r3, r2
9834: 1a000009 bne 9860 <IMFS_evaluate_for_make+0xec>
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
9838: e28cc008 add ip, ip, #8
983c: e8bc000f ldm ip!, {r0, r1, r2, r3}
9840: e1a0e004 mov lr, r4
9844: e8ae000f stmia lr!, {r0, r1, r2, r3}
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
9848: e59d3024 ldr r3, [sp, #36] ; 0x24
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
984c: e59c2000 ldr r2, [ip]
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
9850: e0635005 rsb r5, r3, r5
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
9854: e58e2000 str r2, [lr]
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
9858: e0880005 add r0, r8, r5
985c: ea00003c b 9954 <IMFS_evaluate_for_make+0x1e0>
}
} else {
if ( !node->Parent )
9860: e5936008 ldr r6, [r3, #8]
9864: e3560000 cmp r6, #0
9868: 1a000043 bne 997c <IMFS_evaluate_for_make+0x208>
986c: ea000054 b 99c4 <IMFS_evaluate_for_make+0x250>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
9870: e593304c ldr r3, [r3, #76] ; 0x4c
9874: e3530003 cmp r3, #3
9878: 0a000001 beq 9884 <IMFS_evaluate_for_make+0x110>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
987c: e3530004 cmp r3, #4
9880: 1a000005 bne 989c <IMFS_evaluate_for_make+0x128>
result = IMFS_evaluate_link( pathloc, 0 );
9884: e1a00004 mov r0, r4
9888: e3a01000 mov r1, #0
988c: ebffff8b bl 96c0 <IMFS_evaluate_link>
if ( result == -1 )
9890: e3700001 cmn r0, #1
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
9894: e1a06000 mov r6, r0
if ( result == -1 )
9898: 0a000062 beq 9a28 <IMFS_evaluate_for_make+0x2b4>
return -1;
}
node = pathloc->node_access;
989c: e5940000 ldr r0, [r4]
if ( !node )
98a0: e3500000 cmp r0, #0
98a4: 0a000053 beq 99f8 <IMFS_evaluate_for_make+0x284>
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
98a8: e590304c ldr r3, [r0, #76] ; 0x4c
98ac: e3530001 cmp r3, #1
98b0: 1a000050 bne 99f8 <IMFS_evaluate_for_make+0x284>
/*
* Find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
98b4: e1a0100d mov r1, sp
98b8: eb000110 bl 9d00 <IMFS_find_match_in_dir>
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
98bc: e2506000 subs r6, r0, #0
98c0: 0a000035 beq 999c <IMFS_evaluate_for_make+0x228>
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
98c4: e596304c ldr r3, [r6, #76] ; 0x4c
98c8: e3530001 cmp r3, #1
98cc: 1a00002a bne 997c <IMFS_evaluate_for_make+0x208>
98d0: e596305c ldr r3, [r6, #92] ; 0x5c
98d4: e3530000 cmp r3, #0
98d8: 10889005 addne r9, r8, r5
98dc: 1a000002 bne 98ec <IMFS_evaluate_for_make+0x178>
98e0: ea000025 b 997c <IMFS_evaluate_for_make+0x208>
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
++(*index);
98e4: e2855001 add r5, r5, #1
--(*len);
98e8: e2477001 sub r7, r7, #1
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
98ec: e5d90000 ldrb r0, [r9]
98f0: ebffe52e bl 2db0 <rtems_filesystem_is_separator>
98f4: e3500000 cmp r0, #0
++(*index);
--(*len);
98f8: 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 ) {
98fc: 0a000005 beq 9918 <IMFS_evaluate_for_make+0x1a4>
9900: e5d93000 ldrb r3, [r9]
9904: e3530000 cmp r3, #0
9908: 0a000002 beq 9918 <IMFS_evaluate_for_make+0x1a4>
990c: e3570000 cmp r7, #0
9910: e2899001 add r9, r9, #1
9914: 1afffff2 bne 98e4 <IMFS_evaluate_for_make+0x170>
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] != '.')) {
9918: e5dc3000 ldrb r3, [ip]
991c: e353002e cmp r3, #46 ; 0x2e
9920: 1a000003 bne 9934 <IMFS_evaluate_for_make+0x1c0>
9924: e0883005 add r3, r8, r5
9928: e5d33001 ldrb r3, [r3, #1]
992c: e353002e cmp r3, #46 ; 0x2e
9930: 0a00000e beq 9970 <IMFS_evaluate_for_make+0x1fc>
*pathloc = node->info.directory.mt_fs->mt_fs_root;
9934: e596e05c ldr lr, [r6, #92] ; 0x5c
9938: e28ee01c add lr, lr, #28
993c: e8be000f ldm lr!, {r0, r1, r2, r3}
9940: e1a05004 mov r5, r4
9944: e8a5000f stmia r5!, {r0, r1, r2, r3}
9948: e59e2000 ldr r2, [lr]
994c: e5852000 str r2, [r5]
return (*pathloc->ops->evalformake_h)( &path[i],
9950: e1a0000c mov r0, ip
9954: e1a01004 mov r1, r4
9958: e1a0200a mov r2, sl
995c: e594300c ldr r3, [r4, #12]
9960: e1a0e00f mov lr, pc
9964: e593f004 ldr pc, [r3, #4]
9968: e1a06000 mov r6, r0
996c: ea00002d b 9a28 <IMFS_evaluate_for_make+0x2b4>
pathloc,
name );
}
i += 2;
pathlen -= 2;
node = node->Parent;
9970: 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;
9974: e2855002 add r5, r5, #2
pathlen -= 2;
9978: e2477002 sub r7, r7, #2
node = node->Parent;
}
pathloc->node_access = node;
997c: e5846000 str r6, [r4]
9980: eaffff84 b 9798 <IMFS_evaluate_for_make+0x24>
}
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
9984: eb000e8e bl d3c4 <__errno>
9988: e3a03011 mov r3, #17
998c: ea000023 b 9a20 <IMFS_evaluate_for_make+0x2ac>
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
9990: eb000e8b bl d3c4 <__errno>
9994: e3a0305b mov r3, #91 ; 0x5b
9998: ea000020 b 9a20 <IMFS_evaluate_for_make+0x2ac>
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
999c: e59d3024 ldr r3, [sp, #36] ; 0x24
99a0: e0633005 rsb r3, r3, r5
99a4: e0883003 add r3, r8, r3
99a8: e58a3000 str r3, [sl]
99ac: e0885005 add r5, r8, r5
/*
* 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++) {
99b0: ea000006 b 99d0 <IMFS_evaluate_for_make+0x25c>
if ( !IMFS_is_separator( path[ i ] ) )
99b4: ebffe4fd bl 2db0 <rtems_filesystem_is_separator>
99b8: e3500000 cmp r0, #0
99bc: e2855001 add r5, r5, #1
99c0: 1a000002 bne 99d0 <IMFS_evaluate_for_make+0x25c>
rtems_set_errno_and_return_minus_one( ENOENT );
99c4: eb000e7e bl d3c4 <__errno>
99c8: e3a03002 mov r3, #2
99cc: ea000013 b 9a20 <IMFS_evaluate_for_make+0x2ac>
/*
* 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++) {
99d0: e5d53000 ldrb r3, [r5]
99d4: e2530000 subs r0, r3, #0
99d8: 1afffff5 bne 99b4 <IMFS_evaluate_for_make+0x240>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
99dc: e1a00004 mov r0, r4
99e0: ebfffe08 bl 9208 <IMFS_Set_handlers>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
99e4: e5943000 ldr r3, [r4]
99e8: e593304c ldr r3, [r3, #76] ; 0x4c
99ec: e3530001 cmp r3, #1
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
99f0: e1a06000 mov r6, r0
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
99f4: 0a000002 beq 9a04 <IMFS_evaluate_for_make+0x290>
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
99f8: eb000e71 bl d3c4 <__errno>
99fc: e3a03014 mov r3, #20
9a00: ea000006 b 9a20 <IMFS_evaluate_for_make+0x2ac>
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
9a04: e1a00004 mov r0, r4
9a08: e3a01003 mov r1, #3
9a0c: ebfffe1b bl 9280 <IMFS_evaluate_permission>
9a10: e3500000 cmp r0, #0
9a14: 1a000003 bne 9a28 <IMFS_evaluate_for_make+0x2b4>
rtems_set_errno_and_return_minus_one( EACCES );
9a18: eb000e69 bl d3c4 <__errno>
9a1c: e3a0300d mov r3, #13
9a20: e5803000 str r3, [r0]
9a24: e3e06000 mvn r6, #0
return result;
}
9a28: e1a00006 mov r0, r6
9a2c: e28dd028 add sp, sp, #40 ; 0x28
9a30: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
000092c0 <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;
92c0: e5903000 ldr r3, [r0]
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_HARD_LINK )
92c4: e593204c ldr r2, [r3, #76] ; 0x4c
92c8: e3520003 cmp r2, #3
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
92cc: e92d4030 push {r4, r5, lr}
92d0: e1a04000 mov r4, r0
92d4: e1a05001 mov r5, r1
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_HARD_LINK )
rtems_fatal_error_occurred (0xABCD0000);
92d8: 159f0038 ldrne r0, [pc, #56] ; 9318 <IMFS_evaluate_hard_link+0x58>
92dc: 1bfff131 blne 57a8 <rtems_fatal_error_occurred>
/*
* Set the hard link value and the handlers.
*/
node->node_access = jnode->info.hard_link.link_node;
92e0: e5933050 ldr r3, [r3, #80] ; 0x50
92e4: e5803000 str r3, [r0]
IMFS_Set_handlers( node );
92e8: ebffffc6 bl 9208 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
92ec: e1a00004 mov r0, r4
92f0: e1a01005 mov r1, r5
92f4: ebffffe1 bl 9280 <IMFS_evaluate_permission>
92f8: e3500000 cmp r0, #0
92fc: 13a00000 movne r0, #0
9300: 18bd8030 popne {r4, r5, pc}
rtems_set_errno_and_return_minus_one( EACCES );
9304: eb00102e bl d3c4 <__errno> <== NOT EXECUTED
9308: e3a0300d mov r3, #13 <== NOT EXECUTED
930c: e5803000 str r3, [r0] <== NOT EXECUTED
9310: e3e00000 mvn r0, #0 <== NOT EXECUTED
return result;
}
9314: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00009280 <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 ) )
9280: e3d13007 bics r3, r1, #7
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
9284: 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 ) )
9288: 0a000004 beq 92a0 <IMFS_evaluate_permission+0x20>
rtems_set_errno_and_return_minus_one( EPERM );
928c: eb00104c bl d3c4 <__errno> <== NOT EXECUTED
9290: e3a03001 mov r3, #1 <== NOT EXECUTED
9294: e5803000 str r3, [r0] <== NOT EXECUTED
9298: e3e00000 mvn r0, #0 <== NOT EXECUTED
929c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
92a0: e5903000 ldr r3, [r0]
92a4: e5930030 ldr r0, [r3, #48] ; 0x30
92a8: e1a01301 lsl r1, r1, #6
92ac: e0010000 and r0, r1, r0
92b0: e1500001 cmp r0, r1
92b4: 13a00000 movne r0, #0
92b8: 03a00001 moveq r0, #1
return 1;
return 0;
}
92bc: e49df004 pop {pc} ; (ldr pc, [sp], #4)
0000931c <IMFS_evaluate_sym_link>:
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
931c: e92d4071 push {r0, r4, r5, r6, lr}
IMFS_jnode_t *jnode = node->node_access;
9320: e5906000 ldr r6, [r0]
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_SYM_LINK )
9324: e596304c ldr r3, [r6, #76] ; 0x4c
9328: e3530004 cmp r3, #4
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
932c: e1a04000 mov r4, r0
9330: e1a05001 mov r5, r1
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_SYM_LINK )
rtems_fatal_error_occurred (0xABCD0000);
9334: 159f0088 ldrne r0, [pc, #136] ; 93c4 <IMFS_evaluate_sym_link+0xa8>
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_SYM_LINK )
9338: 1a000003 bne 934c <IMFS_evaluate_sym_link+0x30>
rtems_fatal_error_occurred (0xABCD0000);
if ( !jnode->Parent )
933c: e5963008 ldr r3, [r6, #8]
9340: e3530000 cmp r3, #0
9344: 1a000001 bne 9350 <IMFS_evaluate_sym_link+0x34>
rtems_fatal_error_occurred( 0xBAD00000 );
9348: e59f0078 ldr r0, [pc, #120] ; 93c8 <IMFS_evaluate_sym_link+0xac><== NOT EXECUTED
934c: ebfff115 bl 57a8 <rtems_fatal_error_occurred> <== NOT EXECUTED
/*
* Move the node_access to either the symbolic links parent or
* root depending on the symbolic links path.
*/
node->node_access = jnode->Parent;
9350: e5843000 str r3, [r4]
rtems_filesystem_get_sym_start_loc(
9354: e1a0100d mov r1, sp
9358: e5960050 ldr r0, [r6, #80] ; 0x50
935c: e1a02004 mov r2, r4
9360: eb0004de bl a6e0 <rtems_filesystem_get_sym_start_loc>
/*
* Use eval path to evaluate the path of the symbolic link.
*/
result = IMFS_eval_path(
9364: e59d3000 ldr r3, [sp]
9368: e5966050 ldr r6, [r6, #80] ; 0x50
936c: e0866003 add r6, r6, r3
9370: e1a00006 mov r0, r6
9374: eb001417 bl e3d8 <strlen>
9378: e1a02005 mov r2, r5
937c: e1a01000 mov r1, r0
9380: e1a03004 mov r3, r4
9384: e1a00006 mov r0, r6
9388: eb00000f bl 93cc <IMFS_eval_path>
938c: e1a06000 mov r6, r0
strlen( &jnode->info.sym_link.name[i] ),
flags,
node
);
IMFS_Set_handlers( node );
9390: e1a00004 mov r0, r4
9394: ebffff9b bl 9208 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
9398: e1a00004 mov r0, r4
939c: e1a01005 mov r1, r5
93a0: ebffffb6 bl 9280 <IMFS_evaluate_permission>
93a4: e3500000 cmp r0, #0
93a8: 1a000003 bne 93bc <IMFS_evaluate_sym_link+0xa0>
rtems_set_errno_and_return_minus_one( EACCES );
93ac: eb001004 bl d3c4 <__errno> <== NOT EXECUTED
93b0: e3a0300d mov r3, #13 <== NOT EXECUTED
93b4: e5803000 str r3, [r0] <== NOT EXECUTED
93b8: e3e06000 mvn r6, #0 <== NOT EXECUTED
return result;
}
93bc: e1a00006 mov r0, r6
93c0: e8bd8078 pop {r3, r4, r5, r6, pc}
00009b98 <IMFS_fifo_close>:
}
int IMFS_fifo_close(
rtems_libio_t *iop
)
{
9b98: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->file_info;
9b9c: e5904038 ldr r4, [r0, #56] ; 0x38 <== NOT EXECUTED
int err = pipe_release(&JNODE2PIPE(jnode), iop);
9ba0: e1a01000 mov r1, r0 <== NOT EXECUTED
}
int IMFS_fifo_close(
rtems_libio_t *iop
)
{
9ba4: e1a05000 mov r5, r0 <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->file_info;
int err = pipe_release(&JNODE2PIPE(jnode), iop);
9ba8: e2840050 add r0, r4, #80 ; 0x50 <== NOT EXECUTED
9bac: ebfffc01 bl 8bb8 <pipe_release> <== NOT EXECUTED
if (! err) {
9bb0: e2506000 subs r6, r0, #0 <== NOT EXECUTED
9bb4: 1a00000c bne 9bec <IMFS_fifo_close+0x54> <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_OPEN;
9bb8: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED
9bbc: e3c33c01 bic r3, r3, #256 ; 0x100 <== NOT EXECUTED
9bc0: e5853014 str r3, [r5, #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)
9bc4: e1a00004 mov r0, r4 <== NOT EXECUTED
9bc8: eb000195 bl a224 <rtems_libio_is_file_open> <== NOT EXECUTED
9bcc: e3500000 cmp r0, #0 <== NOT EXECUTED
9bd0: 1a00000a bne 9c00 <IMFS_fifo_close+0x68> <== NOT EXECUTED
9bd4: e1d433b4 ldrh r3, [r4, #52] ; 0x34 <== NOT EXECUTED
9bd8: e3530000 cmp r3, #0 <== NOT EXECUTED
9bdc: 1a000007 bne 9c00 <IMFS_fifo_close+0x68> <== NOT EXECUTED
free(jnode);
9be0: e1a00004 mov r0, r4 <== NOT EXECUTED
9be4: ebffe0b9 bl 1ed0 <free> <== NOT EXECUTED
9be8: ea000004 b 9c00 <IMFS_fifo_close+0x68> <== NOT EXECUTED
}
IMFS_FIFO_RETURN(err);
9bec: aa000003 bge 9c00 <IMFS_fifo_close+0x68> <== NOT EXECUTED
9bf0: eb000df3 bl d3c4 <__errno> <== NOT EXECUTED
9bf4: e2666000 rsb r6, r6, #0 <== NOT EXECUTED
9bf8: e5806000 str r6, [r0] <== NOT EXECUTED
9bfc: e3e06000 mvn r6, #0 <== NOT EXECUTED
}
9c00: e1a00006 mov r0, r6 <== NOT EXECUTED
9c04: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00009a80 <IMFS_fifo_ioctl>:
void *buffer
)
{
int err;
if (command == FIONBIO) {
9a80: e59f3068 ldr r3, [pc, #104] ; 9af0 <IMFS_fifo_ioctl+0x70> <== NOT EXECUTED
9a84: e1510003 cmp r1, r3 <== NOT EXECUTED
int IMFS_fifo_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
9a88: e92d4010 push {r4, lr} <== NOT EXECUTED
9a8c: e1a03000 mov r3, r0 <== NOT EXECUTED
int err;
if (command == FIONBIO) {
9a90: 1a00000b bne 9ac4 <IMFS_fifo_ioctl+0x44> <== NOT EXECUTED
if (buffer == NULL)
9a94: e3520000 cmp r2, #0 <== NOT EXECUTED
9a98: 03e0400d mvneq r4, #13 <== NOT EXECUTED
9a9c: 0a00000d beq 9ad8 <IMFS_fifo_ioctl+0x58> <== NOT EXECUTED
err = -EFAULT;
else {
if (*(int *)buffer)
9aa0: e5924000 ldr r4, [r2] <== NOT EXECUTED
9aa4: e5932014 ldr r2, [r3, #20] <== NOT EXECUTED
9aa8: e3540000 cmp r4, #0 <== NOT EXECUTED
iop->flags |= LIBIO_FLAGS_NO_DELAY;
9aac: 13822001 orrne r2, r2, #1 <== NOT EXECUTED
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
9ab0: 03c22001 biceq r2, r2, #1 <== NOT EXECUTED
if (command == FIONBIO) {
if (buffer == NULL)
err = -EFAULT;
else {
if (*(int *)buffer)
iop->flags |= LIBIO_FLAGS_NO_DELAY;
9ab4: 15832014 strne r2, [r3, #20] <== NOT EXECUTED
9ab8: 13a04000 movne r4, #0 <== NOT EXECUTED
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
9abc: 05832014 streq r2, [r3, #20] <== NOT EXECUTED
9ac0: ea000008 b 9ae8 <IMFS_fifo_ioctl+0x68> <== NOT EXECUTED
return 0;
}
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
9ac4: e5930038 ldr r0, [r3, #56] ; 0x38 <== NOT EXECUTED
9ac8: e5900050 ldr r0, [r0, #80] ; 0x50 <== NOT EXECUTED
9acc: ebfffb54 bl 8824 <pipe_ioctl> <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
9ad0: e2504000 subs r4, r0, #0 <== NOT EXECUTED
9ad4: aa000003 bge 9ae8 <IMFS_fifo_ioctl+0x68> <== NOT EXECUTED
9ad8: eb000e39 bl d3c4 <__errno> <== NOT EXECUTED
9adc: e2644000 rsb r4, r4, #0 <== NOT EXECUTED
9ae0: e5804000 str r4, [r0] <== NOT EXECUTED
9ae4: e3e04000 mvn r4, #0 <== NOT EXECUTED
}
9ae8: e1a00004 mov r0, r4 <== NOT EXECUTED
9aec: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00009a38 <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
9a38: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
9a3c: e58d0000 str r0, [sp] <== NOT EXECUTED
9a40: e5900038 ldr r0, [r0, #56] ; 0x38 <== NOT EXECUTED
9a44: e5900050 ldr r0, [r0, #80] ; 0x50 <== NOT EXECUTED
9a48: ebfffb5b bl 87bc <pipe_lseek> <== NOT EXECUTED
9a4c: e1a03000 mov r3, r0 <== NOT EXECUTED
9a50: e1a04fc3 asr r4, r3, #31 <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
9a54: 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);
9a58: e1a05000 mov r5, r0 <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
9a5c: aa000004 bge 9a74 <IMFS_fifo_lseek+0x3c> <== NOT EXECUTED
9a60: eb000e57 bl d3c4 <__errno> <== NOT EXECUTED
9a64: e2655000 rsb r5, r5, #0 <== NOT EXECUTED
9a68: e5805000 str r5, [r0] <== NOT EXECUTED
9a6c: e3e03000 mvn r3, #0 <== NOT EXECUTED
9a70: e3e04000 mvn r4, #0 <== NOT EXECUTED
}
9a74: e1a01004 mov r1, r4 <== NOT EXECUTED
9a78: e1a00003 mov r0, r3 <== NOT EXECUTED
9a7c: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
00009b48 <IMFS_fifo_read>:
ssize_t IMFS_fifo_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
9b48: e92d4033 push {r0, r1, r4, r5, lr} <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->file_info;
9b4c: e5904038 ldr r4, [r0, #56] ; 0x38 <== NOT EXECUTED
ssize_t IMFS_fifo_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
9b50: e1a03000 mov r3, r0 <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->file_info;
int err = pipe_read(JNODE2PIPE(jnode), buffer, count, iop);
9b54: e5940050 ldr r0, [r4, #80] ; 0x50 <== NOT EXECUTED
9b58: ebfffbad bl 8a14 <pipe_read> <== NOT EXECUTED
if (err > 0)
9b5c: e2505000 subs r5, r0, #0 <== NOT EXECUTED
9b60: da000005 ble 9b7c <IMFS_fifo_read+0x34> <== NOT EXECUTED
IMFS_update_atime(jnode);
9b64: e1a0000d mov r0, sp <== NOT EXECUTED
9b68: e3a01000 mov r1, #0 <== NOT EXECUTED
9b6c: ebffe100 bl 1f74 <gettimeofday> <== NOT EXECUTED
9b70: e59d3000 ldr r3, [sp] <== NOT EXECUTED
9b74: e5843040 str r3, [r4, #64] ; 0x40 <== NOT EXECUTED
9b78: ea000004 b 9b90 <IMFS_fifo_read+0x48> <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
9b7c: 0a000003 beq 9b90 <IMFS_fifo_read+0x48> <== NOT EXECUTED
9b80: eb000e0f bl d3c4 <__errno> <== NOT EXECUTED
9b84: e2655000 rsb r5, r5, #0 <== NOT EXECUTED
9b88: e5805000 str r5, [r0] <== NOT EXECUTED
9b8c: e3e05000 mvn r5, #0 <== NOT EXECUTED
}
9b90: e1a00005 mov r0, r5 <== NOT EXECUTED
9b94: e8bd803c pop {r2, r3, r4, r5, pc} <== NOT EXECUTED
00009af4 <IMFS_fifo_write>:
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
9af4: e92d4033 push {r0, r1, r4, r5, lr} <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->file_info;
9af8: e5904038 ldr r4, [r0, #56] ; 0x38 <== NOT EXECUTED
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
9afc: e1a03000 mov r3, r0 <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->file_info;
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
9b00: e5940050 ldr r0, [r4, #80] ; 0x50 <== NOT EXECUTED
9b04: ebfffb5e bl 8884 <pipe_write> <== NOT EXECUTED
if (err > 0) {
9b08: e2505000 subs r5, r0, #0 <== NOT EXECUTED
9b0c: da000006 ble 9b2c <IMFS_fifo_write+0x38> <== NOT EXECUTED
IMFS_mtime_ctime_update(jnode);
9b10: e1a0000d mov r0, sp <== NOT EXECUTED
9b14: e3a01000 mov r1, #0 <== NOT EXECUTED
9b18: ebffe115 bl 1f74 <gettimeofday> <== NOT EXECUTED
9b1c: e59d3000 ldr r3, [sp] <== NOT EXECUTED
9b20: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
9b24: e5843044 str r3, [r4, #68] ; 0x44 <== NOT EXECUTED
9b28: ea000004 b 9b40 <IMFS_fifo_write+0x4c> <== NOT EXECUTED
}
IMFS_FIFO_RETURN(err);
9b2c: 0a000003 beq 9b40 <IMFS_fifo_write+0x4c> <== NOT EXECUTED
9b30: eb000e23 bl d3c4 <__errno> <== NOT EXECUTED
9b34: e2655000 rsb r5, r5, #0 <== NOT EXECUTED
9b38: e5805000 str r5, [r0] <== NOT EXECUTED
9b3c: e3e05000 mvn r5, #0 <== NOT EXECUTED
}
9b40: e1a00005 mov r0, r5 <== NOT EXECUTED
9b44: e8bd803c pop {r2, r3, r4, r5, pc} <== NOT EXECUTED
00009c44 <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
)
{
9c44: 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;
9c48: e1a0c000 mov ip, r0
9c4c: 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
)
{
9c50: e1a05000 mov r5, r0
9c54: e24dd014 sub sp, sp, #20
* 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;
9c58: e8bc000f ldm ip!, {r0, r1, r2, r3}
9c5c: e1a0e00d mov lr, sp
9c60: e8ae000f stmia lr!, {r0, r1, r2, r3}
9c64: e59c3000 ldr r3, [ip]
9c68: e58e3000 str r3, [lr]
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
9c6c: e3a03000 mov r3, #0
9c70: e585301c str r3, [r5, #28]
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
9c74: e1a0500d mov r5, sp
9c78: e1a0000d mov r0, sp
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
9c7c: e58d4000 str r4, [sp]
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
9c80: e5946008 ldr r6, [r4, #8]
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
9c84: ebfffd5f bl 9208 <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
9c88: e594204c ldr r2, [r4, #76] ; 0x4c
9c8c: e3520001 cmp r2, #1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
9c90: e2843054 add r3, r4, #84 ; 0x54
9c94: 1a000002 bne 9ca4 <IMFS_fsunmount+0x60>
9c98: e5942050 ldr r2, [r4, #80] ; 0x50
9c9c: e1520003 cmp r2, r3
9ca0: 1a000005 bne 9cbc <IMFS_fsunmount+0x78>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
9ca4: e3a00000 mov r0, #0
9ca8: e1a0100d mov r1, sp
9cac: ebffdf1d bl 1928 <IMFS_unlink>
if (result != 0)
9cb0: e3500000 cmp r0, #0
9cb4: 1a00000c bne 9cec <IMFS_fsunmount+0xa8>
9cb8: e1a04006 mov r4, r6
return -1;
jnode = next;
}
if ( jnode != NULL ) {
9cbc: e3540000 cmp r4, #0
9cc0: 0a00000b beq 9cf4 <IMFS_fsunmount+0xb0>
if ( jnode->type == IMFS_DIRECTORY ) {
9cc4: e594304c ldr r3, [r4, #76] ; 0x4c
9cc8: e3530001 cmp r3, #1
9ccc: 1affffe9 bne 9c78 <IMFS_fsunmount+0x34>
9cd0: e5943050 ldr r3, [r4, #80] ; 0x50
9cd4: e2842054 add r2, r4, #84 ; 0x54
9cd8: e1530002 cmp r3, r2
9cdc: 0affffe5 beq 9c78 <IMFS_fsunmount+0x34>
if ( jnode_has_children( jnode ) )
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
9ce0: e2534000 subs r4, r3, #0
9ce4: 1affffe3 bne 9c78 <IMFS_fsunmount+0x34>
9ce8: ea000001 b 9cf4 <IMFS_fsunmount+0xb0> <== NOT EXECUTED
9cec: e3e00000 mvn r0, #0 <== NOT EXECUTED
9cf0: ea000000 b 9cf8 <IMFS_fsunmount+0xb4> <== NOT EXECUTED
9cf4: e3a00000 mov r0, #0
return 0;
}
9cf8: e28dd014 add sp, sp, #20
9cfc: e8bd8070 pop {r4, r5, r6, pc}
00001548 <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,
1548: e59fc0d4 ldr ip, [pc, #212] ; 1624 <IMFS_initialize_support+0xdc>
154c: e59cc000 ldr ip, [ip]
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
)
{
1550: e92d41f0 push {r4, r5, r6, r7, r8, lr}
1554: e1a08002 mov r8, r2
1558: e1a06003 mov r6, r3
155c: e1a04000 mov r4, r0
1560: e1a07001 mov r7, r1
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
1564: e3a02000 mov r2, #0
1568: e3a03010 mov r3, #16
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
156c: e153000c cmp r3, ip
1570: e2822001 add r2, r2, #1
1574: 0a000003 beq 1588 <IMFS_initialize_support+0x40>
1578: e3520006 cmp r2, #6
157c: e1a03083 lsl r3, r3, #1
1580: 1afffff9 bne 156c <IMFS_initialize_support+0x24>
1584: e3a03080 mov r3, #128 ; 0x80 <== NOT EXECUTED
if (bit_mask == requested_bytes_per_block) {
is_valid = true;
}
}
*dest_bytes_per_block = ((is_valid)
1588: e59f5098 ldr r5, [pc, #152] ; 1628 <IMFS_initialize_support+0xe0>
158c: e5853000 str r3, [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();
1590: eb001ebd bl 908c <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;
1594: e59fe090 ldr lr, [pc, #144] ; 162c <IMFS_initialize_support+0xe4>
/*
* 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();
1598: 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;
159c: e8be000f ldm lr!, {r0, r1, r2, r3}
15a0: e284c038 add ip, r4, #56 ; 0x38
15a4: e8ac000f stmia ip!, {r0, r1, r2, r3}
15a8: e8be000f ldm lr!, {r0, r1, r2, r3}
15ac: e8ac000f stmia ip!, {r0, r1, r2, r3}
15b0: 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;
15b4: e5847028 str r7, [r4, #40] ; 0x28
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
15b8: 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;
15bc: 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 ) );
15c0: e3a00001 mov r0, #1
15c4: e3a01010 mov r1, #16
15c8: eb0001b8 bl 1cb0 <calloc>
if ( !fs_info ) {
15cc: e3500000 cmp r0, #0
15d0: 1a000006 bne 15f0 <IMFS_initialize_support+0xa8>
free(temp_mt_entry->mt_fs_root.node_access);
15d4: e594001c ldr r0, [r4, #28] <== NOT EXECUTED
15d8: eb00023c bl 1ed0 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
15dc: eb002f78 bl d3c4 <__errno> <== NOT EXECUTED
15e0: e3a0300c mov r3, #12 <== NOT EXECUTED
15e4: e5803000 str r3, [r0] <== NOT EXECUTED
15e8: e3e00000 mvn r0, #0 <== NOT EXECUTED
15ec: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
15f0: 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;
15f4: e594101c ldr r1, [r4, #28]
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
fs_info->ino_count = 1;
15f8: e3a03001 mov r3, #1
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
15fc: e880000c stm r0, {r2, r3}
fs_info->ino_count = 1;
fs_info->memfile_handlers = memfile_handlers;
fs_info->directory_handlers = directory_handlers;
1600: 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;
1604: e5808008 str r8, [r0, #8]
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
1608: 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;
160c: 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;
1610: e5813038 str r3, [r1, #56] ; 0x38
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
1614: 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();
1618: eb001c69 bl 87c4 <rtems_pipe_initialize>
161c: e3a00000 mov r0, #0
return 0;
}
1620: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
00001630 <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 */
)
{
1630: e92d4070 push {r4, r5, r6, lr}
int i;
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
1634: 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 */
)
{
1638: e24dd048 sub sp, sp, #72 ; 0x48
int i;
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
163c: e58d3028 str r3, [sp, #40] ; 0x28
if ( info.hard_link.link_node->st_nlink >= LINK_MAX )
1640: e1d333b4 ldrh r3, [r3, #52] ; 0x34
1644: 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 */
)
{
1648: e1a05001 mov r5, r1
164c: 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 )
1650: 9a000002 bls 1660 <IMFS_link+0x30>
rtems_set_errno_and_return_minus_one( EMLINK );
1654: eb002f5a bl d3c4 <__errno>
1658: e3a0301f mov r3, #31
165c: ea000012 b 16ac <IMFS_link+0x7c>
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( token, strlen( token ), new_name, &i );
1660: e1a00002 mov r0, r2
1664: eb00335b bl e3d8 <strlen>
1668: e28d4004 add r4, sp, #4
166c: e1a01000 mov r1, r0
1670: e1a02004 mov r2, r4
1674: e28d3044 add r3, sp, #68 ; 0x44
1678: e1a00006 mov r0, r6
167c: eb0021c7 bl 9da0 <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(
1680: e28dc028 add ip, sp, #40 ; 0x28
1684: e1a00005 mov r0, r5
1688: e1a02004 mov r2, r4
168c: e3a01003 mov r1, #3
1690: e59f3054 ldr r3, [pc, #84] ; 16ec <IMFS_link+0xbc>
1694: e58dc000 str ip, [sp]
1698: eb001e8b bl 90cc <IMFS_create_node>
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if ( !new_node )
169c: e3500000 cmp r0, #0
16a0: 1a000004 bne 16b8 <IMFS_link+0x88>
rtems_set_errno_and_return_minus_one( ENOMEM );
16a4: eb002f46 bl d3c4 <__errno> <== NOT EXECUTED
16a8: e3a0300c mov r3, #12 <== NOT EXECUTED
16ac: e5803000 str r3, [r0]
16b0: e3e00000 mvn r0, #0
16b4: ea00000a b 16e4 <IMFS_link+0xb4>
/*
* Increment the link count of the node being pointed to.
*/
info.hard_link.link_node->st_nlink++;
16b8: e59d3028 ldr r3, [sp, #40] ; 0x28
16bc: e1d323b4 ldrh r2, [r3, #52] ; 0x34
16c0: e2822001 add r2, r2, #1
16c4: e1c323b4 strh r2, [r3, #52] ; 0x34
IMFS_update_ctime( info.hard_link.link_node );
16c8: e28d003c add r0, sp, #60 ; 0x3c
16cc: e3a01000 mov r1, #0
16d0: eb000227 bl 1f74 <gettimeofday>
16d4: e59d203c ldr r2, [sp, #60] ; 0x3c
16d8: e59d3028 ldr r3, [sp, #40] ; 0x28
16dc: e5832048 str r2, [r3, #72] ; 0x48
16e0: e3a00000 mov r0, #0
return 0;
}
16e4: e28dd048 add sp, sp, #72 ; 0x48
16e8: e8bd8070 pop {r4, r5, r6, pc}
0000bcbc <IMFS_memfile_addblock>:
)
{
block_p memory;
block_p *block_entry_ptr;
assert( the_jnode );
bcbc: e2503000 subs r3, r0, #0
MEMFILE_STATIC int IMFS_memfile_addblock(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
bcc0: e92d4030 push {r4, r5, lr}
block_p memory;
block_p *block_entry_ptr;
assert( the_jnode );
bcc4: 059f0060 ldreq r0, [pc, #96] ; bd2c <IMFS_memfile_addblock+0x70>
bcc8: 059f1060 ldreq r1, [pc, #96] ; bd30 <IMFS_memfile_addblock+0x74>
bccc: 059f2060 ldreq r2, [pc, #96] ; bd34 <IMFS_memfile_addblock+0x78>
bcd0: 059f3060 ldreq r3, [pc, #96] ; bd38 <IMFS_memfile_addblock+0x7c>
bcd4: 0a000006 beq bcf4 <IMFS_memfile_addblock+0x38>
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE );
bcd8: e593304c ldr r3, [r3, #76] ; 0x4c
bcdc: e3530005 cmp r3, #5
bce0: 0a000004 beq bcf8 <IMFS_memfile_addblock+0x3c>
bce4: e59f0040 ldr r0, [pc, #64] ; bd2c <IMFS_memfile_addblock+0x70><== NOT EXECUTED
bce8: e59f104c ldr r1, [pc, #76] ; bd3c <IMFS_memfile_addblock+0x80><== NOT EXECUTED
bcec: e59f2040 ldr r2, [pc, #64] ; bd34 <IMFS_memfile_addblock+0x78><== NOT EXECUTED
bcf0: e59f3048 ldr r3, [pc, #72] ; bd40 <IMFS_memfile_addblock+0x84><== NOT EXECUTED
bcf4: ebfff8c4 bl a00c <__assert_func> <== NOT EXECUTED
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 );
bcf8: e3a02001 mov r2, #1
bcfc: ebfffeaf bl b7c0 <IMFS_memfile_get_block_pointer>
if ( *block_entry_ptr )
bd00: e5904000 ldr r4, [r0]
bd04: 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 );
bd08: e1a05000 mov r5, r0
if ( *block_entry_ptr )
bd0c: 13a00000 movne r0, #0
bd10: 18bd8030 popne {r4, r5, pc}
#if 0
fprintf(stdout, "%d %p", block, block_entry_ptr );
fflush(stdout);
#endif
memory = memfile_alloc_block();
bd14: ebfffe9c bl b78c <memfile_alloc_block>
if ( !memory )
bd18: e3500000 cmp r0, #0
return 1;
*block_entry_ptr = memory;
bd1c: 15850000 strne r0, [r5]
fprintf(stdout, "%d %p", block, block_entry_ptr );
fflush(stdout);
#endif
memory = memfile_alloc_block();
if ( !memory )
bd20: 03a00001 moveq r0, #1
return 1;
*block_entry_ptr = memory;
bd24: 11a00004 movne r0, r4
return 0;
}
bd28: e8bd8030 pop {r4, r5, pc}
0000bd44 <IMFS_memfile_extend>:
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
bd44: e92d4df1 push {r0, r4, r5, r6, r7, r8, sl, fp, lr}
/*
* Perform internal consistency checks
*/
assert( the_jnode );
bd48: e2504000 subs r4, r0, #0
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
bd4c: e1a05001 mov r5, r1
bd50: e1a06002 mov r6, r2
/*
* Perform internal consistency checks
*/
assert( the_jnode );
bd54: 059f0134 ldreq r0, [pc, #308] ; be90 <IMFS_memfile_extend+0x14c>
bd58: 059f1134 ldreq r1, [pc, #308] ; be94 <IMFS_memfile_extend+0x150>
bd5c: 059f2134 ldreq r2, [pc, #308] ; be98 <IMFS_memfile_extend+0x154>
bd60: 059f3134 ldreq r3, [pc, #308] ; be9c <IMFS_memfile_extend+0x158>
bd64: 0a000006 beq bd84 <IMFS_memfile_extend+0x40>
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE );
bd68: e594304c ldr r3, [r4, #76] ; 0x4c
bd6c: e3530005 cmp r3, #5
bd70: 0a000004 beq bd88 <IMFS_memfile_extend+0x44>
bd74: e59f0114 ldr r0, [pc, #276] ; be90 <IMFS_memfile_extend+0x14c><== NOT EXECUTED
bd78: e59f1120 ldr r1, [pc, #288] ; bea0 <IMFS_memfile_extend+0x15c><== NOT EXECUTED
bd7c: e59f2114 ldr r2, [pc, #276] ; be98 <IMFS_memfile_extend+0x154><== NOT EXECUTED
bd80: e59f311c ldr r3, [pc, #284] ; bea4 <IMFS_memfile_extend+0x160><== NOT EXECUTED
bd84: ebfff8a0 bl a00c <__assert_func> <== NOT EXECUTED
if ( the_jnode->type != IMFS_MEMORY_FILE )
rtems_set_errno_and_return_minus_one( EIO );
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
bd88: e59f3118 ldr r3, [pc, #280] ; bea8 <IMFS_memfile_extend+0x164>
bd8c: e593b000 ldr fp, [r3]
bd90: e1a0312b lsr r3, fp, #2
bd94: e2832001 add r2, r3, #1
bd98: e0010293 mul r1, r3, r2
bd9c: e2811001 add r1, r1, #1
bda0: e0020193 mul r2, r3, r1
bda4: e3a03000 mov r3, #0
bda8: e1530006 cmp r3, r6
bdac: e2422001 sub r2, r2, #1
bdb0: e003029b mul r3, fp, r2
bdb4: ca000005 bgt bdd0 <IMFS_memfile_extend+0x8c>
bdb8: 1a000001 bne bdc4 <IMFS_memfile_extend+0x80>
bdbc: e1530005 cmp r3, r5
bdc0: 8a000002 bhi bdd0 <IMFS_memfile_extend+0x8c>
rtems_set_errno_and_return_minus_one( EINVAL );
bdc4: eb00057e bl d3c4 <__errno> <== NOT EXECUTED
bdc8: e3a03016 mov r3, #22 <== NOT EXECUTED
bdcc: ea000025 b be68 <IMFS_memfile_extend+0x124> <== NOT EXECUTED
if ( new_length <= the_jnode->info.file.size )
bdd0: e5948054 ldr r8, [r4, #84] ; 0x54
bdd4: e1560008 cmp r6, r8
bdd8: e5947050 ldr r7, [r4, #80] ; 0x50
bddc: ca000002 bgt bdec <IMFS_memfile_extend+0xa8>
bde0: 1a000028 bne be88 <IMFS_memfile_extend+0x144>
bde4: e1550007 cmp r5, r7
bde8: 9a000026 bls be88 <IMFS_memfile_extend+0x144>
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
bdec: e1a0cfcb asr ip, fp, #31
bdf0: e1a0300c mov r3, ip
bdf4: e1a0200b mov r2, fp
bdf8: e1a00005 mov r0, r5
bdfc: e1a01006 mov r1, r6
be00: e58dc000 str ip, [sp]
be04: eb002e39 bl 176f0 <__divdi3>
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
be08: e59dc000 ldr ip, [sp]
be0c: e1a01008 mov r1, r8
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
be10: e1a0a000 mov sl, r0
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
be14: e1a0200b mov r2, fp
be18: e1a00007 mov r0, r7
be1c: e1a0300c mov r3, ip
be20: eb002e32 bl 176f0 <__divdi3>
be24: e1a08000 mov r8, r0
be28: e1a07000 mov r7, r0
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
be2c: ea000011 b be78 <IMFS_memfile_extend+0x134>
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
be30: e1a00004 mov r0, r4
be34: e1a01007 mov r1, r7
be38: ebffff9f bl bcbc <IMFS_memfile_addblock>
be3c: e3500000 cmp r0, #0
be40: 0a00000b beq be74 <IMFS_memfile_extend+0x130>
be44: ea000003 b be58 <IMFS_memfile_extend+0x114> <== NOT EXECUTED
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
be48: e1a01007 mov r1, r7 <== NOT EXECUTED
be4c: e1a00004 mov r0, r4 <== NOT EXECUTED
be50: ebfffefa bl ba40 <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-- ) {
be54: e2477001 sub r7, r7, #1 <== NOT EXECUTED
be58: e1570008 cmp r7, r8 <== NOT EXECUTED
be5c: 2afffff9 bcs be48 <IMFS_memfile_extend+0x104> <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
be60: eb000557 bl d3c4 <__errno> <== NOT EXECUTED
be64: e3a0301c mov r3, #28 <== NOT EXECUTED
be68: e5803000 str r3, [r0] <== NOT EXECUTED
be6c: e3e00000 mvn r0, #0 <== NOT EXECUTED
be70: ea000005 b be8c <IMFS_memfile_extend+0x148> <== NOT EXECUTED
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
be74: e2877001 add r7, r7, #1
be78: e157000a cmp r7, sl
be7c: 9affffeb bls be30 <IMFS_memfile_extend+0xec>
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
be80: e5846054 str r6, [r4, #84] ; 0x54
be84: e5845050 str r5, [r4, #80] ; 0x50
be88: e3a00000 mov r0, #0
return 0;
}
be8c: e8bd8df8 pop {r3, r4, r5, r6, r7, r8, sl, fp, pc}
0000b7c0 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
b7c0: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
/*
* Perform internal consistency checks
*/
assert( the_jnode );
b7c4: e2504000 subs r4, r0, #0
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
b7c8: e1a06001 mov r6, r1
b7cc: e1a08002 mov r8, r2
/*
* Perform internal consistency checks
*/
assert( the_jnode );
b7d0: 059f01d8 ldreq r0, [pc, #472] ; b9b0 <IMFS_memfile_get_block_pointer+0x1f0>
b7d4: 03a01fe2 moveq r1, #904 ; 0x388
b7d8: 059f21d4 ldreq r2, [pc, #468] ; b9b4 <IMFS_memfile_get_block_pointer+0x1f4>
b7dc: 059f31d4 ldreq r3, [pc, #468] ; b9b8 <IMFS_memfile_get_block_pointer+0x1f8>
b7e0: 0a000006 beq b800 <IMFS_memfile_get_block_pointer+0x40>
if ( !the_jnode )
return NULL;
assert( the_jnode->type == IMFS_MEMORY_FILE );
b7e4: e594304c ldr r3, [r4, #76] ; 0x4c
b7e8: e3530005 cmp r3, #5
b7ec: 0a000004 beq b804 <IMFS_memfile_get_block_pointer+0x44>
b7f0: e59f01b8 ldr r0, [pc, #440] ; b9b0 <IMFS_memfile_get_block_pointer+0x1f0><== NOT EXECUTED
b7f4: e59f21b8 ldr r2, [pc, #440] ; b9b4 <IMFS_memfile_get_block_pointer+0x1f4><== NOT EXECUTED
b7f8: e59f31bc ldr r3, [pc, #444] ; b9bc <IMFS_memfile_get_block_pointer+0x1fc><== NOT EXECUTED
b7fc: e3a01fe3 mov r1, #908 ; 0x38c <== NOT EXECUTED
b800: ebfffa01 bl a00c <__assert_func> <== NOT EXECUTED
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
b804: e59f31b4 ldr r3, [pc, #436] ; b9c0 <IMFS_memfile_get_block_pointer+0x200>
b808: e5935000 ldr r5, [r3]
b80c: e1a05125 lsr r5, r5, #2
b810: e2453001 sub r3, r5, #1
b814: e1510003 cmp r1, r3
b818: 8a00000e bhi b858 <IMFS_memfile_get_block_pointer+0x98>
fprintf(stdout, "(s %d) ", block );
fflush(stdout);
#endif
p = info->indirect;
if ( malloc_it ) {
b81c: e3520000 cmp r2, #0
if ( my_block <= LAST_INDIRECT ) {
#if 0
fprintf(stdout, "(s %d) ", block );
fflush(stdout);
#endif
p = info->indirect;
b820: e5940058 ldr r0, [r4, #88] ; 0x58
if ( malloc_it ) {
b824: 0a000007 beq b848 <IMFS_memfile_get_block_pointer+0x88>
if ( !p ) {
b828: e3500000 cmp r0, #0
b82c: 1a000003 bne b840 <IMFS_memfile_get_block_pointer+0x80>
p = memfile_alloc_block();
b830: ebffffd5 bl b78c <memfile_alloc_block>
if ( !p )
b834: e3500000 cmp r0, #0
b838: 0a00005a beq b9a8 <IMFS_memfile_get_block_pointer+0x1e8>
return 0;
info->indirect = p;
b83c: e5840058 str r0, [r4, #88] ; 0x58
}
return &info->indirect[ my_block ];
b840: e5940058 ldr r0, [r4, #88] ; 0x58
b844: ea000001 b b850 <IMFS_memfile_get_block_pointer+0x90>
}
if ( !p )
b848: e3500000 cmp r0, #0
b84c: 0a000055 beq b9a8 <IMFS_memfile_get_block_pointer+0x1e8>
return 0;
return &info->indirect[ my_block ];
b850: e0800106 add r0, r0, r6, lsl #2
b854: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
b858: e2852001 add r2, r5, #1 <== NOT EXECUTED
b85c: e0030295 mul r3, r5, r2 <== NOT EXECUTED
b860: e2432001 sub r2, r3, #1 <== NOT EXECUTED
b864: e1510002 cmp r1, r2 <== NOT EXECUTED
b868: 8a000015 bhi b8c4 <IMFS_memfile_get_block_pointer+0x104> <== NOT EXECUTED
#if 0
fprintf(stdout, "(d %d) ", block );
fflush(stdout);
#endif
my_block -= FIRST_DOUBLY_INDIRECT;
b86c: e0656001 rsb r6, r5, r1 <== NOT EXECUTED
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
b870: e1a00006 mov r0, r6 <== NOT EXECUTED
b874: e1a01005 mov r1, r5 <== NOT EXECUTED
b878: eb002cef bl 16c3c <__umodsi3> <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
b87c: e1a01005 mov r1, r5 <== NOT EXECUTED
fflush(stdout);
#endif
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
b880: e1a0a000 mov sl, r0 <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
b884: e1a00006 mov r0, r6 <== NOT EXECUTED
b888: eb002c57 bl 169ec <__aeabi_uidiv> <== NOT EXECUTED
p = info->doubly_indirect;
if ( malloc_it ) {
b88c: e3580000 cmp r8, #0 <== NOT EXECUTED
#endif
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
b890: e1a05000 mov r5, r0 <== NOT EXECUTED
p = info->doubly_indirect;
b894: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED
if ( malloc_it ) {
b898: 0a00003b beq b98c <IMFS_memfile_get_block_pointer+0x1cc> <== NOT EXECUTED
if ( !p ) {
b89c: e3530000 cmp r3, #0 <== NOT EXECUTED
b8a0: 1a000003 bne b8b4 <IMFS_memfile_get_block_pointer+0xf4> <== NOT EXECUTED
p = memfile_alloc_block();
b8a4: ebffffb8 bl b78c <memfile_alloc_block> <== NOT EXECUTED
if ( !p )
b8a8: e2503000 subs r3, r0, #0 <== NOT EXECUTED
b8ac: 0a00003d beq b9a8 <IMFS_memfile_get_block_pointer+0x1e8> <== NOT EXECUTED
return 0;
info->doubly_indirect = p;
b8b0: e584305c str r3, [r4, #92] ; 0x5c <== NOT EXECUTED
}
p1 = (block_p *)p[ doubly ];
b8b4: e7930105 ldr r0, [r3, r5, lsl #2] <== NOT EXECUTED
b8b8: e0835105 add r5, r3, r5, lsl #2 <== NOT EXECUTED
if ( !p1 ) {
b8bc: e3500000 cmp r0, #0 <== NOT EXECUTED
b8c0: ea000028 b b968 <IMFS_memfile_get_block_pointer+0x1a8> <== NOT EXECUTED
#endif
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
b8c4: e2831001 add r1, r3, #1 <== NOT EXECUTED
b8c8: e0020195 mul r2, r5, r1 <== NOT EXECUTED
b8cc: e2422001 sub r2, r2, #1 <== NOT EXECUTED
b8d0: e1560002 cmp r6, r2 <== NOT EXECUTED
b8d4: 8a000033 bhi b9a8 <IMFS_memfile_get_block_pointer+0x1e8> <== NOT EXECUTED
my_block -= FIRST_TRIPLY_INDIRECT;
b8d8: e0636006 rsb r6, r3, r6 <== NOT EXECUTED
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
b8dc: e1a01005 mov r1, r5 <== NOT EXECUTED
b8e0: e1a00006 mov r0, r6 <== NOT EXECUTED
b8e4: eb002cd4 bl 16c3c <__umodsi3> <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
b8e8: e1a01005 mov r1, r5 <== NOT EXECUTED
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
b8ec: e1a0a000 mov sl, r0 <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
b8f0: e1a00006 mov r0, r6 <== NOT EXECUTED
b8f4: eb002c3c bl 169ec <__aeabi_uidiv> <== NOT EXECUTED
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
b8f8: 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;
b8fc: e1a06000 mov r6, r0 <== NOT EXECUTED
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
b900: eb002c39 bl 169ec <__aeabi_uidiv> <== NOT EXECUTED
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
b904: 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;
b908: e1a07000 mov r7, r0 <== NOT EXECUTED
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
b90c: e1a00006 mov r0, r6 <== NOT EXECUTED
b910: eb002cc9 bl 16c3c <__umodsi3> <== NOT EXECUTED
p = info->triply_indirect;
if ( malloc_it ) {
b914: e3580000 cmp r8, #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;
b918: e1a05000 mov r5, r0 <== NOT EXECUTED
p = info->triply_indirect;
b91c: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED
if ( malloc_it ) {
b920: 0a000016 beq b980 <IMFS_memfile_get_block_pointer+0x1c0> <== NOT EXECUTED
if ( !p ) {
b924: e3530000 cmp r3, #0 <== NOT EXECUTED
b928: 1a000003 bne b93c <IMFS_memfile_get_block_pointer+0x17c> <== NOT EXECUTED
p = memfile_alloc_block();
b92c: ebffff96 bl b78c <memfile_alloc_block> <== NOT EXECUTED
if ( !p )
b930: e2503000 subs r3, r0, #0 <== NOT EXECUTED
b934: 0a00001b beq b9a8 <IMFS_memfile_get_block_pointer+0x1e8> <== NOT EXECUTED
return 0;
info->triply_indirect = p;
b938: e5843060 str r3, [r4, #96] ; 0x60 <== NOT EXECUTED
}
p1 = (block_p *) p[ triply ];
b93c: e7932107 ldr r2, [r3, r7, lsl #2] <== NOT EXECUTED
if ( !p1 ) {
b940: e3520000 cmp r2, #0 <== NOT EXECUTED
if ( !p )
return 0;
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
b944: e0837107 add r7, r3, r7, lsl #2 <== NOT EXECUTED
if ( !p1 ) {
b948: 1a000003 bne b95c <IMFS_memfile_get_block_pointer+0x19c> <== NOT EXECUTED
p1 = memfile_alloc_block();
b94c: ebffff8e bl b78c <memfile_alloc_block> <== NOT EXECUTED
if ( !p1 )
b950: e2502000 subs r2, r0, #0 <== NOT EXECUTED
b954: 0a000013 beq b9a8 <IMFS_memfile_get_block_pointer+0x1e8> <== NOT EXECUTED
return 0;
p[ triply ] = (block_p) p1;
b958: e5872000 str r2, [r7] <== NOT EXECUTED
}
p2 = (block_p *)p1[ doubly ];
b95c: e7920105 ldr r0, [r2, r5, lsl #2] <== NOT EXECUTED
b960: e0825105 add r5, r2, r5, lsl #2 <== NOT EXECUTED
if ( !p2 ) {
b964: e3500000 cmp r0, #0 <== NOT EXECUTED
b968: 1a00000c bne b9a0 <IMFS_memfile_get_block_pointer+0x1e0> <== NOT EXECUTED
p2 = memfile_alloc_block();
b96c: ebffff86 bl b78c <memfile_alloc_block> <== NOT EXECUTED
if ( !p2 )
b970: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
p1[ doubly ] = (block_p) p2;
b974: 15850000 strne r0, [r5] <== NOT EXECUTED
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
if ( !p2 )
b978: 1a000008 bne b9a0 <IMFS_memfile_get_block_pointer+0x1e0> <== NOT EXECUTED
b97c: ea000009 b b9a8 <IMFS_memfile_get_block_pointer+0x1e8> <== NOT EXECUTED
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
}
if ( !p )
b980: e3530000 cmp r3, #0 <== NOT EXECUTED
b984: 0a000007 beq b9a8 <IMFS_memfile_get_block_pointer+0x1e8> <== 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 ];
b988: e7933107 ldr r3, [r3, r7, lsl #2] <== NOT EXECUTED
if ( !p1 )
b98c: e3530000 cmp r3, #0 <== NOT EXECUTED
b990: 0a000004 beq b9a8 <IMFS_memfile_get_block_pointer+0x1e8> <== NOT EXECUTED
return 0;
p2 = (block_p *)p1[ doubly ];
b994: e7930105 ldr r0, [r3, r5, lsl #2] <== NOT EXECUTED
if ( !p2 )
b998: e3500000 cmp r0, #0 <== NOT EXECUTED
b99c: 0a000001 beq b9a8 <IMFS_memfile_get_block_pointer+0x1e8> <== NOT EXECUTED
return 0;
return (block_p *)&p2[ singly ];
b9a0: e080010a add r0, r0, sl, lsl #2 <== NOT EXECUTED
b9a4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
b9a8: e3a00000 mov r0, #0 <== NOT EXECUTED
/*
* This means the requested block number is out of range.
*/
return 0;
}
b9ac: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
0000c2cc <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
c2cc: e92d4ff7 push {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}
/*
* Perform internal consistency checks
*/
assert( the_jnode );
c2d0: e2504000 subs r4, r0, #0
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
c2d4: e1a06003 mov r6, r3
c2d8: e1a08001 mov r8, r1
c2dc: e1a09002 mov r9, r2
c2e0: e59d7030 ldr r7, [sp, #48] ; 0x30
/*
* Perform internal consistency checks
*/
assert( the_jnode );
c2e4: 059f024c ldreq r0, [pc, #588] ; c538 <IMFS_memfile_read+0x26c>
c2e8: 03a01f93 moveq r1, #588 ; 0x24c
c2ec: 059f2248 ldreq r2, [pc, #584] ; c53c <IMFS_memfile_read+0x270>
c2f0: 059f3248 ldreq r3, [pc, #584] ; c540 <IMFS_memfile_read+0x274>
c2f4: 0a000007 beq c318 <IMFS_memfile_read+0x4c>
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE ||
c2f8: e594304c ldr r3, [r4, #76] ; 0x4c
c2fc: e2432005 sub r2, r3, #5
c300: e3520001 cmp r2, #1
c304: 9a000004 bls c31c <IMFS_memfile_read+0x50>
c308: e59f0228 ldr r0, [pc, #552] ; c538 <IMFS_memfile_read+0x26c><== NOT EXECUTED
c30c: e59f1230 ldr r1, [pc, #560] ; c544 <IMFS_memfile_read+0x278><== NOT EXECUTED
c310: e59f2224 ldr r2, [pc, #548] ; c53c <IMFS_memfile_read+0x270><== NOT EXECUTED
c314: e59f322c ldr r3, [pc, #556] ; c548 <IMFS_memfile_read+0x27c><== NOT EXECUTED
c318: ebfff73b bl a00c <__assert_func> <== NOT EXECUTED
/*
* Error checks on arguments
*/
assert( dest );
c31c: e3560000 cmp r6, #0
c320: 059f0210 ldreq r0, [pc, #528] ; c538 <IMFS_memfile_read+0x26c>
c324: 059f1220 ldreq r1, [pc, #544] ; c54c <IMFS_memfile_read+0x280>
c328: 059f220c ldreq r2, [pc, #524] ; c53c <IMFS_memfile_read+0x270>
c32c: 059f321c ldreq r3, [pc, #540] ; c550 <IMFS_memfile_read+0x284>
c330: 0afffff8 beq c318 <IMFS_memfile_read+0x4c>
/*
* If there is nothing to read, then quick exit.
*/
my_length = length;
if ( !my_length )
c334: e3570000 cmp r7, #0
c338: 1a000004 bne c350 <IMFS_memfile_read+0x84>
rtems_set_errno_and_return_minus_one( EINVAL );
c33c: eb000420 bl d3c4 <__errno> <== NOT EXECUTED
c340: e3a03016 mov r3, #22 <== NOT EXECUTED
c344: e5803000 str r3, [r0] <== NOT EXECUTED
c348: e3e07000 mvn r7, #0 <== NOT EXECUTED
c34c: ea000077 b c530 <IMFS_memfile_read+0x264> <== NOT EXECUTED
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
if (the_jnode->type == IMFS_LINEAR_FILE) {
c350: e3530006 cmp r3, #6
c354: 1a000012 bne c3a4 <IMFS_memfile_read+0xd8>
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
c358: e284b050 add fp, r4, #80 ; 0x50 <== NOT EXECUTED
c35c: e89b0c00 ldm fp, {sl, fp} <== NOT EXECUTED
c360: e1a0200a mov r2, sl <== NOT EXECUTED
c364: e1a0300b mov r3, fp <== NOT EXECUTED
c368: e3a01000 mov r1, #0 <== NOT EXECUTED
c36c: e0522008 subs r2, r2, r8 <== NOT EXECUTED
c370: e0c33009 sbc r3, r3, r9 <== NOT EXECUTED
c374: e1510003 cmp r1, r3 <== 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;
c378: e5941058 ldr r1, [r4, #88] ; 0x58 <== NOT EXECUTED
if (my_length > (the_jnode->info.linearfile.size - start))
c37c: ca000002 bgt c38c <IMFS_memfile_read+0xc0> <== NOT EXECUTED
c380: 1a000002 bne c390 <IMFS_memfile_read+0xc4> <== NOT EXECUTED
c384: e1570002 cmp r7, r2 <== NOT EXECUTED
c388: 9a000000 bls c390 <IMFS_memfile_read+0xc4> <== NOT EXECUTED
my_length = the_jnode->info.linearfile.size - start;
c38c: e068700a rsb r7, r8, sl <== NOT EXECUTED
memcpy(dest, &file_ptr[start], my_length);
c390: e0811008 add r1, r1, r8 <== NOT EXECUTED
c394: e1a00006 mov r0, r6 <== NOT EXECUTED
c398: e1a02007 mov r2, r7 <== NOT EXECUTED
c39c: eb000616 bl dbfc <memcpy> <== NOT EXECUTED
c3a0: ea00005d b c51c <IMFS_memfile_read+0x250> <== NOT EXECUTED
* 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 )
c3a4: e5943054 ldr r3, [r4, #84] ; 0x54
c3a8: e3a02000 mov r2, #0
c3ac: e1520003 cmp r2, r3
c3b0: e5945050 ldr r5, [r4, #80] ; 0x50
/*
* 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;
c3b4: e1a03001 mov r3, r1
if ( last_byte > the_jnode->info.file.size )
c3b8: e0872001 add r2, r7, r1
c3bc: ca000004 bgt c3d4 <IMFS_memfile_read+0x108>
c3c0: 1a000001 bne c3cc <IMFS_memfile_read+0x100>
c3c4: e1520005 cmp r2, r5
c3c8: 8a000001 bhi c3d4 <IMFS_memfile_read+0x108>
c3cc: e1a05007 mov r5, r7
c3d0: ea000000 b c3d8 <IMFS_memfile_read+0x10c>
my_length = the_jnode->info.file.size - start;
c3d4: e0635005 rsb r5, r3, r5
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
c3d8: e59f3174 ldr r3, [pc, #372] ; c554 <IMFS_memfile_read+0x288>
c3dc: e593a000 ldr sl, [r3]
c3e0: e1a0b00a mov fp, sl
c3e4: e1a0cfcb asr ip, fp, #31
c3e8: e1a0300c mov r3, ip
c3ec: e1a00008 mov r0, r8
c3f0: e1a0200b mov r2, fp
c3f4: e1a01009 mov r1, r9
c3f8: e58dc000 str ip, [sp]
c3fc: eb002de5 bl 17b98 <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
c400: e59dc000 ldr ip, [sp]
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
c404: e1a07000 mov r7, r0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
c408: e1a01009 mov r1, r9
c40c: e1a00008 mov r0, r8
c410: e1a0200b mov r2, fp
c414: e1a0300c mov r3, ip
c418: eb002cb4 bl 176f0 <__divdi3>
if ( start_offset ) {
c41c: e3570000 cmp r7, #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;
c420: e1a08000 mov r8, r0
if ( start_offset ) {
c424: 0a000013 beq c478 <IMFS_memfile_read+0x1ac>
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 );
c428: e1a00004 mov r0, r4
c42c: e1a01008 mov r1, r8
c430: e3a02000 mov r2, #0
c434: ebfffce1 bl b7c0 <IMFS_memfile_get_block_pointer>
assert( block_ptr );
c438: e3500000 cmp r0, #0
c43c: 059f00f4 ldreq r0, [pc, #244] ; c538 <IMFS_memfile_read+0x26c>
c440: 059f1110 ldreq r1, [pc, #272] ; c558 <IMFS_memfile_read+0x28c>
c444: 0a00002c beq c4fc <IMFS_memfile_read+0x230>
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
c448: 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;
c44c: e067a00a rsb sl, r7, sl
c450: e155000a cmp r5, sl
c454: 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 );
c458: e0811007 add r1, r1, r7
c45c: e1a00006 mov r0, r6
c460: e1a0200a mov r2, sl
c464: eb0005e4 bl dbfc <memcpy>
dest += to_copy;
c468: e086600a add r6, r6, sl
block++;
c46c: e2888001 add r8, r8, #1
my_length -= to_copy;
c470: e06a5005 rsb r5, sl, r5
c474: e1a0700a mov r7, sl
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
c478: e59f30d4 ldr r3, [pc, #212] ; c554 <IMFS_memfile_read+0x288>
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
c47c: e1a09003 mov r9, r3
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
c480: e593a000 ldr sl, [r3]
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
c484: ea00000f b c4c8 <IMFS_memfile_read+0x1fc>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
c488: e1a00004 mov r0, r4
c48c: e1a01008 mov r1, r8
c490: e3a02000 mov r2, #0
c494: ebfffcc9 bl b7c0 <IMFS_memfile_get_block_pointer>
assert( block_ptr );
c498: e3500000 cmp r0, #0
c49c: 059f0094 ldreq r0, [pc, #148] ; c538 <IMFS_memfile_read+0x26c>
c4a0: 059f10b4 ldreq r1, [pc, #180] ; c55c <IMFS_memfile_read+0x290>
c4a4: 0a000014 beq c4fc <IMFS_memfile_read+0x230>
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
c4a8: e5901000 ldr r1, [r0]
c4ac: e1a0200a mov r2, sl
c4b0: e1a00006 mov r0, r6
c4b4: eb0005d0 bl dbfc <memcpy>
dest += to_copy;
c4b8: e086600a add r6, r6, sl
block++;
c4bc: e2888001 add r8, r8, #1
my_length -= to_copy;
c4c0: e06a5005 rsb r5, sl, r5
copied += to_copy;
c4c4: e087700a add r7, r7, sl
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
c4c8: e5993000 ldr r3, [r9]
c4cc: e1550003 cmp r5, r3
c4d0: 2affffec bcs c488 <IMFS_memfile_read+0x1bc>
* Phase 3: possibly the first part of one block
*/
assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
c4d4: e3550000 cmp r5, #0
c4d8: 0a00000f beq c51c <IMFS_memfile_read+0x250>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
c4dc: e1a01008 mov r1, r8
c4e0: e1a00004 mov r0, r4
c4e4: e3a02000 mov r2, #0
c4e8: ebfffcb4 bl b7c0 <IMFS_memfile_get_block_pointer>
assert( block_ptr );
c4ec: e2503000 subs r3, r0, #0
c4f0: 1a000004 bne c508 <IMFS_memfile_read+0x23c>
c4f4: e59f003c ldr r0, [pc, #60] ; c538 <IMFS_memfile_read+0x26c><== NOT EXECUTED
c4f8: e59f1060 ldr r1, [pc, #96] ; c560 <IMFS_memfile_read+0x294><== NOT EXECUTED
c4fc: e59f2038 ldr r2, [pc, #56] ; c53c <IMFS_memfile_read+0x270><== NOT EXECUTED
c500: e59f305c ldr r3, [pc, #92] ; c564 <IMFS_memfile_read+0x298><== NOT EXECUTED
c504: eaffff83 b c318 <IMFS_memfile_read+0x4c> <== NOT EXECUTED
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
c508: e1a00006 mov r0, r6
c50c: e5931000 ldr r1, [r3]
c510: e1a02005 mov r2, r5
c514: eb0005b8 bl dbfc <memcpy>
copied += my_length;
c518: e0857007 add r7, r5, r7
}
IMFS_update_atime( the_jnode );
c51c: e28d0004 add r0, sp, #4
c520: e3a01000 mov r1, #0
c524: ebffd692 bl 1f74 <gettimeofday>
c528: e59d3004 ldr r3, [sp, #4]
c52c: e5843040 str r3, [r4, #64] ; 0x40
return copied;
}
c530: e1a00007 mov r0, r7
c534: e8bd8ffe pop {r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000ba8c <IMFS_memfile_remove>:
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
ba8c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
/*
* Perform internal consistency checks
*/
assert( the_jnode );
ba90: e2504000 subs r4, r0, #0
ba94: 059f012c ldreq r0, [pc, #300] ; bbc8 <IMFS_memfile_remove+0x13c>
ba98: 059f112c ldreq r1, [pc, #300] ; bbcc <IMFS_memfile_remove+0x140>
ba9c: 059f212c ldreq r2, [pc, #300] ; bbd0 <IMFS_memfile_remove+0x144>
baa0: 059f312c ldreq r3, [pc, #300] ; bbd4 <IMFS_memfile_remove+0x148>
baa4: 0a000006 beq bac4 <IMFS_memfile_remove+0x38>
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE );
baa8: e594304c ldr r3, [r4, #76] ; 0x4c
baac: e3530005 cmp r3, #5
bab0: 0a000004 beq bac8 <IMFS_memfile_remove+0x3c>
bab4: e59f010c ldr r0, [pc, #268] ; bbc8 <IMFS_memfile_remove+0x13c><== NOT EXECUTED
bab8: e59f1118 ldr r1, [pc, #280] ; bbd8 <IMFS_memfile_remove+0x14c><== NOT EXECUTED
babc: e59f210c ldr r2, [pc, #268] ; bbd0 <IMFS_memfile_remove+0x144><== NOT EXECUTED
bac0: e59f3114 ldr r3, [pc, #276] ; bbdc <IMFS_memfile_remove+0x150><== NOT EXECUTED
bac4: ebfff950 bl a00c <__assert_func> <== NOT EXECUTED
/*
* 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;
bac8: e59f2110 ldr r2, [pc, #272] ; bbe0 <IMFS_memfile_remove+0x154>
* + indirect
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
bacc: e5943058 ldr r3, [r4, #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;
bad0: e5925000 ldr r5, [r2]
* + indirect
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
bad4: 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;
bad8: e1a05125 lsr r5, r5, #2
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
badc: 12840058 addne r0, r4, #88 ; 0x58
bae0: 11a01005 movne r1, r5
bae4: 1bffffb6 blne b9c4 <memfile_free_blocks_in_table>
* + indirect
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
bae8: e594305c ldr r3, [r4, #92] ; 0x5c
baec: e3530000 cmp r3, #0
baf0: 13a06000 movne r6, #0
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
baf4: 159f70e4 ldrne r7, [pc, #228] ; bbe0 <IMFS_memfile_remove+0x154>
* + indirect
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
baf8: 1a000008 bne bb20 <IMFS_memfile_remove+0x94>
bafc: ea00000d b bb38 <IMFS_memfile_remove+0xac>
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
if ( info->doubly_indirect[i] ) {
bb00: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED
bb04: e7932106 ldr r2, [r3, r6, lsl #2] <== NOT EXECUTED
bb08: e3520000 cmp r2, #0 <== NOT EXECUTED
bb0c: e1a00106 lsl r0, r6, #2 <== NOT EXECUTED
memfile_free_blocks_in_table(
bb10: 10830000 addne r0, r3, r0 <== NOT EXECUTED
bb14: 11a01005 movne r1, r5 <== NOT EXECUTED
bb18: 1bffffa9 blne b9c4 <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++ ) {
bb1c: e2866001 add r6, r6, #1 <== NOT EXECUTED
bb20: e5973000 ldr r3, [r7] <== NOT EXECUTED
bb24: e1560123 cmp r6, r3, lsr #2 <== NOT EXECUTED
bb28: 3afffff4 bcc bb00 <IMFS_memfile_remove+0x74> <== 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 );
bb2c: e284005c add r0, r4, #92 ; 0x5c <== NOT EXECUTED
bb30: e1a01005 mov r1, r5 <== NOT EXECUTED
bb34: ebffffa2 bl b9c4 <memfile_free_blocks_in_table> <== NOT EXECUTED
* + indirect
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
bb38: e5943060 ldr r3, [r4, #96] ; 0x60
bb3c: e3530000 cmp r3, #0
bb40: 13a06000 movne r6, #0
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
bb44: 159fa094 ldrne sl, [pc, #148] ; bbe0 <IMFS_memfile_remove+0x154>
* + indirect
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
bb48: 1a000016 bne bba8 <IMFS_memfile_remove+0x11c>
bb4c: ea00001b b bbc0 <IMFS_memfile_remove+0x134>
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
bb50: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED
bb54: e7937106 ldr r7, [r3, r6, lsl #2] <== NOT EXECUTED
if ( !p ) /* ensure we have a valid pointer */
bb58: e3570000 cmp r7, #0 <== NOT EXECUTED
* + indirect
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
bb5c: e1a09106 lsl r9, r6, #2 <== 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 */
bb60: 0a000013 beq bbb4 <IMFS_memfile_remove+0x128> <== NOT EXECUTED
bb64: e3a08000 mov r8, #0 <== NOT EXECUTED
bb68: ea000006 b bb88 <IMFS_memfile_remove+0xfc> <== NOT EXECUTED
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
bb6c: e5973000 ldr r3, [r7] <== NOT EXECUTED
bb70: e3530000 cmp r3, #0 <== NOT EXECUTED
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
bb74: 11a00007 movne r0, r7 <== NOT EXECUTED
bb78: 11a01005 movne r1, r5 <== NOT EXECUTED
bb7c: 1bffff90 blne b9c4 <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++ ) {
bb80: e2888001 add r8, r8, #1 <== NOT EXECUTED
bb84: e2877004 add r7, r7, #4 <== NOT EXECUTED
bb88: e59a3000 ldr r3, [sl] <== NOT EXECUTED
bb8c: e1580123 cmp r8, r3, lsr #2 <== NOT EXECUTED
bb90: 3afffff5 bcc bb6c <IMFS_memfile_remove+0xe0> <== NOT EXECUTED
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
bb94: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED
bb98: e1a01005 mov r1, r5 <== NOT EXECUTED
bb9c: e0800009 add r0, r0, r9 <== NOT EXECUTED
bba0: ebffff87 bl b9c4 <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++ ) {
bba4: e2866001 add r6, r6, #1 <== NOT EXECUTED
bba8: e59a3000 ldr r3, [sl] <== NOT EXECUTED
bbac: e1560123 cmp r6, r3, lsr #2 <== NOT EXECUTED
bbb0: 3affffe6 bcc bb50 <IMFS_memfile_remove+0xc4> <== NOT EXECUTED
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
bbb4: e2840060 add r0, r4, #96 ; 0x60 <== NOT EXECUTED
bbb8: e1a01005 mov r1, r5 <== NOT EXECUTED
bbbc: ebffff80 bl b9c4 <memfile_free_blocks_in_table> <== NOT EXECUTED
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
bbc0: e3a00000 mov r0, #0
bbc4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
0000ba40 <IMFS_memfile_remove_block>:
MEMFILE_STATIC int IMFS_memfile_remove_block(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
ba40: 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 );
ba44: e3a02000 mov r2, #0 <== NOT EXECUTED
ba48: ebffff5c bl b7c0 <IMFS_memfile_get_block_pointer> <== NOT EXECUTED
assert( block_ptr );
ba4c: e2503000 subs r3, r0, #0 <== NOT EXECUTED
ba50: 059f0024 ldreq r0, [pc, #36] ; ba7c <IMFS_memfile_remove_block+0x3c><== NOT EXECUTED
ba54: 059f1024 ldreq r1, [pc, #36] ; ba80 <IMFS_memfile_remove_block+0x40><== NOT EXECUTED
ba58: 059f2024 ldreq r2, [pc, #36] ; ba84 <IMFS_memfile_remove_block+0x44><== NOT EXECUTED
ba5c: 059f3024 ldreq r3, [pc, #36] ; ba88 <IMFS_memfile_remove_block+0x48><== NOT EXECUTED
ba60: 0bfff969 bleq a00c <__assert_func> <== NOT EXECUTED
if ( block_ptr ) {
ptr = *block_ptr;
*block_ptr = 0;
ba64: 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;
ba68: e5930000 ldr r0, [r3] <== NOT EXECUTED
*block_ptr = 0;
ba6c: e5832000 str r2, [r3] <== NOT EXECUTED
memfile_free_block( ptr );
ba70: ebffff3d bl b76c <memfile_free_block> <== NOT EXECUTED
}
return 1;
}
ba74: e3a00001 mov r0, #1 <== NOT EXECUTED
ba78: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
0000bf9c <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
bf9c: e92d4ff7 push {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}
/*
* Perform internal consistency checks
*/
assert( the_jnode );
bfa0: e2504000 subs r4, r0, #0
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
bfa4: e1a08001 mov r8, r1
bfa8: e1a0a002 mov sl, r2
bfac: e1a06003 mov r6, r3
bfb0: e59d5030 ldr r5, [sp, #48] ; 0x30
/*
* Perform internal consistency checks
*/
assert( the_jnode );
bfb4: 059f0204 ldreq r0, [pc, #516] ; c1c0 <IMFS_memfile_write+0x224>
bfb8: 059f1204 ldreq r1, [pc, #516] ; c1c4 <IMFS_memfile_write+0x228>
bfbc: 059f2204 ldreq r2, [pc, #516] ; c1c8 <IMFS_memfile_write+0x22c>
bfc0: 059f3204 ldreq r3, [pc, #516] ; c1cc <IMFS_memfile_write+0x230>
bfc4: 0a000006 beq bfe4 <IMFS_memfile_write+0x48>
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE );
bfc8: e594304c ldr r3, [r4, #76] ; 0x4c
bfcc: e3530005 cmp r3, #5
bfd0: 0a000004 beq bfe8 <IMFS_memfile_write+0x4c>
bfd4: e59f01e4 ldr r0, [pc, #484] ; c1c0 <IMFS_memfile_write+0x224><== NOT EXECUTED
bfd8: e59f11f0 ldr r1, [pc, #496] ; c1d0 <IMFS_memfile_write+0x234><== NOT EXECUTED
bfdc: e59f21e4 ldr r2, [pc, #484] ; c1c8 <IMFS_memfile_write+0x22c><== NOT EXECUTED
bfe0: e59f31ec ldr r3, [pc, #492] ; c1d4 <IMFS_memfile_write+0x238><== NOT EXECUTED
bfe4: ebfff808 bl a00c <__assert_func> <== NOT EXECUTED
/*
* Error check arguments
*/
assert( source );
bfe8: e3560000 cmp r6, #0
bfec: 059f01cc ldreq r0, [pc, #460] ; c1c0 <IMFS_memfile_write+0x224>
bff0: 059f11e0 ldreq r1, [pc, #480] ; c1d8 <IMFS_memfile_write+0x23c>
bff4: 059f21cc ldreq r2, [pc, #460] ; c1c8 <IMFS_memfile_write+0x22c>
bff8: 059f31dc ldreq r3, [pc, #476] ; c1dc <IMFS_memfile_write+0x240>
bffc: 0afffff8 beq bfe4 <IMFS_memfile_write+0x48>
/*
* If there is nothing to write, then quick exit.
*/
my_length = length;
if ( !my_length )
c000: e3550000 cmp r5, #0
c004: 1a000002 bne c014 <IMFS_memfile_write+0x78>
rtems_set_errno_and_return_minus_one( EINVAL );
c008: eb0004ed bl d3c4 <__errno> <== NOT EXECUTED
c00c: e3a03016 mov r3, #22 <== NOT EXECUTED
c010: ea00000e b c050 <IMFS_memfile_write+0xb4> <== NOT EXECUTED
* 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 ) {
c014: e5943054 ldr r3, [r4, #84] ; 0x54
c018: e3530000 cmp r3, #0
c01c: e0851001 add r1, r5, r1
c020: ba000003 blt c034 <IMFS_memfile_write+0x98>
c024: 1a00000c bne c05c <IMFS_memfile_write+0xc0>
c028: e5943050 ldr r3, [r4, #80] ; 0x50
c02c: e1530001 cmp r3, r1
c030: 2a000009 bcs c05c <IMFS_memfile_write+0xc0>
status = IMFS_memfile_extend( the_jnode, last_byte );
c034: e1a00004 mov r0, r4
c038: e3a02000 mov r2, #0
c03c: ebffff40 bl bd44 <IMFS_memfile_extend>
if ( status )
c040: e3500000 cmp r0, #0
c044: 0a000004 beq c05c <IMFS_memfile_write+0xc0>
rtems_set_errno_and_return_minus_one( ENOSPC );
c048: eb0004dd bl d3c4 <__errno> <== NOT EXECUTED
c04c: e3a0301c mov r3, #28 <== NOT EXECUTED
c050: e5803000 str r3, [r0] <== NOT EXECUTED
c054: e3e07000 mvn r7, #0 <== NOT EXECUTED
c058: ea000056 b c1b8 <IMFS_memfile_write+0x21c> <== NOT EXECUTED
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
c05c: e59f317c ldr r3, [pc, #380] ; c1e0 <IMFS_memfile_write+0x244>
c060: e5939000 ldr r9, [r3]
c064: e1a0b009 mov fp, r9
c068: e1a0cfcb asr ip, fp, #31
c06c: e1a0300c mov r3, ip
c070: e1a00008 mov r0, r8
c074: e1a0200b mov r2, fp
c078: e1a0100a mov r1, sl
c07c: e58dc000 str ip, [sp]
c080: eb002ec4 bl 17b98 <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
c084: e59dc000 ldr ip, [sp]
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
c088: e1a07000 mov r7, r0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
c08c: e1a0100a mov r1, sl
c090: e1a00008 mov r0, r8
c094: e1a0200b mov r2, fp
c098: e1a0300c mov r3, ip
c09c: eb002d93 bl 176f0 <__divdi3>
if ( start_offset ) {
c0a0: e3570000 cmp r7, #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;
c0a4: e1a08000 mov r8, r0
if ( start_offset ) {
c0a8: 0a000013 beq c0fc <IMFS_memfile_write+0x160>
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 );
c0ac: e1a01008 mov r1, r8
c0b0: e1a00004 mov r0, r4
c0b4: e3a02000 mov r2, #0
c0b8: ebfffdc0 bl b7c0 <IMFS_memfile_get_block_pointer>
assert( block_ptr );
c0bc: e3500000 cmp r0, #0
c0c0: 059f00f8 ldreq r0, [pc, #248] ; c1c0 <IMFS_memfile_write+0x224>
c0c4: 03a01fc7 moveq r1, #796 ; 0x31c
c0c8: 0a00002c beq c180 <IMFS_memfile_write+0x1e4>
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 );
c0cc: 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;
c0d0: e067a009 rsb sl, r7, r9
c0d4: e15a0005 cmp sl, r5
c0d8: 21a0a005 movcs sl, r5
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 );
c0dc: e0800007 add r0, r0, r7
c0e0: e1a01006 mov r1, r6
c0e4: e1a0200a mov r2, sl
c0e8: eb0006c3 bl dbfc <memcpy>
src += to_copy;
c0ec: e086600a add r6, r6, sl
block++;
c0f0: e2888001 add r8, r8, #1
my_length -= to_copy;
c0f4: e06a5005 rsb r5, sl, r5
copied += to_copy;
c0f8: e1a0700a mov r7, sl
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
c0fc: e59f30dc ldr r3, [pc, #220] ; c1e0 <IMFS_memfile_write+0x244>
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
c100: e1a09003 mov r9, r3
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
c104: e593a000 ldr sl, [r3]
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
c108: ea00000f b c14c <IMFS_memfile_write+0x1b0>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
c10c: e1a00004 mov r0, r4
c110: e1a01008 mov r1, r8
c114: e3a02000 mov r2, #0
c118: ebfffda8 bl b7c0 <IMFS_memfile_get_block_pointer>
assert( block_ptr );
c11c: e3500000 cmp r0, #0
c120: 059f0098 ldreq r0, [pc, #152] ; c1c0 <IMFS_memfile_write+0x224>
c124: 03a01e33 moveq r1, #816 ; 0x330
c128: 0a000014 beq c180 <IMFS_memfile_write+0x1e4>
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 );
c12c: e1a01006 mov r1, r6
c130: e5900000 ldr r0, [r0]
c134: e1a0200a mov r2, sl
c138: eb0006af bl dbfc <memcpy>
src += to_copy;
c13c: e086600a add r6, r6, sl
block++;
c140: e2888001 add r8, r8, #1
my_length -= to_copy;
c144: e06a5005 rsb r5, sl, r5
*
* 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(
c148: e087700a add r7, r7, sl
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
c14c: e5993000 ldr r3, [r9]
c150: e1550003 cmp r5, r3
c154: 2affffec bcs c10c <IMFS_memfile_write+0x170>
*/
assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
c158: e3550000 cmp r5, #0
c15c: 0a00000f beq c1a0 <IMFS_memfile_write+0x204>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
c160: e1a01008 mov r1, r8
c164: e1a00004 mov r0, r4
c168: e3a02000 mov r2, #0
c16c: ebfffd93 bl b7c0 <IMFS_memfile_get_block_pointer>
assert( block_ptr );
c170: e3500000 cmp r0, #0
c174: 1a000004 bne c18c <IMFS_memfile_write+0x1f0>
c178: e59f0040 ldr r0, [pc, #64] ; c1c0 <IMFS_memfile_write+0x224><== NOT EXECUTED
c17c: e59f1060 ldr r1, [pc, #96] ; c1e4 <IMFS_memfile_write+0x248><== NOT EXECUTED
c180: e59f2040 ldr r2, [pc, #64] ; c1c8 <IMFS_memfile_write+0x22c><== NOT EXECUTED
c184: e59f305c ldr r3, [pc, #92] ; c1e8 <IMFS_memfile_write+0x24c><== NOT EXECUTED
c188: eaffff95 b bfe4 <IMFS_memfile_write+0x48> <== NOT EXECUTED
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 );
c18c: e5900000 ldr r0, [r0]
c190: e1a01006 mov r1, r6
c194: e1a02005 mov r2, r5
c198: eb000697 bl dbfc <memcpy>
my_length = 0;
copied += to_copy;
c19c: e0877005 add r7, r7, r5
}
IMFS_mtime_ctime_update( the_jnode );
c1a0: e28d0004 add r0, sp, #4
c1a4: e3a01000 mov r1, #0
c1a8: ebffd771 bl 1f74 <gettimeofday>
c1ac: e59d3004 ldr r3, [sp, #4]
c1b0: e5843048 str r3, [r4, #72] ; 0x48
c1b4: e5843044 str r3, [r4, #68] ; 0x44
return copied;
}
c1b8: e1a00007 mov r0, r7
c1bc: e8bd8ffe pop {r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
000016f0 <IMFS_mknod>:
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
16f0: e92d40f0 push {r4, r5, r6, r7, lr}
16f4: e24dd040 sub sp, sp, #64 ; 0x40
16f8: e1a04001 mov r4, r1
16fc: e1a07000 mov r7, r0
1700: e1a06002 mov r6, r2
1704: e1a05003 mov r5, r3
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 );
1708: eb003332 bl e3d8 <strlen>
170c: e28d303c add r3, sp, #60 ; 0x3c
1710: e1a01000 mov r1, r0
1714: e28d2004 add r2, sp, #4
1718: e1a00007 mov r0, r7
171c: eb00219f bl 9da0 <IMFS_get_token>
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
1720: e2043a0f and r3, r4, #61440 ; 0xf000
1724: e3530901 cmp r3, #16384 ; 0x4000
1728: 0a00000e beq 1768 <IMFS_mknod+0x78>
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
172c: e3530902 cmp r3, #32768 ; 0x8000
1730: 03a01005 moveq r1, #5
1734: 0a00000c beq 176c <IMFS_mknod+0x7c>
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
1738: e3530a06 cmp r3, #24576 ; 0x6000
173c: 13530a02 cmpne r3, #8192 ; 0x2000
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
1740: 058d6028 streq r6, [sp, #40] ; 0x28
1744: 058d502c streq r5, [sp, #44] ; 0x2c
1748: 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) ) {
174c: 0a000006 beq 176c <IMFS_mknod+0x7c>
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
}
else if (S_ISFIFO(mode))
1750: e3530a01 cmp r3, #4096 ; 0x1000
1754: 03a01007 moveq r1, #7
1758: 0a000003 beq 176c <IMFS_mknod+0x7c>
type = IMFS_FIFO;
else {
rtems_set_errno_and_return_minus_one( EINVAL );
175c: eb002f18 bl d3c4 <__errno> <== NOT EXECUTED
1760: e3a03016 mov r3, #22 <== NOT EXECUTED
1764: ea00000b b 1798 <IMFS_mknod+0xa8> <== NOT EXECUTED
1768: e3a01001 mov r1, #1
* 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(
176c: e28dc028 add ip, sp, #40 ; 0x28
1770: e59d0054 ldr r0, [sp, #84] ; 0x54
1774: e1a03004 mov r3, r4
1778: e28d2004 add r2, sp, #4
177c: e58dc000 str ip, [sp]
1780: eb001e51 bl 90cc <IMFS_create_node>
new_name,
mode,
&info
);
if ( !new_node )
1784: e3500000 cmp r0, #0
1788: 13a00000 movne r0, #0
178c: 1a000003 bne 17a0 <IMFS_mknod+0xb0>
rtems_set_errno_and_return_minus_one( ENOMEM );
1790: eb002f0b bl d3c4 <__errno> <== NOT EXECUTED
1794: e3a0300c mov r3, #12 <== NOT EXECUTED
1798: e5803000 str r3, [r0] <== NOT EXECUTED
179c: e3e00000 mvn r0, #0 <== NOT EXECUTED
return 0;
}
17a0: e28dd040 add sp, sp, #64 ; 0x40
17a4: e8bd80f0 pop {r4, r5, r6, r7, pc}
000017a8 <IMFS_mount>:
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
17a8: e5903008 ldr r3, [r0, #8]
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
17ac: e593204c ldr r2, [r3, #76] ; 0x4c
17b0: e3520001 cmp r2, #1
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
17b4: e52de004 push {lr} ; (str lr, [sp, #-4]!)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
17b8: 0a000004 beq 17d0 <IMFS_mount+0x28>
rtems_set_errno_and_return_minus_one( ENOTDIR );
17bc: eb002f00 bl d3c4 <__errno> <== NOT EXECUTED
17c0: e3a03014 mov r3, #20 <== NOT EXECUTED
17c4: e5803000 str r3, [r0] <== NOT EXECUTED
17c8: e3e00000 mvn r0, #0 <== NOT EXECUTED
17cc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
/*
* Set mt_fs pointer to point to the mount table entry for
* the mounted file system.
*/
node->info.directory.mt_fs = mt_entry;
17d0: e583005c str r0, [r3, #92] ; 0x5c
17d4: e3a00000 mov r0, #0
return 0;
}
17d8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
00003cc0 <IMFS_print_jnode>:
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
3cc0: e92d4030 push {r4, r5, lr}
assert( the_jnode );
3cc4: e2504000 subs r4, r0, #0
3cc8: 059f0130 ldreq r0, [pc, #304] ; 3e00 <IMFS_print_jnode+0x140>
3ccc: 03a01038 moveq r1, #56 ; 0x38
3cd0: 059f212c ldreq r2, [pc, #300] ; 3e04 <IMFS_print_jnode+0x144>
3cd4: 059f312c ldreq r3, [pc, #300] ; 3e08 <IMFS_print_jnode+0x148>
3cd8: 0a00002f beq 3d9c <IMFS_print_jnode+0xdc>
fprintf(stdout, "%s", the_jnode->name );
3cdc: e59f5128 ldr r5, [pc, #296] ; 3e0c <IMFS_print_jnode+0x14c>
3ce0: e5953000 ldr r3, [r5]
3ce4: e284000c add r0, r4, #12
3ce8: e5931008 ldr r1, [r3, #8]
3cec: eb003745 bl 11a08 <fputs>
switch( the_jnode->type ) {
3cf0: e594204c ldr r2, [r4, #76] ; 0x4c
3cf4: e2423001 sub r3, r2, #1
3cf8: e3530006 cmp r3, #6
3cfc: 979ff103 ldrls pc, [pc, r3, lsl #2]
3d00: ea000034 b 3dd8 <IMFS_print_jnode+0x118> <== NOT EXECUTED
3d04: 00003d20 .word 0x00003d20 <== NOT EXECUTED
3d08: 00003d34 .word 0x00003d34 <== NOT EXECUTED
3d0c: 00003d7c .word 0x00003d7c <== NOT EXECUTED
3d10: 00003da0 .word 0x00003da0 <== NOT EXECUTED
3d14: 00003d64 .word 0x00003d64 <== NOT EXECUTED
3d18: 00003d48 .word 0x00003d48 <== NOT EXECUTED
3d1c: 00003dbc .word 0x00003dbc <== NOT EXECUTED
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
3d20: e5953000 ldr r3, [r5]
3d24: e3a0002f mov r0, #47 ; 0x2f
3d28: e5931008 ldr r1, [r3, #8]
3d2c: eb0036f0 bl 118f4 <fputc>
break;
3d30: ea00002f b 3df4 <IMFS_print_jnode+0x134>
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
3d34: e5952000 ldr r2, [r5]
3d38: e5943054 ldr r3, [r4, #84] ; 0x54
3d3c: e5920008 ldr r0, [r2, #8]
3d40: e59f10c8 ldr r1, [pc, #200] ; 3e10 <IMFS_print_jnode+0x150>
3d44: ea000003 b 3d58 <IMFS_print_jnode+0x98>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
3d48: e5952000 ldr r2, [r5] <== NOT EXECUTED
3d4c: e5943058 ldr r3, [r4, #88] ; 0x58 <== NOT EXECUTED
3d50: e5920008 ldr r0, [r2, #8] <== NOT EXECUTED
3d54: e59f10b8 ldr r1, [pc, #184] ; 3e14 <IMFS_print_jnode+0x154><== NOT EXECUTED
3d58: e5942050 ldr r2, [r4, #80] ; 0x50
3d5c: eb0036c8 bl 11884 <fprintf>
(uint32_t)the_jnode->info.linearfile.size,
the_jnode->info.linearfile.direct
);
break;
3d60: ea000023 b 3df4 <IMFS_print_jnode+0x134>
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
3d64: e5953000 ldr r3, [r5]
3d68: e5942050 ldr r2, [r4, #80] ; 0x50
3d6c: e5930008 ldr r0, [r3, #8]
3d70: e59f10a0 ldr r1, [pc, #160] ; 3e18 <IMFS_print_jnode+0x158>
3d74: eb0036c2 bl 11884 <fprintf>
(uint32_t)the_jnode->info.file.size );
#endif
break;
3d78: ea00001d b 3df4 <IMFS_print_jnode+0x134>
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
3d7c: e5953000 ldr r3, [r5] <== NOT EXECUTED
3d80: e59f0094 ldr r0, [pc, #148] ; 3e1c <IMFS_print_jnode+0x15c><== NOT EXECUTED
3d84: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED
3d88: eb00371e bl 11a08 <fputs> <== NOT EXECUTED
assert(0);
3d8c: e59f006c ldr r0, [pc, #108] ; 3e00 <IMFS_print_jnode+0x140><== NOT EXECUTED
3d90: e3a0105d mov r1, #93 ; 0x5d <== NOT EXECUTED
3d94: e59f2068 ldr r2, [pc, #104] ; 3e04 <IMFS_print_jnode+0x144><== NOT EXECUTED
3d98: e59f3080 ldr r3, [pc, #128] ; 3e20 <IMFS_print_jnode+0x160><== NOT EXECUTED
3d9c: eb000249 bl 46c8 <__assert_func> <== NOT EXECUTED
break;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
3da0: e5953000 ldr r3, [r5] <== NOT EXECUTED
3da4: e59f0070 ldr r0, [pc, #112] ; 3e1c <IMFS_print_jnode+0x15c><== NOT EXECUTED
3da8: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED
3dac: eb003715 bl 11a08 <fputs> <== NOT EXECUTED
assert(0);
3db0: e59f0048 ldr r0, [pc, #72] ; 3e00 <IMFS_print_jnode+0x140> <== NOT EXECUTED
3db4: e3a01062 mov r1, #98 ; 0x62 <== NOT EXECUTED
3db8: eafffff5 b 3d94 <IMFS_print_jnode+0xd4> <== NOT EXECUTED
break;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
3dbc: e5953000 ldr r3, [r5] <== NOT EXECUTED
3dc0: e59f005c ldr r0, [pc, #92] ; 3e24 <IMFS_print_jnode+0x164> <== NOT EXECUTED
3dc4: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED
3dc8: eb00370e bl 11a08 <fputs> <== NOT EXECUTED
assert(0);
3dcc: e59f002c ldr r0, [pc, #44] ; 3e00 <IMFS_print_jnode+0x140> <== NOT EXECUTED
3dd0: e3a01067 mov r1, #103 ; 0x67 <== NOT EXECUTED
3dd4: eaffffee b 3d94 <IMFS_print_jnode+0xd4> <== NOT EXECUTED
break;
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
3dd8: e5953000 ldr r3, [r5] <== NOT EXECUTED
3ddc: e59f1044 ldr r1, [pc, #68] ; 3e28 <IMFS_print_jnode+0x168> <== NOT EXECUTED
3de0: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
3de4: eb0036a6 bl 11884 <fprintf> <== NOT EXECUTED
assert(0);
3de8: e59f0010 ldr r0, [pc, #16] ; 3e00 <IMFS_print_jnode+0x140> <== NOT EXECUTED
3dec: e3a0106c mov r1, #108 ; 0x6c <== NOT EXECUTED
3df0: eaffffe7 b 3d94 <IMFS_print_jnode+0xd4> <== NOT EXECUTED
break;
}
puts("");
3df4: e59f0030 ldr r0, [pc, #48] ; 3e2c <IMFS_print_jnode+0x16c>
}
3df8: e8bd4030 pop {r4, r5, lr}
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
assert(0);
break;
}
puts("");
3dfc: ea003dcf b 13540 <puts>
000017e8 <IMFS_readlink>:
)
{
IMFS_jnode_t *node;
int i;
node = loc->node_access;
17e8: e5903000 ldr r3, [r0]
if ( node->type != IMFS_SYM_LINK )
17ec: e593004c ldr r0, [r3, #76] ; 0x4c
17f0: e3500004 cmp r0, #4
int IMFS_readlink(
rtems_filesystem_location_info_t *loc,
char *buf, /* OUT */
size_t bufsize
)
{
17f4: e52de004 push {lr} ; (str lr, [sp, #-4]!)
IMFS_jnode_t *node;
int i;
node = loc->node_access;
if ( node->type != IMFS_SYM_LINK )
17f8: 03a00000 moveq r0, #0
17fc: 0a000006 beq 181c <IMFS_readlink+0x34>
rtems_set_errno_and_return_minus_one( EINVAL );
1800: eb002eef bl d3c4 <__errno> <== NOT EXECUTED
1804: e3a03016 mov r3, #22 <== NOT EXECUTED
1808: e5803000 str r3, [r0] <== NOT EXECUTED
180c: e3e00000 mvn r0, #0 <== NOT EXECUTED
1810: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
buf[i] = node->info.sym_link.name[i];
1814: e7c1c000 strb ip, [r1, r0]
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++ )
1818: e2800001 add r0, r0, #1
181c: e1500002 cmp r0, r2
1820: 249df004 popcs {pc} ; (ldrcs pc, [sp], #4)
1824: e593c050 ldr ip, [r3, #80] ; 0x50
1828: e7dcc000 ldrb ip, [ip, r0]
182c: e35c0000 cmp ip, #0
1830: 1afffff7 bne 1814 <IMFS_readlink+0x2c>
buf[i] = node->info.sym_link.name[i];
return i;
}
1834: e49df004 pop {pc} ; (ldr pc, [sp], #4)
00009f1c <IMFS_stat>:
{
IMFS_fs_info_t *fs_info;
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
9f1c: e5903000 ldr r3, [r0]
switch ( the_jnode->type ) {
9f20: e593204c ldr r2, [r3, #76] ; 0x4c
9f24: e2422002 sub r2, r2, #2
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
9f28: e92d4810 push {r4, fp, lr}
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
9f2c: e3520005 cmp r2, #5
9f30: 979ff102 ldrls pc, [pc, r2, lsl #2]
9f34: ea000012 b 9f84 <IMFS_stat+0x68> <== NOT EXECUTED
9f38: 00009f50 .word 0x00009f50 <== NOT EXECUTED
9f3c: 00009f84 .word 0x00009f84 <== NOT EXECUTED
9f40: 00009f70 .word 0x00009f70 <== NOT EXECUTED
9f44: 00009f64 .word 0x00009f64 <== NOT EXECUTED
9f48: 00009f64 .word 0x00009f64 <== NOT EXECUTED
9f4c: 00009f70 .word 0x00009f70 <== NOT EXECUTED
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
9f50: e2832050 add r2, r3, #80 ; 0x50
9f54: e8921004 ldm r2, {r2, ip}
9f58: e581c01c str ip, [r1, #28]
9f5c: e5812018 str r2, [r1, #24]
break;
9f60: ea00000c b 9f98 <IMFS_stat+0x7c>
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
9f64: e283c050 add ip, r3, #80 ; 0x50
9f68: e89c1800 ldm ip, {fp, ip}
9f6c: ea000001 b 9f78 <IMFS_stat+0x5c>
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
9f70: e3a0b000 mov fp, #0 <== NOT EXECUTED
9f74: e3a0c000 mov ip, #0 <== NOT EXECUTED
9f78: e581b020 str fp, [r1, #32]
9f7c: e581c024 str ip, [r1, #36] ; 0x24
break;
9f80: ea000004 b 9f98 <IMFS_stat+0x7c>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
9f84: eb000d0e bl d3c4 <__errno> <== NOT EXECUTED
9f88: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
9f8c: e5803000 str r3, [r0] <== NOT EXECUTED
9f90: e3e00000 mvn r0, #0 <== NOT EXECUTED
9f94: e8bd8810 pop {r4, fp, pc} <== 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;
9f98: e5932030 ldr r2, [r3, #48] ; 0x30
9f9c: e581200c str r2, [r1, #12]
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
9fa0: e5932038 ldr r2, [r3, #56] ; 0x38
9fa4: 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;
9fa8: e5932040 ldr r2, [r3, #64] ; 0x40
9fac: 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 );
9fb0: e5902010 ldr r2, [r0, #16]
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;
9fb4: e5930044 ldr r0, [r3, #68] ; 0x44
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;
9fb8: e1d343b4 ldrh r4, [r3, #52] ; 0x34
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;
9fbc: e5810030 str r0, [r1, #48] ; 0x30
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;
9fc0: e1c141b0 strh r4, [r1, #16]
* 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 );
9fc4: e5920034 ldr r0, [r2, #52] ; 0x34
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;
buf->st_ctime = the_jnode->stat_ctime;
9fc8: e5932048 ldr r2, [r3, #72] ; 0x48
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
9fcc: e59fc030 ldr ip, [pc, #48] ; a004 <IMFS_stat+0xe8>
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;
buf->st_ctime = the_jnode->stat_ctime;
9fd0: e5812038 str r2, [r1, #56] ; 0x38
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;
9fd4: e1d323bc ldrh r2, [r3, #60] ; 0x3c
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;
9fd8: e59cc000 ldr ip, [ip]
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;
9fdc: e1c121b2 strh r2, [r1, #18]
* 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 );
9fe0: e5900000 ldr r0, [r0]
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;
9fe4: e581c040 str ip, [r1, #64] ; 0x40
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;
9fe8: e1d333be ldrh r3, [r3, #62] ; 0x3e
/*
* 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 =
9fec: e59fc014 ldr ip, [pc, #20] ; a008 <IMFS_stat+0xec>
9ff0: e5810004 str r0, [r1, #4]
9ff4: e581c000 str ip, [r1]
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;
9ff8: 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;
9ffc: e3a00000 mov r0, #0
return 0;
}
a000: e8bd8810 pop {r4, fp, pc}
00001894 <IMFS_symlink>:
int IMFS_symlink(
rtems_filesystem_location_info_t *parent_loc,
const char *link_name,
const char *node_name
)
{
1894: e92d40f0 push {r4, r5, r6, r7, lr}
1898: e1a05000 mov r5, r0
189c: 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 );
18a0: e1a00002 mov r0, r2
int IMFS_symlink(
rtems_filesystem_location_info_t *parent_loc,
const char *link_name,
const char *node_name
)
{
18a4: e1a07002 mov r7, r2
18a8: e1a06001 mov r6, r1
int i;
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( node_name, strlen( node_name ), new_name, &i );
18ac: eb0032c9 bl e3d8 <strlen>
18b0: e28d4004 add r4, sp, #4
18b4: e1a01000 mov r1, r0
18b8: e1a02004 mov r2, r4
18bc: e28d303c add r3, sp, #60 ; 0x3c
18c0: e1a00007 mov r0, r7
18c4: eb002135 bl 9da0 <IMFS_get_token>
/*
* Duplicate link name
*/
info.sym_link.name = strdup(link_name);
18c8: e1a00006 mov r0, r6
18cc: eb0032ad bl e388 <strdup>
if (info.sym_link.name == NULL) {
18d0: 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);
18d4: e58d0028 str r0, [sp, #40] ; 0x28
if (info.sym_link.name == NULL) {
18d8: 0a00000b beq 190c <IMFS_symlink+0x78>
* 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(
18dc: e28dc028 add ip, sp, #40 ; 0x28
18e0: e1a00005 mov r0, r5
18e4: e1a02004 mov r2, r4
18e8: e3a01004 mov r1, #4
18ec: e59f3030 ldr r3, [pc, #48] ; 1924 <IMFS_symlink+0x90>
18f0: e58dc000 str ip, [sp]
18f4: eb001df4 bl 90cc <IMFS_create_node>
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if (new_node == NULL) {
18f8: e3500000 cmp r0, #0
18fc: 13a00000 movne r0, #0
1900: 1a000005 bne 191c <IMFS_symlink+0x88>
free(info.sym_link.name);
1904: e59d0028 ldr r0, [sp, #40] ; 0x28 <== NOT EXECUTED
1908: eb000170 bl 1ed0 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
190c: eb002eac bl d3c4 <__errno> <== NOT EXECUTED
1910: e3a0300c mov r3, #12 <== NOT EXECUTED
1914: e5803000 str r3, [r0] <== NOT EXECUTED
1918: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return 0;
}
191c: e28dd040 add sp, sp, #64 ; 0x40
1920: e8bd80f0 pop {r4, r5, r6, r7, pc}
00001928 <IMFS_unlink>:
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
1928: 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;
192c: e5915000 ldr r5, [r1]
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
1930: e595304c ldr r3, [r5, #76] ; 0x4c
1934: e3530003 cmp r3, #3
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
1938: e24dd01c sub sp, sp, #28
193c: e1a04001 mov r4, r1
1940: e1a06000 mov r6, r0
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
1944: 1a000025 bne 19e0 <IMFS_unlink+0xb8>
if ( !node->info.hard_link.link_node )
1948: e595e050 ldr lr, [r5, #80] ; 0x50
194c: e35e0000 cmp lr, #0
1950: 1a000003 bne 1964 <IMFS_unlink+0x3c>
rtems_set_errno_and_return_minus_one( EINVAL );
1954: eb002e9a bl d3c4 <__errno> <== NOT EXECUTED
1958: e3a03016 mov r3, #22 <== NOT EXECUTED
195c: e5803000 str r3, [r0] <== NOT EXECUTED
1960: ea000014 b 19b8 <IMFS_unlink+0x90> <== NOT EXECUTED
the_link = *loc;
1964: e1a07001 mov r7, r1
1968: e8b7000f ldm r7!, {r0, r1, r2, r3}
196c: e1a0c00d mov ip, sp
1970: e8ac000f stmia ip!, {r0, r1, r2, r3}
the_link.node_access = node->info.hard_link.link_node;
1974: e28d801c add r8, sp, #28
1978: 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;
197c: e5973000 ldr r3, [r7]
the_link.node_access = node->info.hard_link.link_node;
IMFS_Set_handlers( &the_link );
1980: 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;
1984: e58c3000 str r3, [ip]
the_link.node_access = node->info.hard_link.link_node;
IMFS_Set_handlers( &the_link );
1988: eb001e1e bl 9208 <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)
198c: e5953050 ldr r3, [r5, #80] ; 0x50
1990: e1d323b4 ldrh r2, [r3, #52] ; 0x34
1994: e3520001 cmp r2, #1
1998: 1a000008 bne 19c0 <IMFS_unlink+0x98>
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
199c: e1a0100d mov r1, sp
19a0: e1a00006 mov r0, r6
19a4: e59d3008 ldr r3, [sp, #8]
19a8: e1a0e00f mov lr, pc
19ac: e593f034 ldr pc, [r3, #52] ; 0x34
if ( result != 0 )
19b0: e3500000 cmp r0, #0
19b4: 0a000009 beq 19e0 <IMFS_unlink+0xb8>
19b8: e3e00000 mvn r0, #0
19bc: ea00000c b 19f4 <IMFS_unlink+0xcc>
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
19c0: e2422001 sub r2, r2, #1
19c4: e1c323b4 strh r2, [r3, #52] ; 0x34
IMFS_update_ctime( node->info.hard_link.link_node );
19c8: e28d0014 add r0, sp, #20
19cc: e3a01000 mov r1, #0
19d0: eb000167 bl 1f74 <gettimeofday>
19d4: e5953050 ldr r3, [r5, #80] ; 0x50
19d8: e59d2014 ldr r2, [sp, #20]
19dc: e5832048 str r2, [r3, #72] ; 0x48
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
19e0: e1a00006 mov r0, r6
19e4: e1a01004 mov r1, r4
19e8: e5943008 ldr r3, [r4, #8]
19ec: e1a0e00f mov lr, pc
19f0: e593f034 ldr pc, [r3, #52] ; 0x34
return result;
}
19f4: e28dd01c add sp, sp, #28
19f8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
000019fc <IMFS_unmount>:
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
19fc: e5903008 ldr r3, [r0, #8]
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
1a00: e593204c ldr r2, [r3, #76] ; 0x4c
1a04: e3520001 cmp r2, #1
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
1a08: e52de004 push {lr} ; (str lr, [sp, #-4]!)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
1a0c: 0a000002 beq 1a1c <IMFS_unmount+0x20>
rtems_set_errno_and_return_minus_one( ENOTDIR );
1a10: eb002e6b bl d3c4 <__errno> <== NOT EXECUTED
1a14: e3a03014 mov r3, #20 <== NOT EXECUTED
1a18: ea000004 b 1a30 <IMFS_unmount+0x34> <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
1a1c: e593205c ldr r2, [r3, #92] ; 0x5c
1a20: e3520000 cmp r2, #0
1a24: 1a000004 bne 1a3c <IMFS_unmount+0x40>
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
1a28: eb002e65 bl d3c4 <__errno> <== NOT EXECUTED
1a2c: e3a03016 mov r3, #22 <== NOT EXECUTED
1a30: e5803000 str r3, [r0] <== NOT EXECUTED
1a34: e3e00000 mvn r0, #0 <== NOT EXECUTED
1a38: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
/*
* 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;
1a3c: e3a00000 mov r0, #0
1a40: e583005c str r0, [r3, #92] ; 0x5c
return 0;
}
1a44: e49df004 pop {pc} ; (ldr pc, [sp], #4)
00002118 <RTEMS_Malloc_Initialize>:
#endif
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
2118: e59f30c8 ldr r3, [pc, #200] ; 21e8 <RTEMS_Malloc_Initialize+0xd0>
211c: e5933000 ldr r3, [r3]
2120: e3530000 cmp r3, #0
void RTEMS_Malloc_Initialize(
void *heap_begin,
uintptr_t heap_size,
size_t sbrk_amount
)
{
2124: e92d4070 push {r4, r5, r6, lr}
2128: e1a04000 mov r4, r0
212c: e1a05001 mov r5, r1
2130: e1a06002 mov r6, r2
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
(*rtems_malloc_statistics_helpers->initialize)();
2134: 11a0e00f movne lr, pc
2138: 1593f000 ldrne pc, [r3]
}
/*
* Initialize the garbage collection list to start with nothing on it.
*/
malloc_deferred_frees_initialize();
213c: ebffffe1 bl 20c8 <malloc_deferred_frees_initialize>
/*
* Initialize the optional sbrk support for extending the heap
*/
if ( rtems_malloc_sbrk_helpers != NULL ) {
2140: e59f30a4 ldr r3, [pc, #164] ; 21ec <RTEMS_Malloc_Initialize+0xd4>
2144: e5933000 ldr r3, [r3]
2148: e3530000 cmp r3, #0
214c: 0a000006 beq 216c <RTEMS_Malloc_Initialize+0x54>
void *new_heap_begin = (*rtems_malloc_sbrk_helpers->initialize)(
2150: e1a00004 mov r0, r4 <== NOT EXECUTED
2154: e1a01006 mov r1, r6 <== NOT EXECUTED
2158: e1a0e00f mov lr, pc <== NOT EXECUTED
215c: e593f000 ldr pc, [r3] <== NOT EXECUTED
heap_begin,
sbrk_amount
);
heap_size -= (uintptr_t) new_heap_begin - (uintptr_t) heap_begin;
2160: e0845005 add r5, r4, r5 <== NOT EXECUTED
2164: e0605005 rsb r5, r0, r5 <== NOT EXECUTED
2168: e1a04000 mov r4, 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 (
216c: e59f307c ldr r3, [pc, #124] ; 21f0 <RTEMS_Malloc_Initialize+0xd8>
2170: e5d31000 ldrb r1, [r3]
2174: e3510000 cmp r1, #0
2178: 1a000005 bne 2194 <RTEMS_Malloc_Initialize+0x7c>
!rtems_unified_work_area
&& rtems_configuration_get_do_zero_of_workspace()
217c: e59f3070 ldr r3, [pc, #112] ; 21f4 <RTEMS_Malloc_Initialize+0xdc>
2180: e5d33028 ldrb r3, [r3, #40] ; 0x28
2184: e3530000 cmp r3, #0
) {
memset( heap_begin, 0, heap_size );
2188: 11a00004 movne r0, r4
218c: 11a02005 movne r2, r5
2190: 1b002ed5 blne dcec <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 ) {
2194: e59f3054 ldr r3, [pc, #84] ; 21f0 <RTEMS_Malloc_Initialize+0xd8>
2198: e5d33000 ldrb r3, [r3]
219c: e3530000 cmp r3, #0
21a0: 1a000008 bne 21c8 <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 );
21a4: e59f304c ldr r3, [pc, #76] ; 21f8 <RTEMS_Malloc_Initialize+0xe0>
21a8: e1a01004 mov r1, r4
21ac: e5930000 ldr r0, [r3]
21b0: e1a02005 mov r2, r5
21b4: e3a03004 mov r3, #4
21b8: eb000f71 bl 5f84 <_Heap_Initialize>
RTEMS_Malloc_Heap,
heap_begin,
heap_size,
CPU_HEAP_ALIGNMENT
);
if ( status == 0 ) {
21bc: e3500000 cmp r0, #0
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
21c0: 0280001a addeq r0, r0, #26
21c4: 0b000d77 bleq 57a8 <rtems_fatal_error_occurred>
}
}
MSBUMP( space_available, _Protected_heap_Get_size(RTEMS_Malloc_Heap) );
21c8: e59f3028 ldr r3, [pc, #40] ; 21f8 <RTEMS_Malloc_Initialize+0xe0>
21cc: e59f4028 ldr r4, [pc, #40] ; 21fc <RTEMS_Malloc_Initialize+0xe4>
21d0: e5930000 ldr r0, [r3]
21d4: e5945000 ldr r5, [r4]
21d8: eb001240 bl 6ae0 <_Protected_heap_Get_size>
21dc: e0800005 add r0, r0, r5
21e0: e5840000 str r0, [r4]
printk( "\n" );
rtems_print_buffer( (heap_begin + heap_size) - 48, 48 );
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
}
#endif
}
21e4: e8bd8070 pop {r4, r5, r6, pc}
00005bfc <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
5bfc: e92d47ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, lr}<== NOT EXECUTED
void *high_water_mark;
void *current;
Stack_Control *stack;
char name[5];
if ( !the_thread )
5c00: e250a000 subs sl, r0, #0 <== NOT EXECUTED
5c04: 0a000043 beq 5d18 <Stack_check_Dump_threads_usage+0x11c> <== NOT EXECUTED
return;
if ( !print_handler )
5c08: e59f310c ldr r3, [pc, #268] ; 5d1c <Stack_check_Dump_threads_usage+0x120><== NOT EXECUTED
5c0c: e5937004 ldr r7, [r3, #4] <== NOT EXECUTED
5c10: e3570000 cmp r7, #0 <== NOT EXECUTED
5c14: 0a00003f beq 5d18 <Stack_check_Dump_threads_usage+0x11c> <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
if (the_thread == (Thread_Control *) -1) {
5c18: e37a0001 cmn sl, #1 <== NOT EXECUTED
}
else
return;
} else {
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
5c1c: 159a60f0 ldrne r6, [sl, #240] ; 0xf0 <== NOT EXECUTED
current = 0;
}
else
return;
} else {
stack = &the_thread->Start.Initial_stack;
5c20: 128a40c0 addne r4, sl, #192 ; 0xc0 <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
if (the_thread == (Thread_Control *) -1) {
5c24: 1a000005 bne 5c40 <Stack_check_Dump_threads_usage+0x44> <== NOT EXECUTED
if (Stack_check_Interrupt_stack.area) {
5c28: e59f40f0 ldr r4, [pc, #240] ; 5d20 <Stack_check_Dump_threads_usage+0x124><== NOT EXECUTED
5c2c: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
5c30: e3530000 cmp r3, #0 <== NOT EXECUTED
5c34: 13a06000 movne r6, #0 <== NOT EXECUTED
5c38: 11a0a006 movne sl, r6 <== NOT EXECUTED
5c3c: 0a000035 beq 5d18 <Stack_check_Dump_threads_usage+0x11c> <== NOT EXECUTED
} else {
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
5c40: e8940220 ldm r4, {r5, r9} <== NOT EXECUTED
5c44: e2899010 add r9, r9, #16 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
5c48: e2455010 sub r5, r5, #16 <== NOT EXECUTED
high_water_mark = Stack_check_find_high_water_mark(low, size);
5c4c: e1a00009 mov r0, r9 <== NOT EXECUTED
5c50: e1a01005 mov r1, r5 <== NOT EXECUTED
5c54: ebffffda bl 5bc4 <Stack_check_find_high_water_mark> <== NOT EXECUTED
if ( high_water_mark )
5c58: e2508000 subs r8, r0, #0 <== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
5c5c: 10899005 addne r9, r9, r5 <== NOT EXECUTED
5c60: 10688009 rsbne r8, r8, r9 <== NOT EXECUTED
else
used = 0;
if ( the_thread ) {
5c64: e35a0000 cmp sl, #0 <== NOT EXECUTED
5c68: e59f30ac ldr r3, [pc, #172] ; 5d1c <Stack_check_Dump_threads_usage+0x120><== NOT EXECUTED
5c6c: 0a00000c beq 5ca4 <Stack_check_Dump_threads_usage+0xa8> <== NOT EXECUTED
(*print_handler)(
5c70: e59aa008 ldr sl, [sl, #8] <== NOT EXECUTED
5c74: e28d2008 add r2, sp, #8 <== NOT EXECUTED
5c78: e1a0000a mov r0, sl <== NOT EXECUTED
5c7c: e3a01005 mov r1, #5 <== NOT EXECUTED
5c80: e5939008 ldr r9, [r3, #8] <== NOT EXECUTED
5c84: eb001663 bl b618 <rtems_object_get_name> <== NOT EXECUTED
5c88: e1a0200a mov r2, sl <== NOT EXECUTED
5c8c: e1a03000 mov r3, r0 <== NOT EXECUTED
5c90: e59f108c ldr r1, [pc, #140] ; 5d24 <Stack_check_Dump_threads_usage+0x128><== NOT EXECUTED
5c94: e1a00009 mov r0, r9 <== NOT EXECUTED
5c98: e1a0e00f mov lr, pc <== NOT EXECUTED
5c9c: e12fff17 bx r7 <== NOT EXECUTED
5ca0: ea000004 b 5cb8 <Stack_check_Dump_threads_usage+0xbc> <== 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 );
5ca4: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
5ca8: e59f1078 ldr r1, [pc, #120] ; 5d28 <Stack_check_Dump_threads_usage+0x12c><== NOT EXECUTED
5cac: e3e02000 mvn r2, #0 <== NOT EXECUTED
5cb0: e1a0e00f mov lr, pc <== NOT EXECUTED
5cb4: e12fff17 bx r7 <== NOT EXECUTED
}
(*print_handler)(
5cb8: e5943000 ldr r3, [r4] <== NOT EXECUTED
5cbc: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED
5cc0: e59f4054 ldr r4, [pc, #84] ; 5d1c <Stack_check_Dump_threads_usage+0x120><== NOT EXECUTED
5cc4: e58d6000 str r6, [sp] <== NOT EXECUTED
5cc8: e58d5004 str r5, [sp, #4] <== NOT EXECUTED
5ccc: e2433001 sub r3, r3, #1 <== NOT EXECUTED
5cd0: e0823003 add r3, r2, r3 <== NOT EXECUTED
5cd4: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
5cd8: e59f104c ldr r1, [pc, #76] ; 5d2c <Stack_check_Dump_threads_usage+0x130><== NOT EXECUTED
5cdc: e1a0e00f mov lr, pc <== NOT EXECUTED
5ce0: e594f004 ldr pc, [r4, #4] <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
5ce4: e5943000 ldr r3, [r4] <== NOT EXECUTED
5ce8: e3530000 cmp r3, #0 <== NOT EXECUTED
5cec: 1a000004 bne 5d04 <Stack_check_Dump_threads_usage+0x108> <== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
5cf0: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
5cf4: e59f1034 ldr r1, [pc, #52] ; 5d30 <Stack_check_Dump_threads_usage+0x134><== NOT EXECUTED
5cf8: e1a0e00f mov lr, pc <== NOT EXECUTED
5cfc: e594f004 ldr pc, [r4, #4] <== NOT EXECUTED
5d00: ea000004 b 5d18 <Stack_check_Dump_threads_usage+0x11c> <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
5d04: e1a02008 mov r2, r8 <== NOT EXECUTED
5d08: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
5d0c: e59f1020 ldr r1, [pc, #32] ; 5d34 <Stack_check_Dump_threads_usage+0x138><== NOT EXECUTED
5d10: e1a0e00f mov lr, pc <== NOT EXECUTED
5d14: e594f004 ldr pc, [r4, #4] <== NOT EXECUTED
}
}
5d18: e8bd87ff pop {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, pc}<== NOT EXECUTED
00005bc4 <Stack_check_find_high_water_mark>:
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
5bc4: e2800010 add r0, r0, #16 <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
5bc8: e3c11003 bic r1, r1, #3 <== NOT EXECUTED
5bcc: e0801001 add r1, r0, r1 <== NOT EXECUTED
if (*base != U32_PATTERN)
5bd0: e59f3020 ldr r3, [pc, #32] ; 5bf8 <Stack_check_find_high_water_mark+0x34><== 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++)
5bd4: ea000003 b 5be8 <Stack_check_find_high_water_mark+0x24> <== NOT EXECUTED
if (*base != U32_PATTERN)
5bd8: e5902000 ldr r2, [r0] <== NOT EXECUTED
5bdc: e1520003 cmp r2, r3 <== NOT EXECUTED
5be0: 112fff1e bxne lr <== 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++)
5be4: e2800004 add r0, r0, #4 <== NOT EXECUTED
5be8: e1500001 cmp r0, r1 <== NOT EXECUTED
5bec: 3afffff9 bcc 5bd8 <Stack_check_find_high_water_mark+0x14> <== NOT EXECUTED
5bf0: e3a00000 mov r0, #0 <== NOT EXECUTED
if (*base != U32_PATTERN)
return (void *) base;
#endif
return (void *)0;
}
5bf4: e12fff1e bx lr <== NOT EXECUTED
0003c678 <T.57>:
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
3c678: 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;
3c67c: e3a06000 mov r6, #0 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
3c680: e24dd01c sub sp, sp, #28 <== NOT EXECUTED
3c684: e58d1008 str r1, [sp, #8] <== NOT EXECUTED
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
3c688: e5c26000 strb r6, [r2] <== NOT EXECUTED
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
3c68c: e28d1018 add r1, sp, #24 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
3c690: e58d200c str r2, [sp, #12] <== NOT EXECUTED
3c694: e1a04003 mov r4, r3 <== NOT EXECUTED
3c698: e1a05000 mov r5, r0 <== NOT EXECUTED
*found = false;
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
3c69c: ebffff07 bl 3c2c0 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
3c6a0: e3500000 cmp r0, #0 <== NOT EXECUTED
3c6a4: ca000075 bgt 3c880 <T.57+0x208> <== NOT EXECUTED
return rc;
/*
* Calculate the bit we are testing plus the end point we search over.
*/
test_bit = *bit;
3c6a8: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED
3c6ac: e5903000 ldr r3, [r0] <== NOT EXECUTED
end_bit = test_bit + (window * direction);
if (end_bit < 0)
3c6b0: e093c584 adds ip, r3, r4, lsl #11 <== NOT EXECUTED
3c6b4: 41a0c006 movmi ip, r6 <== NOT EXECUTED
3c6b8: 4a000002 bmi 3c6c8 <T.57+0x50> <== NOT EXECUTED
end_bit = 0;
else if (end_bit >= control->size)
3c6bc: e595200c ldr r2, [r5, #12] <== NOT EXECUTED
3c6c0: e15c0002 cmp ip, r2 <== NOT EXECUTED
end_bit = control->size - 1;
3c6c4: 2242c001 subcs ip, r2, #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];
3c6c8: e5952014 ldr r2, [r5, #20] <== NOT EXECUTED
map_bits = &map[map_index];
3c6cc: e59d7018 ldr r7, [sp, #24] <== NOT EXECUTED
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
3c6d0: e1a09104 lsl r9, r4, #2 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
3c6d4: e1a0b284 lsl fp, r4, #5 <== NOT EXECUTED
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
3c6d8: e1a00fa4 lsr r0, 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);
3c6dc: e1a062c3 asr r6, r3, #5 <== NOT EXECUTED
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];
3c6e0: e1a08543 asr r8, r3, #10 <== NOT EXECUTED
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
3c6e4: e58d9004 str r9, [sp, #4] <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
3c6e8: e58db014 str fp, [sp, #20] <== NOT EXECUTED
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
3c6ec: e58d0010 str r0, [sp, #16] <== 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];
3c6f0: e0828108 add r8, r2, r8, lsl #2 <== NOT EXECUTED
map_bits = &map[map_index];
3c6f4: e0877106 add r7, r7, r6, 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);
3c6f8: e203101f and r1, r3, #31 <== NOT EXECUTED
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
3c6fc: e206201f and r2, r6, #31 <== NOT EXECUTED
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
3c700: e1a0a005 mov sl, r5 <== 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))
3c704: e5980000 ldr r0, [r8] <== NOT EXECUTED
3c708: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
3c70c: 10865004 addne r5, r6, r4 <== NOT EXECUTED
3c710: 11a05285 lslne r5, r5, #5 <== 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))
3c714: 1a000038 bne 3c7fc <T.57+0x184> <== NOT EXECUTED
3c718: ea00003a b 3c808 <T.57+0x190> <== 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);
3c71c: e3a09001 mov r9, #1 <== NOT EXECUTED
3c720: e1a09219 lsl r9, r9, r2 <== 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))
3c724: e1190000 tst r9, r0 <== 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);
3c728: e58d9000 str r9, [sp] <== 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))
3c72c: 1a00001d bne 3c7a8 <T.57+0x130> <== NOT EXECUTED
3c730: ea00001e b 3c7b0 <T.57+0x138> <== 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);
3c734: e3a0b001 mov fp, #1 <== NOT EXECUTED
3c738: e1a0911b lsl r9, fp, r1 <== 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))
3c73c: e597b000 ldr fp, [r7] <== NOT EXECUTED
3c740: e119000b tst r9, fp <== NOT EXECUTED
3c744: 0a000013 beq 3c798 <T.57+0x120> <== 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);
3c748: e1cb9009 bic r9, fp, r9 <== 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);
3c74c: e5879000 str r9, [r7] <== NOT EXECUTED
if (rtems_rfs_bitmap_match(*map_bits,
3c750: e3590000 cmp r9, #0 <== NOT EXECUTED
RTEMS_RFS_BITMAP_ELEMENT_SET))
*search_bits = rtems_rfs_bitmap_set (*search_bits,
3c754: 05982000 ldreq r2, [r8] <== NOT EXECUTED
3c758: 059d0000 ldreq r0, [sp] <== NOT EXECUTED
3c75c: 01c22000 biceq r2, r2, r0 <== NOT EXECUTED
3c760: 05882000 streq r2, [r8] <== NOT EXECUTED
1 << search_offset);
control->free--;
3c764: e59a0010 ldr r0, [sl, #16] <== NOT EXECUTED
*bit = test_bit;
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
3c768: e59a1000 ldr r1, [sl] <== 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;
3c76c: e28d9008 add r9, sp, #8 <== NOT EXECUTED
3c770: e8990a00 ldm r9, {r9, fp} <== NOT EXECUTED
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
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--;
3c774: e2400001 sub r0, r0, #1 <== NOT EXECUTED
*bit = test_bit;
*found = true;
3c778: e3a02001 mov r2, #1 <== NOT EXECUTED
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
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--;
3c77c: e58a0010 str r0, [sl, #16] <== NOT EXECUTED
*bit = test_bit;
*found = true;
3c780: e5cb2000 strb r2, [fp] <== NOT EXECUTED
3c784: e1a0500a mov r5, sl <== 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;
3c788: e5893000 str r3, [r9] <== NOT EXECUTED
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
3c78c: e5c12000 strb r2, [r1] <== NOT EXECUTED
3c790: e3a00000 mov r0, #0 <== NOT EXECUTED
3c794: ea000039 b 3c880 <T.57+0x208> <== NOT EXECUTED
return 0;
}
if (test_bit == end_bit)
3c798: e153000c cmp r3, ip <== NOT EXECUTED
3c79c: 0a000003 beq 3c7b0 <T.57+0x138> <== NOT EXECUTED
3c7a0: e0811004 add r1, r1, r4 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
3c7a4: e0833004 add r3, r3, r4 <== 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)
3c7a8: e351001f cmp r1, #31 <== NOT EXECUTED
3c7ac: 9affffe0 bls 3c734 <T.57+0xbc> <== NOT EXECUTED
}
}
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
3c7b0: e3540000 cmp r4, #0 <== NOT EXECUTED
3c7b4: d3a0101f movle r1, #31 <== NOT EXECUTED
3c7b8: c3a01000 movgt r1, #0 <== NOT EXECUTED
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
3c7bc: e59d9010 ldr r9, [sp, #16] <== NOT EXECUTED
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
3c7c0: e0813005 add r3, r1, r5 <== NOT EXECUTED
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
3c7c4: e153000c cmp r3, ip <== NOT EXECUTED
3c7c8: c3a09000 movgt r9, #0 <== NOT EXECUTED
3c7cc: d2099001 andle r9, r9, #1 <== NOT EXECUTED
3c7d0: e3590000 cmp r9, #0 <== NOT EXECUTED
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
3c7d4: e59d9004 ldr r9, [sp, #4] <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
3c7d8: e0866004 add r6, r6, r4 <== NOT EXECUTED
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
3c7dc: e0877009 add r7, r7, r9 <== NOT EXECUTED
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
3c7e0: 1a000014 bne 3c838 <T.57+0x1c0> <== NOT EXECUTED
3c7e4: e59db014 ldr fp, [sp, #20] <== NOT EXECUTED
3c7e8: e153000c cmp r3, ip <== NOT EXECUTED
3c7ec: a3540000 cmpge r4, #0 <== NOT EXECUTED
3c7f0: e085500b add r5, r5, fp <== NOT EXECUTED
3c7f4: ca00000f bgt 3c838 <T.57+0x1c0> <== NOT EXECUTED
3c7f8: e0822004 add r2, r2, r4 <== 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)
3c7fc: e352001f cmp r2, #31 <== NOT EXECUTED
3c800: 9affffc5 bls 3c71c <T.57+0xa4> <== NOT EXECUTED
3c804: ea00000b b 3c838 <T.57+0x1c0> <== 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)
3c808: 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;
3c80c: d1e01282 mvnle r1, r2, 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;
3c810: c2622020 rsbgt r2, r2, #32 <== NOT EXECUTED
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
map_offset = 0;
}
else
{
bits_skipped = search_offset + 1;
3c814: d2822001 addle r2, r2, #1 <== 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 ();
3c818: c1a01000 movgt r1, r0 <== 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;
3c81c: e0000294 mul r0, r4, r2 <== 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);
3c820: e3c3301f bic r3, r3, #31 <== 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;
3c824: d0813003 addle r3, r1, r3 <== 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 ();
3c828: c0833282 addgt r3, r3, r2, 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;
3c82c: d3a0101f movle r1, #31 <== NOT EXECUTED
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
3c830: e0866000 add r6, r6, r0 <== 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;
3c834: e0877100 add r7, r7, r0, lsl #2 <== NOT EXECUTED
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
3c838: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED
3c83c: e153000c cmp r3, ip <== NOT EXECUTED
3c840: b3a00000 movlt r0, #0 <== NOT EXECUTED
3c844: a2000001 andge r0, r0, #1 <== NOT EXECUTED
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
3c848: e3540000 cmp r4, #0 <== NOT EXECUTED
3c84c: d3a0201f movle r2, #31 <== NOT EXECUTED
3c850: c3a02000 movgt r2, #0 <== NOT EXECUTED
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
3c854: e3500000 cmp r0, #0 <== NOT EXECUTED
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
3c858: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
3c85c: e0888000 add r8, r8, r0 <== NOT EXECUTED
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
3c860: 1affffa7 bne 3c704 <T.57+0x8c> <== NOT EXECUTED
3c864: e153000c cmp r3, ip <== NOT EXECUTED
3c868: c3a00000 movgt r0, #0 <== NOT EXECUTED
3c86c: d3a00001 movle r0, #1 <== NOT EXECUTED
3c870: e3540000 cmp r4, #0 <== NOT EXECUTED
3c874: d3a00000 movle r0, #0 <== NOT EXECUTED
3c878: e3500000 cmp r0, #0 <== NOT EXECUTED
3c87c: 1affffa0 bne 3c704 <T.57+0x8c> <== NOT EXECUTED
return 0;
}
3c880: e28dd01c add sp, sp, #28 <== NOT EXECUTED
3c884: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00000448 <_Barrier_Manager_initialization>:
#include <rtems/score/object.h>
#include <rtems/rtems/barrier.h>
void _Barrier_Manager_initialization(void)
{
}
448: e12fff1e bx lr
0000ad80 <_CORE_mutex_Seize_interrupt_trylock>:
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
ad80: e59f3110 ldr r3, [pc, #272] ; ae98 <_CORE_mutex_Seize_interrupt_trylock+0x118>
ad84: e5933000 ldr r3, [r3]
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
ad88: e3a02000 mov r2, #0
ad8c: e5832034 str r2, [r3, #52] ; 0x34
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
ad90: e590c050 ldr ip, [r0, #80] ; 0x50
ad94: 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
)
{
ad98: e52de004 push {lr} ; (str lr, [sp, #-4]!)
ad9c: 0a00002a beq ae4c <_CORE_mutex_Seize_interrupt_trylock+0xcc>
the_mutex->lock = CORE_MUTEX_LOCKED;
ada0: 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;
ada4: e5902048 ldr r2, [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;
ada8: e593c008 ldr ip, [r3, #8]
the_mutex->nest_count = 1;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
adac: e3520002 cmp r2, #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;
adb0: e580c060 str ip, [r0, #96] ; 0x60
the_mutex->nest_count = 1;
adb4: e3a0c001 mov ip, #1
adb8: e580c054 str ip, [r0, #84] ; 0x54
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;
adbc: e580305c str r3, [r0, #92] ; 0x5c
the_mutex->holder_id = executing->Object.id;
the_mutex->nest_count = 1;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
adc0: 0a000001 beq adcc <_CORE_mutex_Seize_interrupt_trylock+0x4c>
adc4: e3520003 cmp r2, #3
adc8: 1a00002c bne ae80 <_CORE_mutex_Seize_interrupt_trylock+0x100>
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
adcc: e593c01c ldr ip, [r3, #28]
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
add0: e3520003 cmp r2, #3
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
add4: e28c2001 add r2, ip, #1
add8: e583201c str r2, [r3, #28]
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
addc: 1a000027 bne ae80 <_CORE_mutex_Seize_interrupt_trylock+0x100>
*/
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
ade0: e590204c ldr r2, [r0, #76] ; 0x4c
current = executing->current_priority;
ade4: e593c014 ldr ip, [r3, #20]
if ( current == ceiling ) {
ade8: e15c0002 cmp ip, r2
adec: 0a000023 beq ae80 <_CORE_mutex_Seize_interrupt_trylock+0x100>
_ISR_Enable( *level_p );
return 0;
}
if ( current > ceiling ) {
adf0: 9a00000b bls ae24 <_CORE_mutex_Seize_interrupt_trylock+0xa4>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
adf4: e59f30a0 ldr r3, [pc, #160] ; ae9c <_CORE_mutex_Seize_interrupt_trylock+0x11c>
adf8: e5932000 ldr r2, [r3]
adfc: e2822001 add r2, r2, #1
ae00: e5832000 str r2, [r3]
ae04: e5913000 ldr r3, [r1]
ae08: e129f003 msr CPSR_fc, r3
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
_Thread_Change_priority(
ae0c: e3a02000 mov r2, #0
ae10: e590104c ldr r1, [r0, #76] ; 0x4c
ae14: e590005c ldr r0, [r0, #92] ; 0x5c
ae18: ebffef45 bl 6b34 <_Thread_Change_priority>
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
ae1c: ebfff0a5 bl 70b8 <_Thread_Enable_dispatch>
ae20: ea000018 b ae88 <_CORE_mutex_Seize_interrupt_trylock+0x108>
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
ae24: e3a02006 mov r2, #6
ae28: e5832034 str r2, [r3, #52] ; 0x34
the_mutex->lock = CORE_MUTEX_UNLOCKED;
the_mutex->nest_count = 0; /* undo locking above */
ae2c: e3a02000 mov r2, #0
ae30: 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;
ae34: e2822001 add r2, r2, #1
ae38: e5802050 str r2, [r0, #80] ; 0x50
the_mutex->nest_count = 0; /* undo locking above */
executing->resource_count--; /* undo locking above */
ae3c: e593201c ldr r2, [r3, #28]
ae40: e2422001 sub r2, r2, #1
ae44: e583201c str r2, [r3, #28]
ae48: ea00000c b ae80 <_CORE_mutex_Seize_interrupt_trylock+0x100>
/*
* 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 ) ) {
ae4c: e590205c ldr r2, [r0, #92] ; 0x5c
ae50: e1520003 cmp r2, r3
ae54: 1a00000d bne ae90 <_CORE_mutex_Seize_interrupt_trylock+0x110>
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
ae58: e5903040 ldr r3, [r0, #64] ; 0x40
ae5c: e3530000 cmp r3, #0
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
ae60: 05903054 ldreq r3, [r0, #84] ; 0x54
ae64: 02833001 addeq r3, r3, #1
ae68: 05803054 streq r3, [r0, #84] ; 0x54
* 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 ) {
ae6c: 0a000003 beq ae80 <_CORE_mutex_Seize_interrupt_trylock+0x100>
ae70: e3530001 cmp r3, #1
ae74: 1a000005 bne ae90 <_CORE_mutex_Seize_interrupt_trylock+0x110>
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;
ae78: e3a03002 mov r3, #2 <== NOT EXECUTED
ae7c: e5823034 str r3, [r2, #52] ; 0x34 <== NOT EXECUTED
ae80: e5913000 ldr r3, [r1]
ae84: e129f003 msr CPSR_fc, r3
ae88: e3a00000 mov r0, #0
ae8c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
ae90: e3a00001 mov r0, #1
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}
ae94: e49df004 pop {pc} ; (ldr pc, [sp], #4)
0000044c <_Dual_ported_memory_Manager_initialization>:
#include <rtems/rtems/types.h>
#include <rtems/rtems/dpmem.h>
void _Dual_ported_memory_Manager_initialization(void)
{
}
44c: e12fff1e bx lr
00000450 <_Event_Manager_initialization>:
#include <rtems/score/thread.h>
#include <rtems/score/interr.h>
void _Event_Manager_initialization(void)
{
}
450: e12fff1e bx lr
0000046c <_Extension_Manager_initialization>:
#include <rtems/extension.h>
#include <rtems/score/interr.h>
void _Extension_Manager_initialization(void)
{
}
46c: e12fff1e bx lr
00000454 <_Message_queue_Manager_initialization>:
#include <rtems/score/wkspace.h>
#include <rtems/score/interr.h>
void _Message_queue_Manager_initialization(void)
{
}
454: e12fff1e bx lr
00000458 <_Partition_Manager_initialization>:
#include <rtems/score/thread.h>
#include <rtems/score/interr.h>
void _Partition_Manager_initialization(void)
{
}
458: e12fff1e bx lr
00000468 <_Rate_monotonic_Manager_initialization>:
#include <rtems/rtems/types.h>
#include <rtems/rtems/ratemon.h>
void _Rate_monotonic_Manager_initialization(void)
{
}
468: e12fff1e bx lr
0000045c <_Region_Manager_initialization>:
#include <rtems/score/thread.h>
#include <rtems/score/interr.h>
void _Region_Manager_initialization(void)
{
}
45c: e12fff1e bx lr
00007614 <_Thread_queue_Enqueue_priority>:
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
7614: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
7618: e5913014 ldr r3, [r1, #20]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
761c: e281503c add r5, r1, #60 ; 0x3c
7620: e5815038 str r5, [r1, #56] ; 0x38
the_chain->permanent_null = NULL;
7624: e3a05000 mov r5, #0
the_chain->last = _Chain_Head(the_chain);
7628: e281c038 add ip, r1, #56 ; 0x38
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
762c: e3130020 tst r3, #32
_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 ];
7630: e1a04323 lsr r4, r3, #6
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
7634: e581503c str r5, [r1, #60] ; 0x3c
7638: e285500c add r5, r5, #12
the_chain->last = _Chain_Head(the_chain);
763c: e581c040 str ip, [r1, #64] ; 0x40
block_state = the_thread_queue->state;
7640: e5907038 ldr r7, [r0, #56] ; 0x38
_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 ];
7644: e02c0495 mla ip, r5, r4, r0
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
7648: 159f8154 ldrne r8, [pc, #340] ; 77a4 <_Thread_queue_Enqueue_priority+0x190>
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
764c: 1a000023 bne 76e0 <_Thread_queue_Enqueue_priority+0xcc>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
7650: e28c8004 add r8, ip, #4
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
7654: e10f5000 mrs r5, CPSR
7658: e3854080 orr r4, r5, #128 ; 0x80
765c: 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;
7660: e3e06000 mvn r6, #0
7664: e59c4000 ldr r4, [ip]
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
7668: ea00000b b 769c <_Thread_queue_Enqueue_priority+0x88>
search_priority = search_thread->current_priority;
766c: e5946014 ldr r6, [r4, #20]
if ( priority <= search_priority )
7670: e1530006 cmp r3, r6
7674: 9a00000a bls 76a4 <_Thread_queue_Enqueue_priority+0x90>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
7678: e10fa000 mrs sl, CPSR
767c: e129f005 msr CPSR_fc, r5
7680: e129f00a msr CPSR_fc, sl
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) ) {
7684: e594a010 ldr sl, [r4, #16]
7688: e117000a tst r7, sl
768c: 1a000001 bne 7698 <_Thread_queue_Enqueue_priority+0x84>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
7690: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
7694: eaffffee b 7654 <_Thread_queue_Enqueue_priority+0x40> <== NOT EXECUTED
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
7698: 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 ) ) {
769c: e1540008 cmp r4, r8
76a0: 1afffff1 bne 766c <_Thread_queue_Enqueue_priority+0x58>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
76a4: e590c030 ldr ip, [r0, #48] ; 0x30
76a8: e35c0001 cmp ip, #1
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 ) ) {
76ac: e1a0c005 mov ip, r5
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
76b0: 1a000038 bne 7798 <_Thread_queue_Enqueue_priority+0x184>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
76b4: e1530006 cmp r3, r6
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
76b8: e3a03000 mov r3, #0
76bc: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
76c0: 0a00002a beq 7770 <_Thread_queue_Enqueue_priority+0x15c>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
76c4: e5943004 ldr r3, [r4, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
76c8: e5814000 str r4, [r1]
the_node->previous = previous_node;
76cc: e5813004 str r3, [r1, #4]
previous_node->next = the_node;
search_node->previous = the_node;
the_thread->Wait.queue = the_thread_queue;
76d0: 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;
76d4: e5831000 str r1, [r3]
search_node->previous = the_node;
76d8: e5841004 str r1, [r4, #4]
76dc: ea000021 b 7768 <_Thread_queue_Enqueue_priority+0x154>
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
76e0: e5d86000 ldrb r6, [r8]
76e4: e2866001 add r6, r6, #1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
76e8: e10f5000 mrs r5, CPSR
76ec: e3854080 orr r4, r5, #128 ; 0x80
76f0: e129f004 msr CPSR_fc, r4
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
76f4: e59c4008 ldr r4, [ip, #8]
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
76f8: ea00000b b 772c <_Thread_queue_Enqueue_priority+0x118>
search_priority = search_thread->current_priority;
76fc: e5946014 ldr r6, [r4, #20]
if ( priority >= search_priority )
7700: e1530006 cmp r3, r6
7704: 2a00000a bcs 7734 <_Thread_queue_Enqueue_priority+0x120>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
7708: e10fa000 mrs sl, CPSR
770c: e129f005 msr CPSR_fc, r5
7710: e129f00a msr CPSR_fc, sl
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) ) {
7714: e594a010 ldr sl, [r4, #16]
7718: e117000a tst r7, sl
771c: 1a000001 bne 7728 <_Thread_queue_Enqueue_priority+0x114>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
7720: e129f005 msr CPSR_fc, r5
7724: eaffffed b 76e0 <_Thread_queue_Enqueue_priority+0xcc>
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
7728: 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 ) ) {
772c: e154000c cmp r4, ip
7730: 1afffff1 bne 76fc <_Thread_queue_Enqueue_priority+0xe8>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
7734: e590c030 ldr ip, [r0, #48] ; 0x30
7738: 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 ) ) {
773c: e1a0c005 mov ip, r5
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
7740: 1a000014 bne 7798 <_Thread_queue_Enqueue_priority+0x184>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
7744: e1530006 cmp r3, r6
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
7748: e3a03000 mov r3, #0
774c: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
7750: 0a000006 beq 7770 <_Thread_queue_Enqueue_priority+0x15c>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
7754: e5943000 ldr r3, [r4]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
7758: e8810018 stm r1, {r3, r4}
search_node->next = the_node;
next_node->previous = the_node;
the_thread->Wait.queue = the_thread_queue;
775c: 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;
7760: e5841000 str r1, [r4]
next_node->previous = the_node;
7764: e5831004 str r1, [r3, #4]
7768: e129f005 msr CPSR_fc, r5
776c: ea000007 b 7790 <_Thread_queue_Enqueue_priority+0x17c>
7770: 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;
7774: e5943004 ldr r3, [r4, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
7778: e5814000 str r4, [r1]
the_node->previous = previous_node;
777c: e5813004 str r3, [r1, #4]
previous_node->next = the_node;
search_node->previous = the_node;
the_thread->Wait.queue = the_thread_queue;
7780: 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;
7784: e5831000 str r1, [r3]
search_node->previous = the_node;
7788: e5841004 str r1, [r4, #4]
778c: e129f00c msr CPSR_fc, ip
7790: e3a00001 mov r0, #1
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
7794: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
* 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;
7798: e582c000 str ip, [r2]
return the_thread_queue->sync_state;
779c: e5900030 ldr r0, [r0, #48] ; 0x30
}
77a0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
00000464 <_Timer_Manager_initialization>:
#include <rtems/rtems/types.h>
#include <rtems/rtems/timer.h>
void _Timer_Manager_initialization(void)
{
}
464: e12fff1e bx lr
00015138 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
15138: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1513c: e24dd020 sub sp, sp, #32
15140: e28d3014 add r3, sp, #20
15144: e28d5008 add r5, sp, #8
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
15148: e3a09000 mov r9, #0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
1514c: e283a004 add sl, r3, #4
15150: e2858004 add r8, r5, #4
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
15154: e58d301c str r3, [sp, #28]
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
15158: e2802008 add r2, r0, #8
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
1515c: e2803040 add r3, r0, #64 ; 0x40
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
15160: e58da014 str sl, [sp, #20]
the_chain->permanent_null = NULL;
15164: e58d9018 str r9, [sp, #24]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
15168: e58d8008 str r8, [sp, #8]
the_chain->permanent_null = NULL;
1516c: e58d900c str r9, [sp, #12]
the_chain->last = _Chain_Head(the_chain);
15170: e58d5010 str r5, [sp, #16]
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
15174: e58d2004 str r2, [sp, #4]
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
15178: e58d3000 str r3, [sp]
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
1517c: e1a04000 mov r4, r0
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
15180: e280b030 add fp, r0, #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 );
15184: e2807068 add r7, r0, #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;
15188: e28d2014 add r2, sp, #20
1518c: e5842078 str r2, [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;
15190: e59f2168 ldr r2, [pc, #360] ; 15300 <_Timer_server_Body+0x1c8>
15194: e5923000 ldr r3, [r2]
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
15198: e594103c ldr r1, [r4, #60] ; 0x3c
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1519c: e1a02005 mov r2, r5
151a0: e0611003 rsb r1, r1, r3
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
151a4: e584303c str r3, [r4, #60] ; 0x3c
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
151a8: e1a0000b mov r0, fp
151ac: eb000ff2 bl 1917c <_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();
151b0: e59f314c ldr r3, [pc, #332] ; 15304 <_Timer_server_Body+0x1cc>
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
151b4: e5942074 ldr r2, [r4, #116] ; 0x74
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
151b8: e5936000 ldr r6, [r3]
/*
* 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 ) {
151bc: e1560002 cmp r6, r2
151c0: 9a000004 bls 151d8 <_Timer_server_Body+0xa0>
/*
* 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 );
151c4: e0621006 rsb r1, r2, r6
151c8: e1a00007 mov r0, r7
151cc: e1a02005 mov r2, r5
151d0: eb000fe9 bl 1917c <_Watchdog_Adjust_to_chain>
151d4: ea000003 b 151e8 <_Timer_server_Body+0xb0>
/*
* 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 );
151d8: 30662002 rsbcc r2, r6, r2
151dc: 31a00007 movcc r0, r7
151e0: 33a01001 movcc r1, #1
151e4: 3b000fbc blcc 190dc <_Watchdog_Adjust>
}
watchdogs->last_snapshot = snapshot;
151e8: e5846074 str r6, [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 );
151ec: e5940078 ldr r0, [r4, #120] ; 0x78
151f0: eb000221 bl 15a7c <_Chain_Get>
if ( timer == NULL ) {
151f4: e2501000 subs r1, r0, #0
151f8: 0a00000a beq 15228 <_Timer_server_Body+0xf0>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
151fc: e5913038 ldr r3, [r1, #56] ; 0x38
15200: e3530001 cmp r3, #1
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
15204: 02811010 addeq r1, r1, #16
15208: 01a0000b moveq r0, fp
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
1520c: 0a000003 beq 15220 <_Timer_server_Body+0xe8>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
15210: e3530003 cmp r3, #3
15214: 1afffff4 bne 151ec <_Timer_server_Body+0xb4>
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
15218: e2811010 add r1, r1, #16
1521c: e1a00007 mov r0, r7
15220: eb001002 bl 19230 <_Watchdog_Insert>
15224: eafffff0 b 151ec <_Timer_server_Body+0xb4>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
15228: e10f3000 mrs r3, CPSR
1522c: e3832080 orr r2, r3, #128 ; 0x80
15230: e129f002 msr CPSR_fc, r2
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
15234: e59d2014 ldr r2, [sp, #20]
15238: e152000a cmp r2, sl
1523c: 1a000005 bne 15258 <_Timer_server_Body+0x120>
ts->insert_chain = NULL;
15240: e5841078 str r1, [r4, #120] ; 0x78
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
15244: e129f003 msr CPSR_fc, r3
_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 ) ) {
15248: e59d3008 ldr r3, [sp, #8]
1524c: e1530008 cmp r3, r8
15250: 1a000002 bne 15260 <_Timer_server_Body+0x128>
15254: ea000015 b 152b0 <_Timer_server_Body+0x178>
15258: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
1525c: eaffffcb b 15190 <_Timer_server_Body+0x58> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
15260: e10f2000 mrs r2, CPSR
15264: e3823080 orr r3, r2, #128 ; 0x80
15268: e129f003 msr CPSR_fc, r3
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
1526c: e59d3008 ldr r3, [sp, #8]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
15270: e1530008 cmp r3, r8
15274: 0a00000b beq 152a8 <_Timer_server_Body+0x170>
{
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
15278: e5931000 ldr r1, [r3]
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
1527c: e3530000 cmp r3, #0
the_chain->first = new_first;
15280: e58d1008 str r1, [sp, #8]
new_first->previous = _Chain_Head(the_chain);
15284: e5815004 str r5, [r1, #4]
15288: 0a000006 beq 152a8 <_Timer_server_Body+0x170>
watchdog->state = WATCHDOG_INACTIVE;
1528c: e5839008 str r9, [r3, #8]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
15290: e129f002 msr CPSR_fc, r2
/*
* 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 );
15294: e2830020 add r0, r3, #32
15298: e8900003 ldm r0, {r0, r1}
1529c: e1a0e00f mov lr, pc
152a0: e593f01c ldr pc, [r3, #28]
}
152a4: eaffffed b 15260 <_Timer_server_Body+0x128>
152a8: e129f002 msr CPSR_fc, r2
152ac: eaffffb5 b 15188 <_Timer_server_Body+0x50>
} else {
ts->active = false;
152b0: e5c4907c strb r9, [r4, #124] ; 0x7c
152b4: e59f304c ldr r3, [pc, #76] ; 15308 <_Timer_server_Body+0x1d0>
152b8: e5932000 ldr r2, [r3]
152bc: e2822001 add r2, r2, #1
152c0: e5832000 str r2, [r3]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
152c4: e3a01008 mov r1, #8
152c8: e5940000 ldr r0, [r4]
152cc: eb000d38 bl 187b4 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
152d0: e1a00004 mov r0, r4
152d4: ebffff6b bl 15088 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
152d8: e1a00004 mov r0, r4
152dc: ebffff7f bl 150e0 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
152e0: eb000aa4 bl 17d78 <_Thread_Enable_dispatch>
ts->active = true;
152e4: e3a03001 mov r3, #1
152e8: e5c4307c strb r3, [r4, #124] ; 0x7c
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
152ec: e59d0004 ldr r0, [sp, #4]
152f0: eb001026 bl 19390 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
152f4: e59d0000 ldr r0, [sp]
152f8: eb001024 bl 19390 <_Watchdog_Remove>
152fc: eaffffa1 b 15188 <_Timer_server_Body+0x50>
00020d4c <__kill>:
#endif
int __kill( pid_t pid, int sig )
{
return 0;
}
20d4c: e3a00000 mov r0, #0 <== NOT EXECUTED
20d50: e12fff1e bx lr <== NOT EXECUTED
00018f20 <_exit>:
/*
* If the toolset uses init/fini sections, then we need to
* run the global destructors now.
*/
#if defined(__USE_INIT_FINI__)
FINI_SYMBOL();
18f20: e1a04000 mov r4, r0
18f24: eb000229 bl 197d0 <___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();
18f28: ebffffe0 bl 18eb0 <libc_wrapup>
rtems_shutdown_executive(status);
18f2c: e1a00004 mov r0, r4
18f30: eb00003b bl 19024 <rtems_shutdown_executive>
18f34: eafffffe b 18f34 <_exit+0x14> <== NOT EXECUTED
00022ca8 <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
22ca8: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== 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;
22cac: e3a04000 mov r4, #0 <== NOT EXECUTED
22cb0: e28d7004 add r7, sp, #4 <== NOT EXECUTED
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
22cb4: e1a05003 mov r5, r3 <== NOT EXECUTED
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
22cb8: e5909034 ldr r9, [r0, #52] ; 0x34 <== NOT EXECUTED
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
22cbc: e5274004 str r4, [r7, #-4]! <== NOT EXECUTED
22cc0: e1a06002 mov r6, r2 <== NOT EXECUTED
22cc4: e1a08001 mov r8, r1 <== NOT EXECUTED
uint32_t c = 0;
while (count > 0)
22cc8: ea000012 b 22d18 <_fat_block_read+0x70> <== NOT EXECUTED
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
22ccc: ebfffec4 bl 227e4 <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);
22cd0: 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)
22cd4: e250b000 subs fp, r0, #0 <== NOT EXECUTED
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
22cd8: e0830004 add r0, r3, r4 <== 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)
22cdc: 13e04000 mvnne r4, #0 <== NOT EXECUTED
22ce0: 1a000012 bne 22d30 <_fat_block_read+0x88> <== NOT EXECUTED
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
22ce4: e1d9a0b0 ldrh sl, [r9] <== NOT EXECUTED
memcpy((buff + cmpltd), (block->buffer + ofs), c);
22ce8: 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));
22cec: e066a00a rsb sl, r6, sl <== NOT EXECUTED
memcpy((buff + cmpltd), (block->buffer + ofs), c);
22cf0: 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));
22cf4: e15a0005 cmp sl, r5 <== NOT EXECUTED
22cf8: 21a0a005 movcs sl, r5 <== NOT EXECUTED
memcpy((buff + cmpltd), (block->buffer + ofs), c);
22cfc: e0811006 add r1, r1, r6 <== NOT EXECUTED
22d00: e1a0200a mov r2, sl <== NOT EXECUTED
22d04: eb00752d bl 401c0 <memcpy> <== NOT EXECUTED
count -= c;
cmpltd += c;
22d08: e08a4004 add r4, sl, r4 <== NOT EXECUTED
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
count -= c;
22d0c: e06a5005 rsb r5, sl, r5 <== NOT EXECUTED
cmpltd += c;
blk++;
22d10: e2888001 add r8, r8, #1 <== NOT EXECUTED
22d14: e1a0600b mov r6, fp <== NOT EXECUTED
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
22d18: e3550000 cmp r5, #0 <== NOT EXECUTED
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
22d1c: e1a01008 mov r1, r8 <== NOT EXECUTED
22d20: e3a02001 mov r2, #1 <== NOT EXECUTED
22d24: e1a0300d mov r3, sp <== NOT EXECUTED
22d28: e1a00009 mov r0, r9 <== NOT EXECUTED
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
22d2c: 1affffe6 bne 22ccc <_fat_block_read+0x24> <== NOT EXECUTED
cmpltd += c;
blk++;
ofs = 0;
}
return cmpltd;
}
22d30: e1a00004 mov r0, r4 <== NOT EXECUTED
22d34: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
000227dc <_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);
227dc: e5900034 ldr r0, [r0, #52] ; 0x34 <== NOT EXECUTED
227e0: eaffffaf b 226a4 <fat_buf_release> <== NOT EXECUTED
000229bc <_fat_block_write>:
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
229bc: e92d4ff1 push {r0, 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;
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
229c0: e3a05000 mov r5, #0 <== NOT EXECUTED
229c4: e28d8004 add r8, sp, #4 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
229c8: e1a07003 mov r7, r3 <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
229cc: e5906034 ldr r6, [r0, #52] ; 0x34 <== NOT EXECUTED
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
229d0: e5285004 str r5, [r8, #-4]! <== NOT EXECUTED
229d4: e1a0b002 mov fp, r2 <== NOT EXECUTED
229d8: e1a0a001 mov sl, r1 <== NOT EXECUTED
uint32_t c = 0;
while(count > 0)
229dc: ea00001e b 22a5c <_fat_block_write+0xa0> <== NOT EXECUTED
{
c = MIN(count, (fs_info->vol.bps - ofs));
229e0: e1d630b0 ldrh r3, [r6] <== NOT EXECUTED
229e4: e06b4003 rsb r4, fp, r3 <== NOT EXECUTED
229e8: e1540007 cmp r4, r7 <== NOT EXECUTED
229ec: 21a04007 movcs r4, r7 <== NOT EXECUTED
if (c == fs_info->vol.bps)
229f0: e1540003 cmp r4, r3 <== NOT EXECUTED
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
229f4: 01a00006 moveq r0, r6 <== NOT EXECUTED
229f8: 01a0100a moveq r1, sl <== NOT EXECUTED
229fc: 03a02002 moveq r2, #2 <== NOT EXECUTED
22a00: 01a0300d moveq r3, sp <== NOT EXECUTED
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
22a04: 11a0100a movne r1, sl <== NOT EXECUTED
22a08: 13a02001 movne r2, #1 <== NOT EXECUTED
22a0c: 11a0300d movne r3, sp <== NOT EXECUTED
22a10: 11a00006 movne r0, r6 <== NOT EXECUTED
22a14: ebffff72 bl 227e4 <fat_buf_access> <== NOT EXECUTED
if (rc != RC_OK)
22a18: e3500000 cmp r0, #0 <== 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);
22a1c: e1a09000 mov r9, r0 <== NOT EXECUTED
if (rc != RC_OK)
22a20: 13e05000 mvnne r5, #0 <== NOT EXECUTED
22a24: 1a00000e bne 22a64 <_fat_block_write+0xa8> <== NOT EXECUTED
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
22a28: e59d3000 ldr r3, [sp] <== NOT EXECUTED
22a2c: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED
22a30: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED
22a34: e080000b add r0, r0, fp <== NOT EXECUTED
22a38: e0831005 add r1, r3, r5 <== NOT EXECUTED
22a3c: e1a02004 mov r2, r4 <== NOT EXECUTED
22a40: eb0075de bl 401c0 <memcpy> <== NOT EXECUTED
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
22a44: e3a03001 mov r3, #1 <== NOT EXECUTED
22a48: e5c63080 strb r3, [r6, #128] ; 0x80 <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
22a4c: e0845005 add r5, r4, r5 <== NOT EXECUTED
memcpy((block->buffer + ofs), (buff + cmpltd), c);
fat_buf_mark_modified(fs_info);
count -= c;
22a50: e0647007 rsb r7, r4, r7 <== NOT EXECUTED
cmpltd +=c;
blk++;
22a54: e28aa001 add sl, sl, #1 <== NOT EXECUTED
22a58: e1a0b009 mov fp, r9 <== NOT EXECUTED
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
22a5c: e3570000 cmp r7, #0 <== NOT EXECUTED
22a60: 1affffde bne 229e0 <_fat_block_write+0x24> <== NOT EXECUTED
cmpltd +=c;
blk++;
ofs = 0;
}
return cmpltd;
}
22a64: e1a00005 mov r0, r5 <== NOT EXECUTED
22a68: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00039da4 <_fcntl_r>:
int fd,
int cmd,
int arg
)
{
return fcntl( fd, cmd, arg );
39da4: e1a00001 mov r0, r1 <== NOT EXECUTED
39da8: e1a01002 mov r1, r2 <== NOT EXECUTED
39dac: e1a02003 mov r2, r3 <== NOT EXECUTED
39db0: eaffff8b b 39be4 <fcntl> <== NOT EXECUTED
00020d2c <_getpid_r>:
pid_t _getpid_r(
struct _reent *ptr __attribute__((unused))
)
{
return getpid();
}
20d2c: e3a00001 mov r0, #1 <== NOT EXECUTED
20d30: e12fff1e bx lr <== NOT EXECUTED
00001fcc <_gettimeofday>:
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
1fcc: eaffffe8 b 1f74 <gettimeofday> <== NOT EXECUTED
00020d44 <_kill_r>:
#include <reent.h>
int _kill_r( struct _reent *ptr, pid_t pid, int sig )
{
return 0;
}
20d44: e3a00000 mov r0, #0 <== NOT EXECUTED
20d48: e12fff1e bx lr <== NOT EXECUTED
00025f38 <_link_r>:
struct _reent *ptr __attribute__((unused)),
const char *existing,
const char *new
)
{
return link( existing, new );
25f38: e1a00001 mov r0, r1 <== NOT EXECUTED
25f3c: e1a01002 mov r1, r2 <== NOT EXECUTED
25f40: eaffff7f b 25d44 <link> <== NOT EXECUTED
00026134 <_lstat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
26134: e1a00001 mov r0, r1 <== NOT EXECUTED
26138: e1a01002 mov r1, r2 <== NOT EXECUTED
2613c: eaffffc4 b 26054 <lstat> <== NOT EXECUTED
00019008 <_realloc_r>:
struct _reent *ignored __attribute__((unused)),
void *ptr,
size_t size
)
{
return realloc( ptr, size );
19008: e1a00001 mov r0, r1 <== NOT EXECUTED
1900c: e1a01002 mov r1, r2 <== NOT EXECUTED
19010: ea00000e b 19050 <realloc> <== NOT EXECUTED
00008f14 <_stat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
8f14: e1a00001 mov r0, r1 <== NOT EXECUTED
8f18: e1a01002 mov r1, r2 <== NOT EXECUTED
8f1c: eaffffc4 b 8e34 <stat> <== NOT EXECUTED
0000ced0 <_unlink_r>:
int _unlink_r(
struct _reent *ptr __attribute__((unused)),
const char *path
)
{
return unlink( path );
ced0: e1a00001 mov r0, r1 <== NOT EXECUTED
ced4: eaffff71 b cca0 <unlink> <== NOT EXECUTED
00024dbc <chdir>:
#include <rtems/seterr.h>
int chdir(
const char *pathname
)
{
24dbc: e92d4030 push {r4, r5, lr}
rtems_filesystem_location_info_t loc;
int result;
if ( !pathname )
24dc0: e2505000 subs r5, r0, #0
#include <rtems/seterr.h>
int chdir(
const char *pathname
)
{
24dc4: e24dd018 sub sp, sp, #24
rtems_filesystem_location_info_t loc;
int result;
if ( !pathname )
24dc8: 1a000002 bne 24dd8 <chdir+0x1c>
rtems_set_errno_and_return_minus_one( EFAULT );
24dcc: eb00604b bl 3cf00 <__errno>
24dd0: e3a0300e mov r3, #14
24dd4: ea000025 b 24e70 <chdir+0xb4>
/*
* Get the node where we wish to go.
*/
result = rtems_filesystem_evaluate_path(
24dd8: eb007b45 bl 43af4 <strlen>
24ddc: e28d4004 add r4, sp, #4
24de0: e3a0c001 mov ip, #1
24de4: e1a01000 mov r1, r0
24de8: e1a0200c mov r2, ip
24dec: e1a00005 mov r0, r5
24df0: e1a03004 mov r3, r4
24df4: e58dc000 str ip, [sp]
24df8: ebff8a0f bl 763c <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), RTEMS_LIBIO_PERMS_SEARCH, &loc, true );
if ( result != 0 )
24dfc: e3500000 cmp r0, #0
24e00: 1a00001b bne 24e74 <chdir+0xb8>
return -1;
/*
* Verify you can change directory into this node.
*/
if ( !loc.ops->node_type_h ) {
24e04: e59d2010 ldr r2, [sp, #16]
24e08: e5923010 ldr r3, [r2, #16]
24e0c: e3530000 cmp r3, #0
24e10: 1a000007 bne 24e34 <chdir+0x78>
rtems_filesystem_freenode( &loc );
24e14: e592301c ldr r3, [r2, #28] <== NOT EXECUTED
24e18: e3530000 cmp r3, #0 <== NOT EXECUTED
24e1c: 11a00004 movne r0, r4 <== NOT EXECUTED
24e20: 11a0e00f movne lr, pc <== NOT EXECUTED
24e24: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
24e28: eb006034 bl 3cf00 <__errno> <== NOT EXECUTED
24e2c: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
24e30: ea00000e b 24e70 <chdir+0xb4> <== NOT EXECUTED
}
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
24e34: e1a00004 mov r0, r4
24e38: e1a0e00f mov lr, pc
24e3c: e12fff13 bx r3
24e40: e3500001 cmp r0, #1
24e44: 0a00000c beq 24e7c <chdir+0xc0>
rtems_filesystem_freenode( &loc );
24e48: e59d3010 ldr r3, [sp, #16]
24e4c: e3530000 cmp r3, #0
24e50: 0a000004 beq 24e68 <chdir+0xac>
24e54: e593301c ldr r3, [r3, #28]
24e58: e3530000 cmp r3, #0
24e5c: 11a00004 movne r0, r4
24e60: 11a0e00f movne lr, pc
24e64: 112fff13 bxne r3
rtems_set_errno_and_return_minus_one( ENOTDIR );
24e68: eb006024 bl 3cf00 <__errno>
24e6c: e3a03014 mov r3, #20
24e70: e5803000 str r3, [r0]
24e74: e3e00000 mvn r0, #0
24e78: ea000012 b 24ec8 <chdir+0x10c>
}
rtems_filesystem_freenode( &rtems_filesystem_current );
24e7c: e59f304c ldr r3, [pc, #76] ; 24ed0 <chdir+0x114>
24e80: e5930000 ldr r0, [r3]
24e84: e5903010 ldr r3, [r0, #16]
24e88: e3530000 cmp r3, #0
24e8c: 0a000004 beq 24ea4 <chdir+0xe8>
24e90: e593301c ldr r3, [r3, #28]
24e94: e3530000 cmp r3, #0
24e98: 12800004 addne r0, r0, #4
24e9c: 11a0e00f movne lr, pc
24ea0: 112fff13 bxne r3
rtems_filesystem_current = loc;
24ea4: e59f3024 ldr r3, [pc, #36] ; 24ed0 <chdir+0x114>
24ea8: e28d4004 add r4, sp, #4
24eac: e593c000 ldr ip, [r3]
24eb0: e8b4000f ldm r4!, {r0, r1, r2, r3}
24eb4: e28cc004 add ip, ip, #4
24eb8: e8ac000f stmia ip!, {r0, r1, r2, r3}
24ebc: e5943000 ldr r3, [r4]
24ec0: e58c3000 str r3, [ip]
24ec4: e3a00000 mov r0, #0
return 0;
}
24ec8: e28dd018 add sp, sp, #24
24ecc: e8bd8030 pop {r4, r5, pc}
00007140 <chmod>:
int chmod(
const char *path,
mode_t mode
)
{
7140: e92d4070 push {r4, r5, r6, lr}
7144: e24dd018 sub sp, sp, #24
7148: e1a05001 mov r5, r1
714c: 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 );
7150: eb00f267 bl 43af4 <strlen>
7154: e28d4004 add r4, sp, #4
7158: e1a01000 mov r1, r0
715c: e3a0c001 mov ip, #1
7160: e1a00006 mov r0, r6
7164: e3a02000 mov r2, #0
7168: e1a03004 mov r3, r4
716c: e58dc000 str ip, [sp]
7170: eb000131 bl 763c <rtems_filesystem_evaluate_path>
if ( status != 0 )
7174: e3500000 cmp r0, #0
7178: 1a00000d bne 71b4 <chmod+0x74>
return -1;
if ( !loc.handlers ){
717c: e59d300c ldr r3, [sp, #12]
7180: e3530000 cmp r3, #0
7184: 1a00000c bne 71bc <chmod+0x7c>
rtems_filesystem_freenode( &loc );
7188: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
718c: e3530000 cmp r3, #0 <== NOT EXECUTED
7190: 0a000004 beq 71a8 <chmod+0x68> <== NOT EXECUTED
7194: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
7198: e3530000 cmp r3, #0 <== NOT EXECUTED
719c: 11a00004 movne r0, r4 <== NOT EXECUTED
71a0: 11a0e00f movne lr, pc <== NOT EXECUTED
71a4: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
71a8: eb00d754 bl 3cf00 <__errno> <== NOT EXECUTED
71ac: e3a03009 mov r3, #9 <== NOT EXECUTED
71b0: e5803000 str r3, [r0] <== NOT EXECUTED
71b4: e3e05000 mvn r5, #0
71b8: ea00001a b 7228 <chmod+0xe8>
}
if ( !loc.handlers->fchmod_h ){
71bc: e593301c ldr r3, [r3, #28]
71c0: e3530000 cmp r3, #0
71c4: 1a00000a bne 71f4 <chmod+0xb4>
rtems_filesystem_freenode( &loc );
71c8: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
71cc: e3530000 cmp r3, #0 <== NOT EXECUTED
71d0: 0a000004 beq 71e8 <chmod+0xa8> <== NOT EXECUTED
71d4: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
71d8: e3530000 cmp r3, #0 <== NOT EXECUTED
71dc: 11a00004 movne r0, r4 <== NOT EXECUTED
71e0: 11a0e00f movne lr, pc <== NOT EXECUTED
71e4: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
71e8: eb00d744 bl 3cf00 <__errno> <== NOT EXECUTED
71ec: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
71f0: eaffffee b 71b0 <chmod+0x70> <== NOT EXECUTED
}
result = (*loc.handlers->fchmod_h)( &loc, mode );
71f4: e1a01005 mov r1, r5
71f8: e1a00004 mov r0, r4
71fc: e1a0e00f mov lr, pc
7200: e12fff13 bx r3
rtems_filesystem_freenode( &loc );
7204: e59d3010 ldr r3, [sp, #16]
7208: 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 );
720c: e1a05000 mov r5, r0
rtems_filesystem_freenode( &loc );
7210: 0a000004 beq 7228 <chmod+0xe8>
7214: e593301c ldr r3, [r3, #28]
7218: e3530000 cmp r3, #0
721c: 11a00004 movne r0, r4
7220: 11a0e00f movne lr, pc
7224: 112fff13 bxne r3
return result;
}
7228: e1a00005 mov r0, r5
722c: e28dd018 add sp, sp, #24
7230: e8bd8070 pop {r4, r5, r6, pc}
00024ed4 <chown>:
int chown(
const char *path,
uid_t owner,
gid_t group
)
{
24ed4: e92d40f0 push {r4, r5, r6, r7, lr}
24ed8: e1a01801 lsl r1, r1, #16
24edc: e24dd018 sub sp, sp, #24
24ee0: e1a02802 lsl r2, r2, #16
24ee4: e1a06821 lsr r6, r1, #16
24ee8: e1a05822 lsr r5, r2, #16
24eec: e1a07000 mov r7, r0
rtems_filesystem_location_info_t loc;
int result;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &loc, true ) )
24ef0: eb007aff bl 43af4 <strlen>
24ef4: e28d4004 add r4, sp, #4
24ef8: e1a01000 mov r1, r0
24efc: e3a0c001 mov ip, #1
24f00: e1a00007 mov r0, r7
24f04: e3a02000 mov r2, #0
24f08: e1a03004 mov r3, r4
24f0c: e58dc000 str ip, [sp]
24f10: ebff89c9 bl 763c <rtems_filesystem_evaluate_path>
24f14: e3500000 cmp r0, #0
24f18: 1a00000b bne 24f4c <chown+0x78>
return -1;
if ( !loc.ops->chown_h ) {
24f1c: e59d2010 ldr r2, [sp, #16]
24f20: e5923018 ldr r3, [r2, #24]
24f24: e3530000 cmp r3, #0
24f28: 1a000009 bne 24f54 <chown+0x80>
rtems_filesystem_freenode( &loc );
24f2c: e592301c ldr r3, [r2, #28] <== NOT EXECUTED
24f30: e3530000 cmp r3, #0 <== NOT EXECUTED
24f34: 11a00004 movne r0, r4 <== NOT EXECUTED
24f38: 11a0e00f movne lr, pc <== NOT EXECUTED
24f3c: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
24f40: eb005fee bl 3cf00 <__errno> <== NOT EXECUTED
24f44: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
24f48: e5803000 str r3, [r0] <== NOT EXECUTED
24f4c: e3e05000 mvn r5, #0
24f50: ea00000d b 24f8c <chown+0xb8>
}
result = (*loc.ops->chown_h)( &loc, owner, group );
24f54: e1a02005 mov r2, r5
24f58: e1a01006 mov r1, r6
24f5c: e1a00004 mov r0, r4
24f60: e1a0e00f mov lr, pc
24f64: e12fff13 bx r3
rtems_filesystem_freenode( &loc );
24f68: e59d3010 ldr r3, [sp, #16]
24f6c: 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 );
24f70: e1a05000 mov r5, r0
rtems_filesystem_freenode( &loc );
24f74: 0a000004 beq 24f8c <chown+0xb8>
24f78: e593301c ldr r3, [r3, #28]
24f7c: e3530000 cmp r3, #0
24f80: 11a00004 movne r0, r4
24f84: 11a0e00f movne lr, pc
24f88: 112fff13 bxne r3
return result;
}
24f8c: e1a00005 mov r0, r5
24f90: e28dd018 add sp, sp, #24
24f94: e8bd80f0 pop {r4, r5, r6, r7, pc}
00024f98 <chroot>:
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
24f98: 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) {
24f9c: e59f50d4 ldr r5, [pc, #212] ; 25078 <chroot+0xe0>
24fa0: e59f30d4 ldr r3, [pc, #212] ; 2507c <chroot+0xe4>
24fa4: e5954000 ldr r4, [r5]
24fa8: e1540003 cmp r4, r3
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
24fac: e24dd018 sub sp, sp, #24
24fb0: 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) {
24fb4: 1a000007 bne 24fd8 <chroot+0x40>
rtems_libio_set_private_env(); /* try to set a new private env*/
24fb8: eb00058c bl 265f0 <rtems_libio_set_private_env>
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
24fbc: e5953000 ldr r3, [r5]
24fc0: e1530004 cmp r3, r4
24fc4: 1a000003 bne 24fd8 <chroot+0x40>
rtems_set_errno_and_return_minus_one( ENOTSUP );
24fc8: eb005fcc bl 3cf00 <__errno> <== NOT EXECUTED
24fcc: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
24fd0: e5803000 str r3, [r0] <== NOT EXECUTED
24fd4: ea000008 b 24ffc <chroot+0x64> <== NOT EXECUTED
}
result = chdir(pathname);
24fd8: e1a00006 mov r0, r6
24fdc: ebffff76 bl 24dbc <chdir>
if (result) {
24fe0: e250c000 subs ip, r0, #0
24fe4: 0a000006 beq 25004 <chroot+0x6c>
rtems_set_errno_and_return_minus_one( errno );
24fe8: eb005fc4 bl 3cf00 <__errno> <== NOT EXECUTED
24fec: e1a04000 mov r4, r0 <== NOT EXECUTED
24ff0: eb005fc2 bl 3cf00 <__errno> <== NOT EXECUTED
24ff4: e5903000 ldr r3, [r0] <== NOT EXECUTED
24ff8: e5843000 str r3, [r4] <== NOT EXECUTED
24ffc: e3e00000 mvn r0, #0 <== NOT EXECUTED
25000: ea00001a b 25070 <chroot+0xd8> <== NOT EXECUTED
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
25004: e1a0200c mov r2, ip
25008: e59f0070 ldr r0, [pc, #112] ; 25080 <chroot+0xe8>
2500c: e3a01001 mov r1, #1
25010: e28d3004 add r3, sp, #4
25014: e58dc000 str ip, [sp]
25018: ebff8987 bl 763c <rtems_filesystem_evaluate_path>
2501c: e3500000 cmp r0, #0
25020: 1afffff0 bne 24fe8 <chroot+0x50>
/* 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);
25024: e59f304c ldr r3, [pc, #76] ; 25078 <chroot+0xe0>
25028: e5930000 ldr r0, [r3]
2502c: e5903024 ldr r3, [r0, #36] ; 0x24
25030: e3530000 cmp r3, #0
25034: 0a000004 beq 2504c <chroot+0xb4>
25038: e593301c ldr r3, [r3, #28]
2503c: e3530000 cmp r3, #0
25040: 12800018 addne r0, r0, #24
25044: 11a0e00f movne lr, pc
25048: 112fff13 bxne r3
rtems_filesystem_root = loc;
2504c: e59f3024 ldr r3, [pc, #36] ; 25078 <chroot+0xe0>
25050: e28d4004 add r4, sp, #4
25054: e593c000 ldr ip, [r3]
25058: e8b4000f ldm r4!, {r0, r1, r2, r3}
2505c: e28cc018 add ip, ip, #24
25060: e8ac000f stmia ip!, {r0, r1, r2, r3}
25064: e5943000 ldr r3, [r4]
25068: e58c3000 str r3, [ip]
2506c: e3a00000 mov r0, #0
return 0;
}
25070: e28dd018 add sp, sp, #24
25074: e8bd8070 pop {r4, r5, r6, pc}
000020c0 <create_disk>:
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
20c0: e59fc19c ldr ip, [pc, #412] ; 2264 <create_disk+0x1a4>
return disktab [major].minor + minor;
}
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
20c4: 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) {
20c8: e59c4000 ldr r4, [ip]
20cc: e1500004 cmp r0, r4
return disktab [major].minor + minor;
}
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
20d0: e1a05000 mov r5, r0
20d4: e1a06001 mov r6, r1
20d8: e1a08002 mov r8, r2
20dc: e1a09003 mov r9, 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) {
20e0: 3a00000e bcc 2120 <create_disk+0x60>
rtems_disk_device_table *table = disktab;
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
20e4: e1a07084 lsl r7, r4, #1
if (major >= new_size) {
20e8: e1500007 cmp r0, r7
new_size = major + 1;
20ec: 22857001 addcs r7, 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;
20f0: e59c0004 ldr r0, [ip, #4]
if (major >= new_size) {
new_size = major + 1;
}
table = realloc(table, new_size * sizeof(*table));
20f4: e1a01187 lsl r1, r7, #3
20f8: eb0006cd bl 3c34 <realloc>
if (table == NULL) {
20fc: e250a000 subs sl, r0, #0
2100: 0a00004e beq 2240 <create_disk+0x180>
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
2104: e0642007 rsb r2, r4, r7 <== NOT EXECUTED
2108: e08a0184 add r0, sl, r4, lsl #3 <== NOT EXECUTED
210c: e1a02182 lsl r2, r2, #3 <== NOT EXECUTED
2110: e3a01000 mov r1, #0 <== NOT EXECUTED
2114: eb003dd7 bl 11878 <memset> <== NOT EXECUTED
disktab = table;
2118: e59f3144 ldr r3, [pc, #324] ; 2264 <create_disk+0x1a4> <== NOT EXECUTED
disktab_size = new_size;
211c: e8830480 stm r3, {r7, sl} <== NOT EXECUTED
}
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
2120: e59f313c ldr r3, [pc, #316] ; 2264 <create_disk+0x1a4>
2124: e5933004 ldr r3, [r3, #4]
2128: e7930185 ldr r0, [r3, r5, lsl #3]
212c: e1a0a185 lsl sl, r5, #3
2130: e3500000 cmp r0, #0
2134: e083300a add r3, r3, sl
2138: 0a000002 beq 2148 <create_disk+0x88>
213c: e5932004 ldr r2, [r3, #4]
2140: e1560002 cmp r6, r2
2144: 3a000013 bcc 2198 <create_disk+0xd8>
rtems_disk_device **table = disktab [major].minor;
rtems_device_minor_number old_size = disktab [major].size;
2148: e593b004 ldr fp, [r3, #4]
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
214c: e35b0000 cmp fp, #0
2150: 03a04008 moveq r4, #8
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
2154: 11a0408b lslne r4, fp, #1
}
if (minor >= new_size) {
2158: e1560004 cmp r6, r4
new_size = minor + 1;
215c: 22864001 addcs r4, r6, #1
}
table = realloc(table, new_size * sizeof(*table));
2160: e1a01104 lsl r1, r4, #2
2164: eb0006b2 bl 3c34 <realloc>
if (table == NULL) {
2168: e2507000 subs r7, r0, #0
216c: 0a000033 beq 2240 <create_disk+0x180>
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
2170: e06b2004 rsb r2, fp, r4
2174: e087010b add r0, r7, fp, lsl #2
2178: e1a02102 lsl r2, r2, #2
217c: e3a01000 mov r1, #0
2180: eb003dbc bl 11878 <memset>
disktab [major].minor = table;
2184: e59f30d8 ldr r3, [pc, #216] ; 2264 <create_disk+0x1a4>
2188: e5933004 ldr r3, [r3, #4]
218c: e083a00a add sl, r3, sl
2190: e7837185 str r7, [r3, r5, lsl #3]
disktab [major].size = new_size;
2194: e58a4004 str r4, [sl, #4]
}
return disktab [major].minor + minor;
2198: e59f30c4 ldr r3, [pc, #196] ; 2264 <create_disk+0x1a4>
219c: e5933004 ldr r3, [r3, #4]
21a0: e7937185 ldr r7, [r3, r5, lsl #3]
21a4: e0873106 add r3, r7, r6, lsl #2
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
21a8: e3530000 cmp r3, #0
21ac: 0a000023 beq 2240 <create_disk+0x180>
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
21b0: e7973106 ldr r3, [r7, r6, lsl #2]
21b4: e3530000 cmp r3, #0
21b8: 13a0000c movne r0, #12
21bc: 18bd8ff0 popne {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
21c0: e3a00034 mov r0, #52 ; 0x34
21c4: eb0003c8 bl 30ec <malloc>
if (dd == NULL) {
21c8: e2504000 subs r4, r0, #0
21cc: 0a00001b beq 2240 <create_disk+0x180>
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
21d0: e3580000 cmp r8, #0
21d4: 0a00000f beq 2218 <create_disk+0x158>
alloc_name = strdup(name);
21d8: e1a00008 mov r0, r8
21dc: eb003f20 bl 11e64 <strdup>
if (alloc_name == NULL) {
21e0: e3500000 cmp r0, #0
if (dd == NULL) {
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
alloc_name = strdup(name);
21e4: e1a08000 mov r8, r0
21e8: e1a0a000 mov sl, r0
if (alloc_name == NULL) {
21ec: 1a000015 bne 2248 <create_disk+0x188>
free(dd);
21f0: e1a00004 mov r0, r4 <== NOT EXECUTED
21f4: eb0002f0 bl 2dbc <free> <== NOT EXECUTED
21f8: e3a0001a mov r0, #26 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
21fc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
free(alloc_name);
2200: e1a00008 mov r0, r8 <== NOT EXECUTED
2204: eb0002ec bl 2dbc <free> <== NOT EXECUTED
free(dd);
2208: e1a00004 mov r0, r4 <== NOT EXECUTED
220c: eb0002ea bl 2dbc <free> <== NOT EXECUTED
2210: e3a0000d mov r0, #13 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
2214: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
2218: e1a0a008 mov sl, r8
}
}
dd->dev = dev;
dd->name = alloc_name;
dd->uses = 0;
221c: e3a00000 mov r0, #0
dd->deleted = false;
*dd_entry = dd;
2220: e7874106 str r4, [r7, r6, lsl #2]
free(dd);
return RTEMS_UNSATISFIED;
}
}
dd->dev = dev;
2224: e5845000 str r5, [r4]
dd->name = alloc_name;
dd->uses = 0;
dd->deleted = false;
*dd_entry = dd;
*dd_ptr = dd;
2228: e5894000 str r4, [r9]
return RTEMS_UNSATISFIED;
}
}
dd->dev = dev;
dd->name = alloc_name;
222c: e584a010 str sl, [r4, #16]
free(dd);
return RTEMS_UNSATISFIED;
}
}
dd->dev = dev;
2230: e5846004 str r6, [r4, #4]
dd->name = alloc_name;
dd->uses = 0;
2234: e5840014 str r0, [r4, #20]
dd->deleted = false;
2238: e5c40030 strb r0, [r4, #48] ; 0x30
*dd_entry = dd;
*dd_ptr = dd;
return RTEMS_SUCCESSFUL;
223c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
2240: e3a0001a mov r0, #26
}
2244: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return RTEMS_NO_MEMORY;
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
2248: e59f1018 ldr r1, [pc, #24] ; 2268 <create_disk+0x1a8>
224c: e1a02005 mov r2, r5
2250: e1a03006 mov r3, r6
2254: eb0003e6 bl 31f4 <mknod>
2258: e3500000 cmp r0, #0
225c: aaffffee bge 221c <create_disk+0x15c>
2260: eaffffe6 b 2200 <create_disk+0x140> <== NOT EXECUTED
000080b0 <devFS_evaluate_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
80b0: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
80b4: e3d27007 bics r7, r2, #7
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
80b8: e1a09000 mov r9, r0
80bc: e1a04001 mov r4, r1
80c0: e1a05003 mov r5, r3
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
80c4: 0a000002 beq 80d4 <devFS_evaluate_path+0x24>
rtems_set_errno_and_return_minus_one( EPERM );
80c8: eb00063b bl 99bc <__errno> <== NOT EXECUTED
80cc: e3a03001 mov r3, #1 <== NOT EXECUTED
80d0: ea000005 b 80ec <devFS_evaluate_path+0x3c> <== NOT EXECUTED
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
80d4: e5936000 ldr r6, [r3]
if (!device_name_table)
80d8: e3560000 cmp r6, #0
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
80dc: 159fa090 ldrne sl, [pc, #144] ; 8174 <devFS_evaluate_path+0xc4>
if ( !rtems_libio_is_valid_perms( flags ) )
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)
80e0: 1a000019 bne 814c <devFS_evaluate_path+0x9c>
rtems_set_errno_and_return_minus_one( EFAULT );
80e4: eb000634 bl 99bc <__errno> <== NOT EXECUTED
80e8: e3a0300e mov r3, #14 <== NOT EXECUTED
80ec: e5803000 str r3, [r0] <== NOT EXECUTED
80f0: e3e00000 mvn r0, #0 <== NOT EXECUTED
80f4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
for (i = 0; i < rtems_device_table_size; i++) {
if (!device_name_table[i].device_name)
80f8: e5968000 ldr r8, [r6]
80fc: e2581000 subs r1, r8, #0
8100: 0a00000f beq 8144 <devFS_evaluate_path+0x94>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
8104: eb0009e2 bl a894 <strncmp>
8108: e3500000 cmp r0, #0
810c: 1a00000c bne 8144 <devFS_evaluate_path+0x94>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
8110: e7d80004 ldrb r0, [r8, r4]
8114: e3500000 cmp r0, #0
8118: 1a000009 bne 8144 <devFS_evaluate_path+0x94>
/* 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;
811c: e59f3054 ldr r3, [pc, #84] ; 8178 <devFS_evaluate_path+0xc8>
8120: e5933000 ldr r3, [r3]
8124: e5933028 ldr r3, [r3, #40] ; 0x28
8128: e5853010 str r3, [r5, #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;
812c: e59f3048 ldr r3, [pc, #72] ; 817c <devFS_evaluate_path+0xcc>
8130: e5853008 str r3, [r5, #8]
pathloc->ops = &devFS_ops;
8134: e59f3044 ldr r3, [pc, #68] ; 8180 <devFS_evaluate_path+0xd0>
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
8138: e5856000 str r6, [r5]
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
813c: e585300c str r3, [r5, #12]
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
8140: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
/* 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++) {
8144: e2877001 add r7, r7, #1
8148: e2866014 add r6, r6, #20
814c: e59a3000 ldr r3, [sl]
8150: e1570003 cmp r7, r3
if (!device_name_table[i].device_name)
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
8154: e1a00009 mov r0, r9
8158: e1a02004 mov r2, r4
/* 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++) {
815c: 3affffe5 bcc 80f8 <devFS_evaluate_path+0x48>
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
8160: eb000615 bl 99bc <__errno>
8164: e3a03002 mov r3, #2
8168: e5803000 str r3, [r0]
816c: e3e00000 mvn r0, #0
}
8170: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
000012a4 <devFS_initialize>:
int devFS_initialize(
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const void *data
)
{
12a4: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_device_name_t *device_name_table;
/* allocate device only filesystem name table */
device_name_table = (rtems_device_name_t *)_Workspace_Allocate(
12a8: e59f7058 ldr r7, [pc, #88] ; 1308 <devFS_initialize+0x64>
12ac: e5973000 ldr r3, [r7]
12b0: e3a06014 mov r6, #20
int devFS_initialize(
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const void *data
)
{
12b4: 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(
12b8: e0000396 mul r0, r6, r3
12bc: eb001a4f bl 7c00 <_Workspace_Allocate>
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* no memory for device filesystem */
if (!device_name_table)
12c0: e2505000 subs r5, r0, #0
12c4: 1a000004 bne 12dc <devFS_initialize+0x38>
rtems_set_errno_and_return_minus_one( ENOMEM );
12c8: eb0021bb bl 99bc <__errno> <== NOT EXECUTED
12cc: e3a0300c mov r3, #12 <== NOT EXECUTED
12d0: e5803000 str r3, [r0] <== NOT EXECUTED
12d4: e3e00000 mvn r0, #0 <== NOT EXECUTED
12d8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
memset(
12dc: e5972000 ldr r2, [r7]
12e0: e3a01000 mov r1, #0
12e4: e0020296 mul r2, r6, r2
12e8: eb0023e1 bl a274 <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;
12ec: e59f3018 ldr r3, [pc, #24] ; 130c <devFS_initialize+0x68>
temp_mt_entry->mt_fs_root.ops = &devFS_ops;
12f0: 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;
12f4: 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;
12f8: 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;
12fc: 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;
1300: e3a00000 mov r0, #0
return 0;
}
1304: e8bd80f0 pop {r4, r5, r6, r7, pc}
00001310 <devFS_mknod>:
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
1310: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
1314: 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') &&
1318: e5d00000 ldrb r0, [r0]
131c: e3500064 cmp r0, #100 ; 0x64
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
1320: e1a05001 mov r5, r1
1324: e58d2000 str r2, [sp]
1328: e1a09003 mov r9, 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') &&
132c: 1a000008 bne 1354 <devFS_mknod+0x44>
1330: e5d43001 ldrb r3, [r4, #1]
1334: e3530065 cmp r3, #101 ; 0x65
1338: 1a000005 bne 1354 <devFS_mknod+0x44>
(path[2] == 'v') && (path[3] == '\0'))
133c: e5d43002 ldrb r3, [r4, #2]
1340: e3530076 cmp r3, #118 ; 0x76
1344: 1a000002 bne 1354 <devFS_mknod+0x44>
1348: e5d40003 ldrb r0, [r4, #3]
134c: e3500000 cmp r0, #0
1350: 0a000039 beq 143c <devFS_mknod+0x12c>
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
1354: e205aa0f and sl, r5, #61440 ; 0xf000
1358: e35a0a02 cmp sl, #8192 ; 0x2000
135c: 135a0a06 cmpne sl, #24576 ; 0x6000
1360: 03a0a000 moveq sl, #0
1364: 13a0a001 movne sl, #1
1368: 0a000002 beq 1378 <devFS_mknod+0x68>
rtems_set_errno_and_return_minus_one( EINVAL );
136c: eb002192 bl 99bc <__errno> <== NOT EXECUTED
1370: e3a03016 mov r3, #22 <== NOT EXECUTED
1374: ea000008 b 139c <devFS_mknod+0x8c> <== NOT EXECUTED
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;
1378: e59d3028 ldr r3, [sp, #40] ; 0x28
137c: e5936000 ldr r6, [r3]
if (!device_name_table)
1380: e3560000 cmp r6, #0
1384: 13e07000 mvnne r7, #0
1388: 11a0800a movne r8, sl
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
138c: 159fb0ac ldrne fp, [pc, #172] ; 1440 <devFS_mknod+0x130>
1390: 1a000010 bne 13d8 <devFS_mknod+0xc8>
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 );
1394: eb002188 bl 99bc <__errno> <== NOT EXECUTED
1398: e3a0300e mov r3, #14 <== NOT EXECUTED
139c: e5803000 str r3, [r0] <== NOT EXECUTED
13a0: e3e00000 mvn r0, #0 <== NOT EXECUTED
13a4: ea000024 b 143c <devFS_mknod+0x12c> <== NOT EXECUTED
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
13a8: e796300a ldr r3, [r6, sl]
13ac: e2531000 subs r1, r3, #0
13b0: 0a000005 beq 13cc <devFS_mknod+0xbc>
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
13b4: eb002456 bl a514 <strcmp> <== NOT EXECUTED
13b8: e3500000 cmp r0, #0 <== NOT EXECUTED
13bc: 1a000003 bne 13d0 <devFS_mknod+0xc0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EEXIST );
13c0: eb00217d bl 99bc <__errno> <== NOT EXECUTED
13c4: e3a03011 mov r3, #17 <== NOT EXECUTED
13c8: eafffff3 b 139c <devFS_mknod+0x8c> <== NOT EXECUTED
13cc: e1a07008 mov r7, r8
/* 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++){
13d0: e2888001 add r8, r8, #1
13d4: e28aa014 add sl, sl, #20
13d8: e59b3000 ldr r3, [fp]
13dc: e1580003 cmp r8, r3
if (device_name_table[i].device_name == NULL)
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
13e0: e1a00004 mov r0, r4
/* 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++){
13e4: 3affffef bcc 13a8 <devFS_mknod+0x98>
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
13e8: e3770001 cmn r7, #1
13ec: 1a000004 bne 1404 <devFS_mknod+0xf4>
rtems_set_errno_and_return_minus_one( ENOMEM );
13f0: eb002171 bl 99bc <__errno> <== NOT EXECUTED
13f4: e3a0300c mov r3, #12 <== NOT EXECUTED
13f8: e5803000 str r3, [r0] <== NOT EXECUTED
13fc: e1a00007 mov r0, r7 <== NOT EXECUTED
1400: ea00000d b 143c <devFS_mknod+0x12c> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
1404: e10f8000 mrs r8, CPSR
1408: e3883080 orr r3, r8, #128 ; 0x80
140c: e129f003 msr CPSR_fc, r3
_ISR_Disable(level);
device_name_table[slot].device_name = (char *)path;
1410: e3a02014 mov r2, #20
1414: e0030792 mul r3, r2, r7
device_name_table[slot].device_name_length = strlen(path);
1418: e1a00004 mov r0, r4
if (slot == -1)
rtems_set_errno_and_return_minus_one( ENOMEM );
_ISR_Disable(level);
device_name_table[slot].device_name = (char *)path;
141c: e7864003 str r4, [r6, r3]
1420: e0866003 add r6, r6, r3
device_name_table[slot].device_name_length = strlen(path);
1424: eb002502 bl a834 <strlen>
device_name_table[slot].major = major;
1428: e59d3000 ldr r3, [sp]
device_name_table[slot].minor = minor;
device_name_table[slot].mode = mode;
142c: e5865010 str r5, [r6, #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);
1430: e9860209 stmib r6, {r0, r3, r9}
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
1434: e129f008 msr CPSR_fc, r8
1438: e3a00000 mov r0, #0
device_name_table[slot].minor = minor;
device_name_table[slot].mode = mode;
_ISR_Enable(level);
return 0;
}
143c: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
000014c0 <devFS_read>:
ssize_t devFS_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
14c0: e92d487f push {r0, r1, r2, r3, r4, r5, r6, fp, lr} <== NOT EXECUTED
14c4: e1a03000 mov r3, r0 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
14c8: 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;
14cc: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
args.flags = iop->flags;
args.bytes_moved = 0;
14d0: e3a02000 mov r2, #0 <== NOT EXECUTED
14d4: e58d2018 str r2, [sp, #24] <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
14d8: 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;
14dc: e5932038 ldr r2, [r3, #56] ; 0x38 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
14e0: e283c00c add ip, r3, #12 <== NOT EXECUTED
14e4: e89c1800 ldm ip, {fp, ip} <== NOT EXECUTED
args.buffer = buffer;
14e8: e58d100c str r1, [sp, #12] <== NOT EXECUTED
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
14ec: e2820008 add r0, r2, #8 <== NOT EXECUTED
14f0: e8900003 ldm r0, {r0, r1} <== NOT EXECUTED
14f4: 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;
14f8: 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;
14fc: e58d3000 str r3, [sp] <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
1500: eb000f82 bl 5310 <rtems_io_read> <== NOT EXECUTED
np->major,
np->minor,
(void *) &args
);
if ( status )
1504: e3500000 cmp r0, #0 <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
1508: 059d0018 ldreq r0, [sp, #24] <== NOT EXECUTED
np->minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
150c: 1b001b1c blne 8184 <rtems_deviceio_errno> <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
1510: e28dd01c add sp, sp, #28 <== NOT EXECUTED
1514: e8bd8800 pop {fp, pc} <== NOT EXECUTED
00001518 <devFS_stat>:
struct stat *buf
)
{
rtems_device_name_t *the_dev;
the_dev = (rtems_device_name_t *)loc->node_access;
1518: e5903000 ldr r3, [r0]
if (!the_dev)
151c: e3530000 cmp r3, #0
int devFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
1520: 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)
1524: 1a000004 bne 153c <devFS_stat+0x24>
rtems_set_errno_and_return_minus_one( EFAULT );
1528: eb002123 bl 99bc <__errno> <== NOT EXECUTED
152c: e3a0300e mov r3, #14 <== NOT EXECUTED
1530: e5803000 str r3, [r0] <== NOT EXECUTED
1534: e3e00000 mvn r0, #0 <== NOT EXECUTED
1538: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
buf->st_rdev = rtems_filesystem_make_dev_t( the_dev->major, the_dev->minor );
buf->st_mode = the_dev->mode;
153c: 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 );
1540: e593200c ldr r2, [r3, #12]
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
1544: e5933008 ldr r3, [r3, #8]
1548: e581201c str r2, [r1, #28]
buf->st_mode = the_dev->mode;
154c: 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 );
1550: e5813018 str r3, [r1, #24]
buf->st_mode = the_dev->mode;
1554: e3a00000 mov r0, #0
return 0;
}
1558: e49df004 pop {pc} ; (ldr pc, [sp], #4)
0000c7a4 <device_read>:
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
c7a4: e92d487f push {r0, r1, r2, r3, r4, r5, r6, fp, lr}
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
c7a8: e5903014 ldr r3, [r0, #20]
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
args.iop = iop;
args.offset = iop->offset;
c7ac: e280c00c add ip, r0, #12
c7b0: e89c1800 ldm ip, {fp, ip}
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
c7b4: e58d3014 str r3, [sp, #20]
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
args.iop = iop;
args.offset = iop->offset;
c7b8: e98d1800 stmib sp, {fp, ip}
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
c7bc: e3a03000 mov r3, #0
the_jnode = iop->file_info;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
c7c0: e58d2010 str r2, [sp, #16]
args.flags = iop->flags;
args.bytes_moved = 0;
c7c4: e58d3018 str r3, [sp, #24]
the_jnode = iop->file_info;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
c7c8: e58d100c str r1, [sp, #12]
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
args.iop = iop;
c7cc: e58d0000 str r0, [sp]
{
rtems_libio_rw_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
c7d0: e5903038 ldr r3, [r0, #56] ; 0x38
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
c7d4: e1a0200d mov r2, sp
c7d8: e2830050 add r0, r3, #80 ; 0x50
c7dc: e8900003 ldm r0, {r0, r1}
c7e0: eb00024e bl d120 <rtems_io_read>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
c7e4: e3500000 cmp r0, #0 <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
c7e8: 059d0018 ldreq r0, [sp, #24] <== NOT EXECUTED
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
c7ec: 1b0002c7 blne d310 <rtems_deviceio_errno> <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
c7f0: e28dd01c add sp, sp, #28 <== NOT EXECUTED
c7f4: e8bd8800 pop {fp, pc} <== NOT EXECUTED
00001d80 <disk_unlock>:
static void
disk_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
1d80: e59f3020 ldr r3, [pc, #32] ; 1da8 <disk_unlock+0x28>
1d84: e3a02000 mov r2, #0
}
}
static void
disk_unlock(void)
{
1d88: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
sc = rtems_semaphore_release(diskdevs_mutex);
1d8c: e5930008 ldr r0, [r3, #8]
static void
disk_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
1d90: e5c3200c strb r2, [r3, #12]
sc = rtems_semaphore_release(diskdevs_mutex);
1d94: eb0011c0 bl 649c <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL) {
1d98: e3500000 cmp r0, #0
1d9c: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
/* FIXME: Error number */
rtems_fatal_error_occurred(0xdeadbeef);
1da0: e59f0004 ldr r0, [pc, #4] ; 1dac <disk_unlock+0x2c> <== NOT EXECUTED
1da4: eb0012e4 bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
00003aa0 <drainOutput>:
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
3aa0: e59030b4 ldr r3, [r0, #180] ; 0xb4
3aa4: e3530000 cmp r3, #0
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
3aa8: e92d4030 push {r4, r5, lr}
3aac: e1a04000 mov r4, r0
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
3ab0: 08bd8030 popeq {r4, r5, pc}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
3ab4: e10f3000 mrs r3, CPSR <== NOT EXECUTED
3ab8: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
3abc: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
3ac0: e3a05002 mov r5, #2 <== 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) {
3ac4: ea00000a b 3af4 <drainOutput+0x54> <== NOT EXECUTED
tty->rawOutBufState = rob_wait;
3ac8: e5845094 str r5, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3acc: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
3ad0: e3a01000 mov r1, #0 <== NOT EXECUTED
3ad4: e594008c ldr r0, [r4, #140] ; 0x8c <== NOT EXECUTED
3ad8: e1a02001 mov r2, r1 <== NOT EXECUTED
3adc: eb0005ae bl 519c <rtems_semaphore_obtain> <== NOT EXECUTED
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
3ae0: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
3ae4: 1b00072f blne 57a8 <rtems_fatal_error_occurred> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
3ae8: e10f3000 mrs r3, CPSR <== NOT EXECUTED
3aec: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
3af0: 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) {
3af4: e5941084 ldr r1, [r4, #132] ; 0x84 <== NOT EXECUTED
3af8: e5942080 ldr r2, [r4, #128] ; 0x80 <== NOT EXECUTED
3afc: e1510002 cmp r1, r2 <== NOT EXECUTED
3b00: 1afffff0 bne 3ac8 <drainOutput+0x28> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3b04: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
3b08: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00002568 <dup2>:
int dup2(
int fildes,
int fildes2
)
{
2568: e92d4070 push {r4, r5, r6, lr}
256c: e24dd048 sub sp, sp, #72 ; 0x48
2570: e1a04001 mov r4, r1
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
2574: e1a0100d mov r1, sp
int dup2(
int fildes,
int fildes2
)
{
2578: e1a06000 mov r6, r0
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
257c: eb000181 bl 2b88 <fstat>
if ( status == -1 )
2580: e3700001 cmn r0, #1
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
2584: e1a0500d mov r5, sp
if ( status == -1 )
2588: 0a000009 beq 25b4 <dup2+0x4c>
/*
* If fildes2 is not valid, then we should not do anything either.
*/
status = fstat( fildes2, &buf );
258c: e1a0100d mov r1, sp
2590: e1a00004 mov r0, r4
2594: eb00017b bl 2b88 <fstat>
if ( status == -1 )
2598: e3700001 cmn r0, #1
259c: 0a000004 beq 25b4 <dup2+0x4c>
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
25a0: e1a00006 mov r0, r6 <== NOT EXECUTED
25a4: e1a02004 mov r2, r4 <== NOT EXECUTED
25a8: e3a01000 mov r1, #0 <== NOT EXECUTED
25ac: eb00007b bl 27a0 <fcntl> <== NOT EXECUTED
25b0: ea000000 b 25b8 <dup2+0x50> <== NOT EXECUTED
25b4: e3e00000 mvn r0, #0
}
25b8: e28dd048 add sp, sp, #72 ; 0x48
25bc: e8bd8070 pop {r4, r5, r6, pc}
000035a0 <echo>:
* 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')) {
35a0: e591303c ldr r3, [r1, #60] ; 0x3c <== NOT EXECUTED
35a4: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
35a8: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
35ac: e1a04001 mov r4, r1 <== NOT EXECUTED
35b0: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
35b4: 0a000015 beq 3610 <echo+0x70> <== NOT EXECUTED
35b8: e59f305c ldr r3, [pc, #92] ; 361c <echo+0x7c> <== NOT EXECUTED
35bc: e5933000 ldr r3, [r3] <== NOT EXECUTED
35c0: e0833000 add r3, r3, r0 <== NOT EXECUTED
35c4: e5d32001 ldrb r2, [r3, #1] <== NOT EXECUTED
35c8: e2503009 subs r3, r0, #9 <== NOT EXECUTED
35cc: 13a03001 movne r3, #1 <== NOT EXECUTED
35d0: e01332a2 ands r3, r3, r2, lsr #5 <== NOT EXECUTED
35d4: 0a00000d beq 3610 <echo+0x70> <== NOT EXECUTED
35d8: e350000a cmp r0, #10 <== NOT EXECUTED
35dc: 0a00000b beq 3610 <echo+0x70> <== NOT EXECUTED
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
35e0: 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] = '^';
35e4: e3a0c05e mov ip, #94 ; 0x5e <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
35e8: e1a0000d mov r0, sp <== NOT EXECUTED
35ec: e3a01002 mov r1, #2 <== NOT EXECUTED
35f0: 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;
35f4: 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] = '^';
35f8: e5cdc000 strb ip, [sp] <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
35fc: ebffff50 bl 3344 <rtems_termios_puts> <== NOT EXECUTED
tty->column += 2;
3600: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
3604: e2833002 add r3, r3, #2 <== NOT EXECUTED
3608: 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')) {
360c: ea000001 b 3618 <echo+0x78> <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
}
else {
oproc (c, tty);
3610: e1a01004 mov r1, r4 <== NOT EXECUTED
3614: ebffff8b bl 3448 <oproc> <== NOT EXECUTED
}
}
3618: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
00025404 <endgrent>:
group_fp = fopen("/etc/group", "r");
}
void endgrent(void)
{
if (group_fp != NULL)
25404: e59f300c ldr r3, [pc, #12] ; 25418 <endgrent+0x14> <== NOT EXECUTED
25408: e5930000 ldr r0, [r3] <== NOT EXECUTED
2540c: e3500000 cmp r0, #0 <== NOT EXECUTED
25410: 012fff1e bxeq lr <== NOT EXECUTED
fclose(group_fp);
25414: ea005f06 b 3d034 <fclose> <== NOT EXECUTED
0002541c <endpwent>:
passwd_fp = fopen("/etc/passwd", "r");
}
void endpwent(void)
{
if (passwd_fp != NULL)
2541c: e59f300c ldr r3, [pc, #12] ; 25430 <endpwent+0x14> <== NOT EXECUTED
25420: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED
25424: e3500000 cmp r0, #0 <== NOT EXECUTED
25428: 012fff1e bxeq lr <== NOT EXECUTED
fclose(passwd_fp);
2542c: ea005f00 b 3d034 <fclose> <== NOT EXECUTED
00003620 <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)
3620: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED
3624: 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)
{
3628: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
362c: e1a04000 mov r4, r0 <== NOT EXECUTED
3630: e1a07001 mov r7, r1 <== NOT EXECUTED
if (tty->ccount == 0)
3634: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
return;
if (lineFlag) {
3638: e3510000 cmp r1, #0 <== NOT EXECUTED
363c: 0a000062 beq 37cc <erase+0x1ac> <== NOT EXECUTED
if (!(tty->termios.c_lflag & ECHO)) {
3640: e590303c ldr r3, [r0, #60] ; 0x3c <== NOT EXECUTED
3644: e2132008 ands r2, r3, #8 <== NOT EXECUTED
tty->ccount = 0;
3648: 05802020 streq r2, [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)) {
364c: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
3650: e2133010 ands r3, r3, #16 <== NOT EXECUTED
3654: 1a00005c bne 37cc <erase+0x1ac> <== NOT EXECUTED
tty->ccount = 0;
3658: e5803020 str r3, [r0, #32] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
365c: e1a01004 mov r1, r4 <== NOT EXECUTED
3660: e5d00044 ldrb r0, [r0, #68] ; 0x44 <== NOT EXECUTED
3664: ebffffcd bl 35a0 <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
3668: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
366c: e3130020 tst r3, #32 <== NOT EXECUTED
echo ('\n', tty);
3670: 11a01004 movne r1, r4 <== NOT EXECUTED
3674: 13a0000a movne r0, #10 <== NOT EXECUTED
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
if (tty->termios.c_lflag & ECHOK)
3678: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
367c: ea00000c b 36b4 <erase+0x94> <== NOT EXECUTED
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
3680: e2411001 sub r1, r1, #1 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
3684: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
3688: e5841020 str r1, [r4, #32] <== NOT EXECUTED
368c: e594201c ldr r2, [r4, #28] <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
3690: e3130008 tst r3, #8 <== NOT EXECUTED
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
3694: e7d25001 ldrb r5, [r2, r1] <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
3698: 0a000048 beq 37c0 <erase+0x1a0> <== NOT EXECUTED
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
369c: e3570000 cmp r7, #0 <== NOT EXECUTED
36a0: 1a000005 bne 36bc <erase+0x9c> <== NOT EXECUTED
36a4: e3130010 tst r3, #16 <== NOT EXECUTED
36a8: 1a000003 bne 36bc <erase+0x9c> <== NOT EXECUTED
echo (tty->termios.c_cc[VERASE], tty);
36ac: e5d40043 ldrb r0, [r4, #67] ; 0x43 <== NOT EXECUTED
36b0: e1a01004 mov r1, r4 <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
36b4: e8bd41f0 pop {r4, r5, r6, r7, r8, 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);
36b8: eaffffb8 b 35a0 <echo> <== NOT EXECUTED
}
else if (c == '\t') {
36bc: e3550009 cmp r5, #9 <== NOT EXECUTED
36c0: 1a000020 bne 3748 <erase+0x128> <== NOT EXECUTED
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
}
else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
36c4: e2033c02 and r3, r3, #512 ; 0x200 <== 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;
36c8: e594502c ldr r5, [r4, #44] ; 0x2c <== NOT EXECUTED
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
}
else if (iscntrl (c)) {
36cc: e596c000 ldr ip, [r6] <== NOT EXECUTED
36d0: e3a02000 mov r2, #0 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
36d4: ea00000d b 3710 <erase+0xf0> <== NOT EXECUTED
c = tty->cbuf[i++];
36d8: e594001c ldr r0, [r4, #28] <== NOT EXECUTED
36dc: e7d00002 ldrb r0, [r0, r2] <== NOT EXECUTED
if (c == '\t') {
36e0: e3500009 cmp r0, #9 <== NOT EXECUTED
col = (col | 7) + 1;
}
else if (iscntrl (c)) {
36e4: e08c8000 add r8, ip, r0 <== NOT EXECUTED
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
36e8: 03855007 orreq r5, r5, #7 <== NOT EXECUTED
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
36ec: 0a000005 beq 3708 <erase+0xe8> <== NOT EXECUTED
col = (col | 7) + 1;
}
else if (iscntrl (c)) {
36f0: e5d80001 ldrb r0, [r8, #1] <== NOT EXECUTED
36f4: e3100020 tst r0, #32 <== NOT EXECUTED
36f8: 0a000002 beq 3708 <erase+0xe8> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
36fc: e3530000 cmp r3, #0 <== NOT EXECUTED
col += 2;
3700: 12855002 addne r5, r5, #2 <== NOT EXECUTED
3704: ea000000 b 370c <erase+0xec> <== NOT EXECUTED
}
else {
col++;
3708: e2855001 add r5, r5, #1 <== NOT EXECUTED
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
370c: e2822001 add r2, r2, #1 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
3710: e1520001 cmp r2, r1 <== NOT EXECUTED
3714: 1affffef bne 36d8 <erase+0xb8> <== NOT EXECUTED
3718: ea000006 b 3738 <erase+0x118> <== NOT EXECUTED
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
371c: e59f00bc ldr r0, [pc, #188] ; 37e0 <erase+0x1c0> <== NOT EXECUTED
3720: e3a01001 mov r1, #1 <== NOT EXECUTED
3724: e1a02004 mov r2, r4 <== NOT EXECUTED
3728: ebffff05 bl 3344 <rtems_termios_puts> <== NOT EXECUTED
tty->column--;
372c: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
3730: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3734: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
3738: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
373c: e1530005 cmp r3, r5 <== NOT EXECUTED
3740: cafffff5 bgt 371c <erase+0xfc> <== NOT EXECUTED
3744: ea00001d b 37c0 <erase+0x1a0> <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
3748: e5962000 ldr r2, [r6] <== NOT EXECUTED
374c: e2855001 add r5, r5, #1 <== NOT EXECUTED
3750: e7d22005 ldrb r2, [r2, r5] <== NOT EXECUTED
3754: e3120020 tst r2, #32 <== NOT EXECUTED
3758: 0a000009 beq 3784 <erase+0x164> <== NOT EXECUTED
375c: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
3760: 0a000007 beq 3784 <erase+0x164> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
3764: e59f0078 ldr r0, [pc, #120] ; 37e4 <erase+0x1c4> <== NOT EXECUTED
3768: e3a01003 mov r1, #3 <== NOT EXECUTED
376c: e1a02004 mov r2, r4 <== NOT EXECUTED
3770: ebfffef3 bl 3344 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
3774: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
3778: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
377c: 12433001 subne r3, r3, #1 <== NOT EXECUTED
3780: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
3784: e5963000 ldr r3, [r6] <== NOT EXECUTED
3788: e7d33005 ldrb r3, [r3, r5] <== NOT EXECUTED
378c: e3130020 tst r3, #32 <== NOT EXECUTED
3790: 0a000002 beq 37a0 <erase+0x180> <== NOT EXECUTED
3794: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
3798: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
379c: 0a000007 beq 37c0 <erase+0x1a0> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
37a0: e59f003c ldr r0, [pc, #60] ; 37e4 <erase+0x1c4> <== NOT EXECUTED
37a4: e3a01003 mov r1, #3 <== NOT EXECUTED
37a8: e1a02004 mov r2, r4 <== NOT EXECUTED
37ac: ebfffee4 bl 3344 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
37b0: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
37b4: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
37b8: 12433001 subne r3, r3, #1 <== NOT EXECUTED
37bc: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
}
}
if (!lineFlag)
37c0: e3570000 cmp r7, #0 <== NOT EXECUTED
37c4: 1a000001 bne 37d0 <erase+0x1b0> <== NOT EXECUTED
37c8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
37cc: e59f6014 ldr r6, [pc, #20] ; 37e8 <erase+0x1c8> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
37d0: e5941020 ldr r1, [r4, #32] <== NOT EXECUTED
37d4: e3510000 cmp r1, #0 <== NOT EXECUTED
37d8: 1affffa8 bne 3680 <erase+0x60> <== NOT EXECUTED
37dc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
000227e4 <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)
{
227e4: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
227e8: 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)
227ec: e5d00081 ldrb r0, [r0, #129] ; 0x81 <== NOT EXECUTED
227f0: 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)
{
227f4: e1a05001 mov r5, r1 <== NOT EXECUTED
227f8: e1a07002 mov r7, r2 <== NOT EXECUTED
227fc: e1a0a003 mov sl, r3 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
22800: 1a00000f bne 22844 <fat_buf_access+0x60> <== NOT EXECUTED
{
if (op_type == FAT_OP_TYPE_READ)
22804: e3520001 cmp r2, #1 <== NOT EXECUTED
22808: e2841054 add r1, r4, #84 ; 0x54 <== NOT EXECUTED
2280c: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
22810: e2843084 add r3, r4, #132 ; 0x84 <== NOT EXECUTED
22814: 1a000002 bne 22824 <fat_buf_access+0x40> <== NOT EXECUTED
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
22818: e1a02005 mov r2, r5 <== NOT EXECUTED
2281c: ebff8ab1 bl 52e8 <rtems_bdbuf_read> <== NOT EXECUTED
22820: ea000001 b 2282c <fat_buf_access+0x48> <== NOT EXECUTED
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
22824: e1a02005 mov r2, r5 <== NOT EXECUTED
22828: ebff8a7b bl 521c <rtems_bdbuf_get> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2282c: e3500000 cmp r0, #0 <== NOT EXECUTED
22830: 1a000058 bne 22998 <fat_buf_access+0x1b4> <== 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;
22834: 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;
22838: e5c40080 strb r0, [r4, #128] ; 0x80 <== NOT EXECUTED
fs_info->c.state = FAT_CACHE_ACTUAL;
2283c: e5c43081 strb r3, [r4, #129] ; 0x81 <== 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;
22840: e584507c str r5, [r4, #124] ; 0x7c <== NOT EXECUTED
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) &&
22844: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
22848: e1d421b4 ldrh r2, [r4, #20] <== NOT EXECUTED
2284c: e1530002 cmp r3, r2 <== NOT EXECUTED
22850: 33a06000 movcc r6, #0 <== NOT EXECUTED
22854: 3a000003 bcc 22868 <fat_buf_access+0x84> <== NOT EXECUTED
22858: e594601c ldr r6, [r4, #28] <== NOT EXECUTED
2285c: e1530006 cmp r3, r6 <== NOT EXECUTED
22860: 23a06000 movcs r6, #0 <== NOT EXECUTED
22864: 33a06001 movcc r6, #1 <== NOT EXECUTED
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.blk_num != blk)
22868: e1530005 cmp r3, r5 <== NOT EXECUTED
2286c: 0a00004e beq 229ac <fat_buf_access+0x1c8> <== NOT EXECUTED
{
if (fs_info->c.modified)
22870: e5d48080 ldrb r8, [r4, #128] ; 0x80 <== NOT EXECUTED
22874: e3580000 cmp r8, #0 <== NOT EXECUTED
22878: 0a000032 beq 22948 <fat_buf_access+0x164> <== NOT EXECUTED
{
if (sec_of_fat && !fs_info->vol.mirror)
2287c: e21660ff ands r6, r6, #255 ; 0xff <== NOT EXECUTED
22880: 0a000006 beq 228a0 <fat_buf_access+0xbc> <== NOT EXECUTED
22884: e5d43048 ldrb r3, [r4, #72] ; 0x48 <== NOT EXECUTED
22888: e3530000 cmp r3, #0 <== NOT EXECUTED
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
2288c: 05943084 ldreq r3, [r4, #132] ; 0x84 <== NOT EXECUTED
22890: 05940088 ldreq r0, [r4, #136] ; 0x88 <== NOT EXECUTED
22894: 05931020 ldreq r1, [r3, #32] <== NOT EXECUTED
22898: 01d420b0 ldrheq r2, [r4] <== NOT EXECUTED
2289c: 0b007647 bleq 401c0 <memcpy> <== NOT EXECUTED
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
228a0: e5940084 ldr r0, [r4, #132] ; 0x84 <== NOT EXECUTED
228a4: ebff862d bl 4160 <rtems_bdbuf_release_modified> <== NOT EXECUTED
fs_info->c.state = FAT_CACHE_EMPTY;
228a8: e3a03000 mov r3, #0 <== NOT EXECUTED
fs_info->c.modified = 0;
if (sc != RTEMS_SUCCESSFUL)
228ac: 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;
228b0: 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;
228b4: e5c43081 strb r3, [r4, #129] ; 0x81 <== NOT EXECUTED
fs_info->c.modified = 0;
if (sc != RTEMS_SUCCESSFUL)
228b8: 1a000036 bne 22998 <fat_buf_access+0x1b4> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
if (sec_of_fat && !fs_info->vol.mirror)
228bc: e3560000 cmp r6, #0 <== NOT EXECUTED
228c0: 0a000025 beq 2295c <fat_buf_access+0x178> <== NOT EXECUTED
228c4: e5d43048 ldrb r3, [r4, #72] ; 0x48 <== NOT EXECUTED
228c8: e3530000 cmp r3, #0 <== NOT EXECUTED
228cc: 03a06001 moveq r6, #1 <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
228d0: 01a0800d moveq r8, sp <== NOT EXECUTED
fs_info->c.state = FAT_CACHE_EMPTY;
fs_info->c.modified = 0;
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
if (sec_of_fat && !fs_info->vol.mirror)
228d4: 0a000016 beq 22934 <fat_buf_access+0x150> <== NOT EXECUTED
228d8: ea00001f b 2295c <fat_buf_access+0x178> <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
228dc: e5941018 ldr r1, [r4, #24] <== NOT EXECUTED
228e0: e594207c ldr r2, [r4, #124] ; 0x7c <== NOT EXECUTED
228e4: e0222691 mla r2, r1, r6, r2 <== NOT EXECUTED
228e8: e2841054 add r1, r4, #84 ; 0x54 <== NOT EXECUTED
228ec: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
228f0: ebff8a49 bl 521c <rtems_bdbuf_get> <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
228f4: e3500000 cmp r0, #0 <== NOT EXECUTED
228f8: 1a000008 bne 22920 <fat_buf_access+0x13c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
228fc: e59d3000 ldr r3, [sp] <== NOT EXECUTED
22900: e5941088 ldr r1, [r4, #136] ; 0x88 <== NOT EXECUTED
22904: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED
22908: e1d420b0 ldrh r2, [r4] <== NOT EXECUTED
2290c: eb00762b bl 401c0 <memcpy> <== NOT EXECUTED
sc = rtems_bdbuf_release_modified(b);
22910: e59d0000 ldr r0, [sp] <== NOT EXECUTED
22914: ebff8611 bl 4160 <rtems_bdbuf_release_modified> <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL)
22918: e3500000 cmp r0, #0 <== NOT EXECUTED
2291c: 0a000002 beq 2292c <fat_buf_access+0x148> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
22920: eb006976 bl 3cf00 <__errno> <== NOT EXECUTED
22924: e3a0300c mov r3, #12 <== NOT EXECUTED
22928: ea00001c b 229a0 <fat_buf_access+0x1bc> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
2292c: e2866001 add r6, r6, #1 <== NOT EXECUTED
22930: e20660ff and r6, r6, #255 ; 0xff <== NOT EXECUTED
22934: e5d42009 ldrb r2, [r4, #9] <== NOT EXECUTED
22938: e1520006 cmp r2, r6 <== NOT EXECUTED
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
2293c: e1a0300d mov r3, sp <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
22940: 8affffe5 bhi 228dc <fat_buf_access+0xf8> <== NOT EXECUTED
22944: ea000004 b 2295c <fat_buf_access+0x178> <== NOT EXECUTED
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
22948: e5940084 ldr r0, [r4, #132] ; 0x84 <== NOT EXECUTED
2294c: ebff8625 bl 41e8 <rtems_bdbuf_release> <== NOT EXECUTED
fs_info->c.state = FAT_CACHE_EMPTY;
if (sc != RTEMS_SUCCESSFUL)
22950: e3500000 cmp r0, #0 <== NOT EXECUTED
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
fs_info->c.state = FAT_CACHE_EMPTY;
22954: e5c48081 strb r8, [r4, #129] ; 0x81 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
22958: 1a00000e bne 22998 <fat_buf_access+0x1b4> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
}
if (op_type == FAT_OP_TYPE_READ)
2295c: e3570001 cmp r7, #1 <== NOT EXECUTED
22960: e2841054 add r1, r4, #84 ; 0x54 <== NOT EXECUTED
22964: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
22968: e2843084 add r3, r4, #132 ; 0x84 <== NOT EXECUTED
2296c: 1a000002 bne 2297c <fat_buf_access+0x198> <== NOT EXECUTED
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
22970: e1a02005 mov r2, r5 <== NOT EXECUTED
22974: ebff8a5b bl 52e8 <rtems_bdbuf_read> <== NOT EXECUTED
22978: ea000001 b 22984 <fat_buf_access+0x1a0> <== NOT EXECUTED
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
2297c: e1a02005 mov r2, r5 <== NOT EXECUTED
22980: ebff8a25 bl 521c <rtems_bdbuf_get> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
22984: 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;
22988: 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;
2298c: 0584507c streq r5, [r4, #124] ; 0x7c <== NOT EXECUTED
fs_info->c.state = FAT_CACHE_ACTUAL;
22990: 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)
22994: 0a000004 beq 229ac <fat_buf_access+0x1c8> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
22998: eb006958 bl 3cf00 <__errno> <== NOT EXECUTED
2299c: e3a03005 mov r3, #5 <== NOT EXECUTED
229a0: e5803000 str r3, [r0] <== NOT EXECUTED
229a4: e3e00000 mvn r0, #0 <== NOT EXECUTED
229a8: ea000002 b 229b8 <fat_buf_access+0x1d4> <== NOT EXECUTED
fs_info->c.blk_num = blk;
fs_info->c.state = FAT_CACHE_ACTUAL;
}
*buf = fs_info->c.buf;
229ac: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED
229b0: e58a3000 str r3, [sl] <== NOT EXECUTED
229b4: e3a00000 mov r0, #0 <== NOT EXECUTED
return RC_OK;
}
229b8: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
000226a4 <fat_buf_release>:
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
226a4: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
226a8: 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)
226ac: e5d00081 ldrb r0, [r0, #129] ; 0x81 <== NOT EXECUTED
226b0: e3500000 cmp r0, #0 <== NOT EXECUTED
226b4: 0a000047 beq 227d8 <fat_buf_release+0x134> <== NOT EXECUTED
return RC_OK;
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
226b8: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
226bc: e1d421b4 ldrh r2, [r4, #20] <== NOT EXECUTED
226c0: e1530002 cmp r3, r2 <== NOT EXECUTED
226c4: 33a05000 movcc r5, #0 <== NOT EXECUTED
226c8: 3a000003 bcc 226dc <fat_buf_release+0x38> <== NOT EXECUTED
226cc: e594501c ldr r5, [r4, #28] <== NOT EXECUTED
226d0: e1530005 cmp r3, r5 <== NOT EXECUTED
226d4: 23a05000 movcs r5, #0 <== NOT EXECUTED
226d8: 33a05001 movcc r5, #1 <== NOT EXECUTED
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.modified)
226dc: e5d43080 ldrb r3, [r4, #128] ; 0x80 <== NOT EXECUTED
226e0: e3530000 cmp r3, #0 <== NOT EXECUTED
226e4: 0a000032 beq 227b4 <fat_buf_release+0x110> <== NOT EXECUTED
{
if (sec_of_fat && !fs_info->vol.mirror)
226e8: e21550ff ands r5, r5, #255 ; 0xff <== NOT EXECUTED
226ec: 0a000006 beq 2270c <fat_buf_release+0x68> <== NOT EXECUTED
226f0: e5d43048 ldrb r3, [r4, #72] ; 0x48 <== NOT EXECUTED
226f4: e3530000 cmp r3, #0 <== NOT EXECUTED
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
226f8: 05943084 ldreq r3, [r4, #132] ; 0x84 <== NOT EXECUTED
226fc: 05940088 ldreq r0, [r4, #136] ; 0x88 <== NOT EXECUTED
22700: 05931020 ldreq r1, [r3, #32] <== NOT EXECUTED
22704: 01d420b0 ldrheq r2, [r4] <== NOT EXECUTED
22708: 0b0076ac bleq 401c0 <memcpy> <== NOT EXECUTED
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
2270c: e5940084 ldr r0, [r4, #132] ; 0x84 <== NOT EXECUTED
22710: ebff8692 bl 4160 <rtems_bdbuf_release_modified> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
22714: e3500000 cmp r0, #0 <== NOT EXECUTED
22718: 1a000029 bne 227c4 <fat_buf_release+0x120> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.modified = 0;
if (sec_of_fat && !fs_info->vol.mirror)
2271c: 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;
22720: e5c40080 strb r0, [r4, #128] ; 0x80 <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
22724: 0a000029 beq 227d0 <fat_buf_release+0x12c> <== NOT EXECUTED
22728: e5d43048 ldrb r3, [r4, #72] ; 0x48 <== NOT EXECUTED
2272c: e3530000 cmp r3, #0 <== NOT EXECUTED
22730: 03a05001 moveq r5, #1 <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
22734: 01a0600d moveq r6, sp <== NOT EXECUTED
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;
if (sec_of_fat && !fs_info->vol.mirror)
22738: 0a000018 beq 227a0 <fat_buf_release+0xfc> <== NOT EXECUTED
2273c: ea000023 b 227d0 <fat_buf_release+0x12c> <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
22740: e5941018 ldr r1, [r4, #24] <== NOT EXECUTED
22744: e594207c ldr r2, [r4, #124] ; 0x7c <== NOT EXECUTED
22748: e0222591 mla r2, r1, r5, r2 <== NOT EXECUTED
2274c: e2841054 add r1, r4, #84 ; 0x54 <== NOT EXECUTED
22750: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
22754: ebff8ab0 bl 521c <rtems_bdbuf_get> <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
22758: e3500000 cmp r0, #0 <== NOT EXECUTED
2275c: 0a000004 beq 22774 <fat_buf_release+0xd0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
22760: eb0069e6 bl 3cf00 <__errno> <== NOT EXECUTED
22764: e3a0300c mov r3, #12 <== NOT EXECUTED
22768: e5803000 str r3, [r0] <== NOT EXECUTED
2276c: e3e00000 mvn r0, #0 <== NOT EXECUTED
22770: ea000018 b 227d8 <fat_buf_release+0x134> <== NOT EXECUTED
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
22774: e59d3000 ldr r3, [sp] <== NOT EXECUTED
22778: e5941088 ldr r1, [r4, #136] ; 0x88 <== NOT EXECUTED
2277c: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED
22780: e1d420b0 ldrh r2, [r4] <== NOT EXECUTED
22784: eb00768d bl 401c0 <memcpy> <== NOT EXECUTED
sc = rtems_bdbuf_release_modified(b);
22788: e59d0000 ldr r0, [sp] <== NOT EXECUTED
2278c: ebff8673 bl 4160 <rtems_bdbuf_release_modified> <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL)
22790: e3500000 cmp r0, #0 <== NOT EXECUTED
22794: 1afffff1 bne 22760 <fat_buf_release+0xbc> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
22798: e2855001 add r5, r5, #1 <== NOT EXECUTED
2279c: e20550ff and r5, r5, #255 ; 0xff <== NOT EXECUTED
227a0: e5d42009 ldrb r2, [r4, #9] <== NOT EXECUTED
227a4: e1520005 cmp r2, r5 <== NOT EXECUTED
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
227a8: e1a0300d mov r3, sp <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
227ac: 8affffe3 bhi 22740 <fat_buf_release+0x9c> <== NOT EXECUTED
227b0: ea000006 b 227d0 <fat_buf_release+0x12c> <== NOT EXECUTED
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
227b4: e5940084 ldr r0, [r4, #132] ; 0x84 <== NOT EXECUTED
227b8: ebff868a bl 41e8 <rtems_bdbuf_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
227bc: e3500000 cmp r0, #0 <== NOT EXECUTED
227c0: 0a000002 beq 227d0 <fat_buf_release+0x12c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
227c4: eb0069cd bl 3cf00 <__errno> <== NOT EXECUTED
227c8: e3a03005 mov r3, #5 <== NOT EXECUTED
227cc: eaffffe5 b 22768 <fat_buf_release+0xc4> <== NOT EXECUTED
}
fs_info->c.state = FAT_CACHE_EMPTY;
227d0: e3a00000 mov r0, #0 <== NOT EXECUTED
227d4: e5c40081 strb r0, [r4, #129] ; 0x81 <== NOT EXECUTED
return RC_OK;
}
227d8: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
00023328 <fat_cluster_read>:
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)) )
23328: e2513000 subs r3, r1, #0 <== NOT EXECUTED
fat_cluster_read(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
void *buff
)
{
2332c: e1a0c002 mov ip, r2 <== NOT EXECUTED
23330: e92d4001 push {r0, lr} <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
23334: e5902034 ldr r2, [r0, #52] ; 0x34 <== NOT EXECUTED
23338: 1a000003 bne 2334c <fat_cluster_read+0x24> <== NOT EXECUTED
2333c: e5d2100a ldrb r1, [r2, #10] <== NOT EXECUTED
23340: e3110003 tst r1, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
23344: 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)) )
23348: 1a000003 bne 2335c <fat_cluster_read+0x34> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2334c: e5d21005 ldrb r1, [r2, #5] <== NOT EXECUTED
23350: e592e030 ldr lr, [r2, #48] ; 0x30 <== NOT EXECUTED
23354: e2433002 sub r3, r3, #2 <== NOT EXECUTED
23358: 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,
2335c: e5d23002 ldrb r3, [r2, #2] <== NOT EXECUTED
23360: e5d22004 ldrb r2, [r2, #4] <== NOT EXECUTED
23364: e1a03312 lsl r3, r2, r3 <== NOT EXECUTED
23368: e3a02000 mov r2, #0 <== NOT EXECUTED
2336c: e58dc000 str ip, [sp] <== NOT EXECUTED
23370: ebfffe4c bl 22ca8 <_fat_block_read> <== NOT EXECUTED
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
}
23374: e8bd8008 pop {r3, pc} <== NOT EXECUTED
00022bb0 <fat_cluster_write>:
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)) )
22bb0: e2513000 subs r3, r1, #0 <== NOT EXECUTED
fat_cluster_write(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
const void *buff
)
{
22bb4: e1a0c002 mov ip, r2 <== NOT EXECUTED
22bb8: e92d4001 push {r0, lr} <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
22bbc: e5902034 ldr r2, [r0, #52] ; 0x34 <== NOT EXECUTED
22bc0: 1a000003 bne 22bd4 <fat_cluster_write+0x24> <== NOT EXECUTED
22bc4: e5d2100a ldrb r1, [r2, #10] <== NOT EXECUTED
22bc8: e3110003 tst r1, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
22bcc: 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)) )
22bd0: 1a000003 bne 22be4 <fat_cluster_write+0x34> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
22bd4: e5d21005 ldrb r1, [r2, #5] <== NOT EXECUTED
22bd8: e592e030 ldr lr, [r2, #48] ; 0x30 <== NOT EXECUTED
22bdc: e2433002 sub r3, r3, #2 <== NOT EXECUTED
22be0: 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,
22be4: e5d23002 ldrb r3, [r2, #2] <== NOT EXECUTED
22be8: e5d22004 ldrb r2, [r2, #4] <== NOT EXECUTED
22bec: e1a03312 lsl r3, r2, r3 <== NOT EXECUTED
22bf0: e3a02000 mov r2, #0 <== NOT EXECUTED
22bf4: e58dc000 str ip, [sp] <== NOT EXECUTED
22bf8: ebffff6f bl 229bc <_fat_block_write> <== NOT EXECUTED
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
}
22bfc: e8bd8008 pop {r3, pc} <== NOT EXECUTED
00022a6c <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
)
{
22a6c: e92d4077 push {r0, r1, r2, r4, r5, r6, lr} <== NOT EXECUTED
ssize_t ret1 = 0, ret2 = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
22a70: 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,
22a74: e1d533bc ldrh r3, [r5, #60] ; 0x3c <== NOT EXECUTED
22a78: 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);
22a7c: e58d1008 str r1, [sp, #8] <== NOT EXECUTED
le_next_free = CT_LE_L(next_free);
22a80: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
ret1 = _fat_block_write(mt_entry,
22a84: e1a01003 mov r1, r3 <== NOT EXECUTED
22a88: e3a02f7a mov r2, #488 ; 0x1e8 <== NOT EXECUTED
22a8c: 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
)
{
22a90: 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,
22a94: e58dc000 str ip, [sp] <== NOT EXECUTED
22a98: ebffffc7 bl 229bc <_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,
22a9c: e3a03004 mov r3, #4 <== NOT EXECUTED
22aa0: e1d513bc ldrh r1, [r5, #60] ; 0x3c <== NOT EXECUTED
22aa4: 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,
22aa8: 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,
22aac: e3a02f7b mov r2, #492 ; 0x1ec <== NOT EXECUTED
22ab0: e1a00004 mov r0, r4 <== NOT EXECUTED
22ab4: e58dc000 str ip, [sp] <== NOT EXECUTED
22ab8: ebffffbf bl 229bc <_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) )
22abc: e1a06fa6 lsr r6, r6, #31 <== NOT EXECUTED
22ac0: e1960fa0 orrs r0, r6, r0, lsr #31 <== NOT EXECUTED
return -1;
return RC_OK;
}
22ac4: 13e00000 mvnne r0, #0 <== NOT EXECUTED
22ac8: e8bd807e pop {r1, r2, r3, r4, r5, r6, pc} <== NOT EXECUTED
000222b8 <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)
222b8: e5913008 ldr r3, [r1, #8] <== NOT EXECUTED
222bc: e3530001 cmp r3, #1 <== NOT EXECUTED
int
fat_file_close(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
222c0: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
222c4: e1a04001 mov r4, r1 <== NOT EXECUTED
222c8: e1a05000 mov r5, r0 <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
222cc: e5906034 ldr r6, [r0, #52] ; 0x34 <== 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)
222d0: 9a000003 bls 222e4 <fat_file_close+0x2c> <== NOT EXECUTED
{
fat_fd->links_num--;
222d4: e2433001 sub r3, r3, #1 <== NOT EXECUTED
222d8: e5813008 str r3, [r1, #8] <== NOT EXECUTED
222dc: e3a00000 mov r0, #0 <== NOT EXECUTED
return rc;
222e0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
}
key = fat_construct_key(mt_entry, &fat_fd->dir_pos.sname);
if (fat_fd->flags & FAT_FILE_REMOVED)
222e4: e5d17030 ldrb r7, [r1, #48] ; 0x30 <== NOT EXECUTED
222e8: e2177001 ands r7, r7, #1 <== NOT EXECUTED
222ec: 0a00000e beq 2232c <fat_file_close+0x74> <== NOT EXECUTED
{
rc = fat_file_truncate(mt_entry, fat_fd, 0);
222f0: e3a02000 mov r2, #0 <== NOT EXECUTED
222f4: ebfffe36 bl 21bd4 <fat_file_truncate> <== NOT EXECUTED
if ( rc != RC_OK )
222f8: e3500000 cmp r0, #0 <== NOT EXECUTED
222fc: 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 );
22300: e1a00004 mov r0, r4 <== NOT EXECUTED
22304: ebffa84d bl c440 <_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) )
22308: e1a00005 mov r0, r5 <== NOT EXECUTED
2230c: e594100c ldr r1, [r4, #12] <== NOT EXECUTED
22310: eb0000af bl 225d4 <fat_ino_is_unique> <== NOT EXECUTED
22314: e3500000 cmp r0, #0 <== NOT EXECUTED
22318: 0a00000a beq 22348 <fat_file_close+0x90> <== NOT EXECUTED
fat_free_unique_ino(mt_entry, fat_fd->ino);
2231c: e1a00005 mov r0, r5 <== NOT EXECUTED
22320: e594100c ldr r1, [r4, #12] <== NOT EXECUTED
22324: eb0000a0 bl 225ac <fat_free_unique_ino> <== NOT EXECUTED
22328: ea000006 b 22348 <fat_file_close+0x90> <== NOT EXECUTED
free(fat_fd);
}
else
{
if (fat_ino_is_unique(mt_entry, fat_fd->ino))
2232c: e591100c ldr r1, [r1, #12] <== NOT EXECUTED
22330: eb0000a7 bl 225d4 <fat_ino_is_unique> <== NOT EXECUTED
22334: e3500000 cmp r0, #0 <== NOT EXECUTED
{
fat_fd->links_num = 0;
22338: 15847008 strne r7, [r4, #8] <== NOT EXECUTED
free(fat_fd);
}
else
{
if (fat_ino_is_unique(mt_entry, fat_fd->ino))
2233c: 1a000003 bne 22350 <fat_file_close+0x98> <== NOT EXECUTED
22340: e1a00004 mov r0, r4 <== NOT EXECUTED
22344: ebffa83d bl c440 <_Chain_Extract> <== NOT EXECUTED
fat_fd->links_num = 0;
}
else
{
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
free(fat_fd);
22348: e1a00004 mov r0, r4 <== NOT EXECUTED
2234c: ebff94d8 bl 76b4 <free> <== NOT EXECUTED
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
22350: e1a00006 mov r0, r6 <== NOT EXECUTED
return rc;
}
22354: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
22358: ea0000d1 b 226a4 <fat_buf_release> <== NOT EXECUTED
000219d0 <fat_file_datasync>:
int
fat_file_datasync(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
219d0: e92d47f3 push {r0, r1, 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)
219d4: e5914018 ldr r4, [r1, #24] <== NOT EXECUTED
219d8: e3540000 cmp r4, #0 <== NOT EXECUTED
int
fat_file_datasync(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
219dc: e1a07000 mov r7, r0 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_fs_info_t *fs_info = mt_entry->fs_info;
219e0: e5905034 ldr r5, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t cur_cln = fat_fd->cln;
219e4: e591301c ldr r3, [r1, #28] <== NOT EXECUTED
rtems_bdbuf_buffer *block = NULL;
uint32_t sec = 0;
uint32_t i = 0;
if (fat_fd->fat_file_size == 0)
219e8: 0a000036 beq 21ac8 <fat_file_datasync+0xf8> <== 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;
219ec: e3a02000 mov r2, #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);
219f0: 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;
219f4: e88d000c stm sp, {r2, r3} <== 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);
219f8: eb000329 bl 226a4 <fat_buf_release> <== NOT EXECUTED
if (rc != RC_OK)
219fc: e2504000 subs r4, r0, #0 <== 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++ )
{
/* ... sync it */
sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
21a00: 01a0a00d moveq sl, 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);
21a04: 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)
21a08: 0a000028 beq 21ab0 <fat_file_datasync+0xe0> <== NOT EXECUTED
21a0c: ea00002d b 21ac8 <fat_file_datasync+0xf8> <== 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)) )
21a10: e3530000 cmp r3, #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;
21a14: e5972034 ldr r2, [r7, #52] ; 0x34 <== NOT EXECUTED
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
21a18: 1a000003 bne 21a2c <fat_file_datasync+0x5c> <== NOT EXECUTED
21a1c: e5d2100a ldrb r1, [r2, #10] <== NOT EXECUTED
21a20: e3110003 tst r1, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
21a24: 1592801c ldrne r8, [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)) )
21a28: 1a000003 bne 21a3c <fat_file_datasync+0x6c> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
21a2c: e5921030 ldr r1, [r2, #48] ; 0x30 <== NOT EXECUTED
21a30: e5d22005 ldrb r2, [r2, #5] <== NOT EXECUTED
21a34: e2438002 sub r8, r3, #2 <== NOT EXECUTED
21a38: e0818218 add r8, r1, r8, lsl r2 <== NOT EXECUTED
21a3c: e3a06000 mov r6, #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++ )
21a40: ea00000e b 21a80 <fat_file_datasync+0xb0> <== NOT EXECUTED
{
/* ... sync it */
sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
21a44: e2851054 add r1, r5, #84 ; 0x54 <== NOT EXECUTED
21a48: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
21a4c: ebff8e25 bl 52e8 <rtems_bdbuf_read> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
21a50: e3500000 cmp r0, #0 <== NOT EXECUTED
21a54: 1a000003 bne 21a68 <fat_file_datasync+0x98> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
sc = rtems_bdbuf_sync(block);
21a58: e59d0000 ldr r0, [sp] <== NOT EXECUTED
21a5c: ebff8c16 bl 4abc <rtems_bdbuf_sync> <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL )
21a60: e3500000 cmp r0, #0 <== NOT EXECUTED
21a64: 0a000004 beq 21a7c <fat_file_datasync+0xac> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
21a68: eb006d24 bl 3cf00 <__errno> <== NOT EXECUTED
21a6c: e3a03005 mov r3, #5 <== NOT EXECUTED
21a70: e5803000 str r3, [r0] <== NOT EXECUTED
21a74: e3e04000 mvn r4, #0 <== NOT EXECUTED
21a78: ea000012 b 21ac8 <fat_file_datasync+0xf8> <== 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++ )
21a7c: e2866001 add r6, r6, #1 <== NOT EXECUTED
21a80: e5d51004 ldrb r1, [r5, #4] <== NOT EXECUTED
21a84: e1560001 cmp r6, r1 <== NOT EXECUTED
{
/* ... sync it */
sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
21a88: e0862008 add r2, r6, r8 <== NOT EXECUTED
21a8c: e1a0300a mov r3, sl <== 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++ )
21a90: 3affffeb bcc 21a44 <fat_file_datasync+0x74> <== 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);
21a94: e1a00007 mov r0, r7 <== NOT EXECUTED
21a98: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
21a9c: e1a02009 mov r2, r9 <== NOT EXECUTED
21aa0: eb005e1c bl 39318 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
21aa4: e3500000 cmp r0, #0 <== NOT EXECUTED
21aa8: 11a04000 movne r4, r0 <== NOT EXECUTED
21aac: 1a000005 bne 21ac8 <fat_file_datasync+0xf8> <== 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)
21ab0: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
21ab4: e285100c add r1, r5, #12 <== NOT EXECUTED
21ab8: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
21abc: e0031001 and r1, r3, r1 <== NOT EXECUTED
21ac0: e1510002 cmp r1, r2 <== NOT EXECUTED
21ac4: 3affffd1 bcc 21a10 <fat_file_datasync+0x40> <== NOT EXECUTED
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
if ( rc != RC_OK )
return rc;
}
return rc;
}
21ac8: e1a00004 mov r0, r4 <== NOT EXECUTED
21acc: e8bd87fc pop {r2, r3, r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
00021ccc <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
)
{
21ccc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
21cd0: e1a0b003 mov fp, 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;
21cd4: e58b2000 str r2, [fp] <== NOT EXECUTED
if (new_length <= fat_fd->fat_file_size)
21cd8: e5919018 ldr r9, [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
)
{
21cdc: 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;
21ce0: 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)
21ce4: e1520009 cmp r2, r9 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length,
uint32_t *a_length
)
{
21ce8: e1a07002 mov r7, r2 <== NOT EXECUTED
21cec: e1a04001 mov r4, r1 <== NOT EXECUTED
21cf0: e1a05000 mov r5, 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;
21cf4: 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;
21cf8: 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;
21cfc: e5906034 ldr r6, [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)
21d00: 9a000061 bls 21e8c <fat_file_extend+0x1c0> <== NOT EXECUTED
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
21d04: e5913020 ldr r3, [r1, #32] <== NOT EXECUTED
21d08: e3530001 cmp r3, #1 <== NOT EXECUTED
21d0c: 1a000005 bne 21d28 <fat_file_extend+0x5c> <== NOT EXECUTED
21d10: e5913024 ldr r3, [r1, #36] ; 0x24 <== NOT EXECUTED
21d14: e3530000 cmp r3, #0 <== NOT EXECUTED
21d18: 1a000002 bne 21d28 <fat_file_extend+0x5c> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
21d1c: e5d6300a ldrb r3, [r6, #10] <== NOT EXECUTED
21d20: e3130003 tst r3, #3 <== NOT EXECUTED
21d24: 1a00001a bne 21d94 <fat_file_extend+0xc8> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
21d28: e1d620b6 ldrh r2, [r6, #6] <== NOT EXECUTED
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
21d2c: 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 -
21d30: e0038009 and r8, r3, r9 <== NOT EXECUTED
21d34: e0688002 rsb r8, r8, r2 <== NOT EXECUTED
21d38: e0088003 and r8, r8, 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;
21d3c: e0699007 rsb r9, r9, r7 <== NOT EXECUTED
if (bytes2add > bytes_remain)
21d40: e1590008 cmp r9, r8 <== NOT EXECUTED
21d44: 9a000050 bls 21e8c <fat_file_extend+0x1c0> <== 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)
21d48: e0599008 subs r9, r9, r8 <== NOT EXECUTED
21d4c: 0a00004e beq 21e8c <fat_file_extend+0x1c0> <== NOT EXECUTED
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
21d50: e5d63008 ldrb r3, [r6, #8] <== NOT EXECUTED
21d54: e249a001 sub sl, r9, #1 <== NOT EXECUTED
21d58: e1a0a33a lsr sl, sl, r3 <== NOT EXECUTED
21d5c: e28aa001 add sl, sl, #1 <== NOT EXECUTED
rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
21d60: e28dc008 add ip, sp, #8 <== NOT EXECUTED
21d64: e1a00005 mov r0, r5 <== NOT EXECUTED
21d68: e28d1010 add r1, sp, #16 <== NOT EXECUTED
21d6c: e1a0200a mov r2, sl <== NOT EXECUTED
21d70: e28d3004 add r3, sp, #4 <== NOT EXECUTED
21d74: e58dc000 str ip, [sp] <== NOT EXECUTED
21d78: eb005def bl 3953c <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)
21d7c: e3500000 cmp r0, #0 <== NOT EXECUTED
21d80: 11a08000 movne r8, r0 <== NOT EXECUTED
21d84: 1a000041 bne 21e90 <fat_file_extend+0x1c4> <== NOT EXECUTED
return rc;
/* this means that no space left on device */
if ((cls_added == 0) && (bytes_remain == 0))
21d88: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
21d8c: e1988003 orrs r8, r8, r3 <== NOT EXECUTED
21d90: 1a000004 bne 21da8 <fat_file_extend+0xdc> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
21d94: eb006c59 bl 3cf00 <__errno> <== NOT EXECUTED
21d98: e3a0301c mov r3, #28 <== NOT EXECUTED
21d9c: e5803000 str r3, [r0] <== NOT EXECUTED
21da0: e3e08000 mvn r8, #0 <== NOT EXECUTED
21da4: ea000039 b 21e90 <fat_file_extend+0x1c4> <== NOT EXECUTED
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
21da8: e15a0003 cmp sl, r3 <== NOT EXECUTED
21dac: 0a000008 beq 21dd4 <fat_file_extend+0x108> <== NOT EXECUTED
*a_length = new_length -
21db0: e1e03003 mvn r3, r3 <== NOT EXECUTED
21db4: e5d62008 ldrb r2, [r6, #8] <== NOT EXECUTED
21db8: e083a00a add sl, r3, sl <== NOT EXECUTED
21dbc: e047a21a sub sl, r7, sl, lsl r2 <== NOT EXECUTED
21dc0: e1d630b6 ldrh r3, [r6, #6] <== NOT EXECUTED
21dc4: e2433001 sub r3, r3, #1 <== NOT EXECUTED
21dc8: e0099003 and r9, r9, r3 <== NOT EXECUTED
21dcc: e069900a rsb r9, r9, sl <== NOT EXECUTED
21dd0: e58b9000 str r9, [fp] <== 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 )
21dd4: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED
21dd8: e3530000 cmp r3, #0 <== NOT EXECUTED
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
21ddc: 059d2010 ldreq r2, [sp, #16] <== NOT EXECUTED
fat_fd->map.file_cln = 0;
21de0: 05843034 streq r3, [r4, #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;
21de4: 05842038 streq r2, [r4, #56] ; 0x38 <== NOT EXECUTED
21de8: 0584201c streq r2, [r4, #28] <== NOT EXECUTED
21dec: 0a000014 beq 21e44 <fat_file_extend+0x178> <== NOT EXECUTED
fat_fd->map.file_cln = 0;
}
else
{
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
21df0: e594203c ldr r2, [r4, #60] ; 0x3c <== NOT EXECUTED
21df4: e3720001 cmn r2, #1 <== NOT EXECUTED
{
old_last_cl = fat_fd->map.last_cln;
21df8: 158d200c strne r2, [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)
21dfc: 1a000008 bne 21e24 <fat_file_extend+0x158> <== NOT EXECUTED
{
old_last_cl = fat_fd->map.last_cln;
}
else
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
21e00: e28dc00c add ip, sp, #12 <== NOT EXECUTED
21e04: e2433001 sub r3, r3, #1 <== NOT EXECUTED
21e08: e1a00005 mov r0, r5 <== NOT EXECUTED
21e0c: e1a01004 mov r1, r4 <== NOT EXECUTED
21e10: e3a02001 mov r2, #1 <== NOT EXECUTED
21e14: e58dc000 str ip, [sp] <== NOT EXECUTED
21e18: ebffff3f bl 21b1c <fat_file_ioctl> <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
21e1c: e2508000 subs r8, r0, #0 <== NOT EXECUTED
21e20: 1a000014 bne 21e78 <fat_file_extend+0x1ac> <== NOT EXECUTED
fat_free_fat_clusters_chain(mt_entry, chain);
return rc;
}
}
rc = fat_set_fat_cluster(mt_entry, old_last_cl, chain);
21e24: e1a00005 mov r0, r5 <== NOT EXECUTED
21e28: e28d100c add r1, sp, #12 <== NOT EXECUTED
21e2c: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
21e30: eb005ca0 bl 390b8 <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
21e34: e2508000 subs r8, r0, #0 <== NOT EXECUTED
21e38: 1a00000e bne 21e78 <fat_file_extend+0x1ac> <== NOT EXECUTED
{
fat_free_fat_clusters_chain(mt_entry, chain);
return rc;
}
fat_buf_release(fs_info);
21e3c: e1a00006 mov r0, r6 <== NOT EXECUTED
21e40: eb000217 bl 226a4 <fat_buf_release> <== NOT EXECUTED
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
21e44: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
21e48: e3530000 cmp r3, #0 <== NOT EXECUTED
21e4c: 0a00000d beq 21e88 <fat_file_extend+0x1bc> <== NOT EXECUTED
{
fat_fd->map.last_cln = last_cl;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
21e50: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
21e54: 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;
21e58: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
21e5c: e584303c str r3, [r4, #60] ; 0x3c <== NOT EXECUTED
if (fat_fd->fat_file_type == FAT_DIRECTORY)
21e60: 1a000008 bne 21e88 <fat_file_extend+0x1bc> <== NOT EXECUTED
{
rc = fat_init_clusters_chain(mt_entry, chain);
21e64: e1a00005 mov r0, r5 <== NOT EXECUTED
21e68: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
21e6c: eb000363 bl 22c00 <fat_init_clusters_chain> <== NOT EXECUTED
if ( rc != RC_OK )
21e70: e2508000 subs r8, r0, #0 <== NOT EXECUTED
21e74: 0a000003 beq 21e88 <fat_file_extend+0x1bc> <== NOT EXECUTED
{
fat_free_fat_clusters_chain(mt_entry, chain);
21e78: e1a00005 mov r0, r5 <== NOT EXECUTED
21e7c: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
21e80: eb005d7e bl 39480 <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
21e84: ea000001 b 21e90 <fat_file_extend+0x1c4> <== NOT EXECUTED
}
}
}
fat_fd->fat_file_size = new_length;
21e88: e5847018 str r7, [r4, #24] <== NOT EXECUTED
return RC_OK;
21e8c: e3a08000 mov r8, #0 <== NOT EXECUTED
}
21e90: e1a00008 mov r0, r8 <== NOT EXECUTED
21e94: e28dd014 add sp, sp, #20 <== NOT EXECUTED
21e98: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00021b1c <fat_file_ioctl>:
fat_file_ioctl(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
21b1c: e92d000c push {r2, r3} <== NOT EXECUTED
21b20: e92d4033 push {r0, r1, r4, r5, lr} <== NOT EXECUTED
21b24: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
21b28: e3530001 cmp r3, #1 <== NOT EXECUTED
int cmd,
...)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
21b2c: e3a03000 mov r3, #0 <== NOT EXECUTED
21b30: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
uint32_t cl_start = 0;
uint32_t pos = 0;
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
21b34: e28d3018 add r3, sp, #24 <== NOT EXECUTED
21b38: e58d3000 str r3, [sp] <== NOT EXECUTED
fat_file_fd_t *fat_fd,
int cmd,
...)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
21b3c: e590c034 ldr ip, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
21b40: 1a00001c bne 21bb8 <fat_file_ioctl+0x9c> <== 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 )
21b44: e5913018 ldr r3, [r1, #24] <== NOT EXECUTED
va_start(ap, cmd);
switch (cmd)
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t );
21b48: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED
ret = va_arg(ap, uint32_t *);
/* sanity check */
if ( pos >= fat_fd->fat_file_size )
21b4c: e1520003 cmp r2, r3 <== NOT EXECUTED
switch (cmd)
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t );
ret = va_arg(ap, uint32_t *);
21b50: e28d3020 add r3, sp, #32 <== NOT EXECUTED
21b54: e58d3000 str r3, [sp] <== NOT EXECUTED
21b58: e59d401c ldr r4, [sp, #28] <== NOT EXECUTED
/* sanity check */
if ( pos >= fat_fd->fat_file_size )
21b5c: 3a000002 bcc 21b6c <fat_file_ioctl+0x50> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
21b60: eb006ce6 bl 3cf00 <__errno> <== NOT EXECUTED
21b64: e3a03005 mov r3, #5 <== NOT EXECUTED
21b68: ea000014 b 21bc0 <fat_file_ioctl+0xa4> <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
21b6c: e5913020 ldr r3, [r1, #32] <== NOT EXECUTED
21b70: e3530001 cmp r3, #1 <== NOT EXECUTED
21b74: 1a000007 bne 21b98 <fat_file_ioctl+0x7c> <== NOT EXECUTED
21b78: e5913024 ldr r3, [r1, #36] ; 0x24 <== NOT EXECUTED
21b7c: e3530000 cmp r3, #0 <== NOT EXECUTED
21b80: 1a000004 bne 21b98 <fat_file_ioctl+0x7c> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
21b84: e5dc500a ldrb r5, [ip, #10] <== NOT EXECUTED
21b88: e3150003 tst r5, #3 <== NOT EXECUTED
{
/* cluster 0 (zero) reserved for root dir */
*ret = 0;
21b8c: 15843000 strne r3, [r4] <== NOT EXECUTED
21b90: 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)))
21b94: 1a00000b bne 21bc8 <fat_file_ioctl+0xac> <== 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);
21b98: e5dc3008 ldrb r3, [ip, #8] <== NOT EXECUTED
21b9c: e1a02332 lsr r2, r2, r3 <== NOT EXECUTED
21ba0: e28d3004 add r3, sp, #4 <== NOT EXECUTED
21ba4: ebffff64 bl 2193c <fat_file_lseek> <== NOT EXECUTED
if ( rc != RC_OK )
21ba8: e3500000 cmp r0, #0 <== NOT EXECUTED
return rc;
*ret = cur_cln;
21bac: 059d3004 ldreq r3, [sp, #4] <== NOT EXECUTED
21bb0: 05843000 streq r3, [r4] <== NOT EXECUTED
21bb4: ea000003 b 21bc8 <fat_file_ioctl+0xac> <== NOT EXECUTED
break;
default:
errno = EINVAL;
21bb8: eb006cd0 bl 3cf00 <__errno> <== NOT EXECUTED
21bbc: e3a03016 mov r3, #22 <== NOT EXECUTED
21bc0: e5803000 str r3, [r0] <== NOT EXECUTED
21bc4: e3e00000 mvn r0, #0 <== NOT EXECUTED
rc = -1;
break;
}
return rc;
}
21bc8: e8bd403c pop {r2, r3, r4, r5, lr} <== NOT EXECUTED
21bcc: e28dd008 add sp, sp, #8 <== NOT EXECUTED
21bd0: e12fff1e bx lr <== NOT EXECUTED
0002193c <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
)
{
2193c: e92d47f1 push {r0, r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
21940: e5918034 ldr r8, [r1, #52] ; 0x34 <== NOT EXECUTED
21944: e1520008 cmp r2, r8 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
21948: e1a07003 mov r7, r3 <== NOT EXECUTED
2194c: e1a04001 mov r4, r1 <== NOT EXECUTED
21950: e1a05002 mov r5, r2 <== NOT EXECUTED
21954: e1a09000 mov r9, r0 <== NOT EXECUTED
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
*disk_cln = fat_fd->map.disk_cln;
21958: 05913038 ldreq r3, [r1, #56] ; 0x38 <== NOT EXECUTED
uint32_t *disk_cln
)
{
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
2195c: 0a000015 beq 219b8 <fat_file_lseek+0x7c> <== NOT EXECUTED
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
21960: 85913038 ldrhi r3, [r1, #56] ; 0x38 <== NOT EXECUTED
count = file_cln - fat_fd->map.file_cln;
}
else
{
cur_cln = fat_fd->cln;
21964: 9591301c ldrls r3, [r1, #28] <== NOT EXECUTED
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
21968: 858d3000 strhi r3, [sp] <== NOT EXECUTED
count = file_cln - fat_fd->map.file_cln;
2196c: 80688002 rsbhi r8, r8, r2 <== NOT EXECUTED
}
else
{
cur_cln = fat_fd->cln;
21970: 958d3000 strls r3, [sp] <== NOT EXECUTED
21974: 91a08002 movls r8, r2 <== NOT EXECUTED
21978: e3a06000 mov r6, #0 <== NOT EXECUTED
}
/* skip over the clusters */
for (i = 0; i < count; i++)
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
2197c: e1a0a00d mov sl, sp <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
21980: ea000005 b 2199c <fat_file_lseek+0x60> <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
21984: e59d1000 ldr r1, [sp] <== NOT EXECUTED
21988: eb005e62 bl 39318 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
2198c: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return rc;
21990: 11a04fc3 asrne r4, r3, #31 <== NOT EXECUTED
21994: 1a00000a bne 219c4 <fat_file_lseek+0x88> <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
21998: e2866001 add r6, r6, #1 <== NOT EXECUTED
2199c: e1560008 cmp r6, r8 <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
219a0: e1a00009 mov r0, r9 <== NOT EXECUTED
219a4: e1a0200d mov r2, sp <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
219a8: 3afffff5 bcc 21984 <fat_file_lseek+0x48> <== NOT EXECUTED
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
219ac: e59d3000 ldr r3, [sp] <== NOT EXECUTED
if ( rc != RC_OK )
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
219b0: e5845034 str r5, [r4, #52] ; 0x34 <== NOT EXECUTED
fat_fd->map.disk_cln = cur_cln;
219b4: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
*disk_cln = cur_cln;
219b8: e5873000 str r3, [r7] <== NOT EXECUTED
219bc: e3a04000 mov r4, #0 <== NOT EXECUTED
219c0: e3a03000 mov r3, #0 <== NOT EXECUTED
}
return RC_OK;
}
219c4: e1a01004 mov r1, r4 <== NOT EXECUTED
219c8: e1a00003 mov r0, r3 <== NOT EXECUTED
219cc: e8bd87f8 pop {r3, r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
00021ad0 <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) +
21ad0: e5913020 ldr r3, [r1, #32] <== NOT EXECUTED
uint32_t cln
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
21ad4: 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
)
{
21ad8: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
21adc: e1a04001 mov r4, r1 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
21ae0: e5905034 ldr r5, [r0, #52] ; 0x34 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
21ae4: e5946024 ldr r6, [r4, #36] ; 0x24 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
21ae8: e1a00004 mov r0, r4 <== NOT EXECUTED
21aec: ebffaa53 bl c440 <_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 );
21af0: e1a062a6 lsr r6, r6, #5 <== NOT EXECUTED
21af4: e5953068 ldr r3, [r5, #104] ; 0x68 <== NOT EXECUTED
21af8: e2066001 and r6, r6, #1 <== NOT EXECUTED
21afc: e3a0000c mov r0, #12 <== NOT EXECUTED
21b00: e0203096 mla r0, r6, r0, r3 <== NOT EXECUTED
21b04: e1a01004 mov r1, r4 <== NOT EXECUTED
21b08: ebffaa41 bl c414 <_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;
21b0c: e5d43030 ldrb r3, [r4, #48] ; 0x30 <== NOT EXECUTED
21b10: e3833001 orr r3, r3, #1 <== NOT EXECUTED
21b14: e5c43030 strb r3, [r4, #48] ; 0x30 <== NOT EXECUTED
}
21b18: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
0002235c <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
)
{
2235c: 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) +
22360: e5916000 ldr r6, [r1] <== NOT EXECUTED
uint32_t cln
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
22364: e3560001 cmp r6, #1 <== NOT EXECUTED
22368: e1a08001 mov r8, r1 <== NOT EXECUTED
2236c: e1a0b000 mov fp, r0 <== NOT EXECUTED
22370: e1a0a002 mov sl, r2 <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
22374: e5904034 ldr r4, [r0, #52] ; 0x34 <== NOT EXECUTED
22378: 0a00000b beq 223ac <fat_file_open+0x50> <== 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)) )
2237c: e3560000 cmp r6, #0 <== NOT EXECUTED
22380: 1a000003 bne 22394 <fat_file_open+0x38> <== NOT EXECUTED
22384: e5d4300a ldrb r3, [r4, #10] <== NOT EXECUTED
22388: e3130003 tst r3, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2238c: 1594601c ldrne r6, [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)) )
22390: 1a000003 bne 223a4 <fat_file_open+0x48> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
22394: e5d42005 ldrb r2, [r4, #5] <== NOT EXECUTED
22398: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED
2239c: e2466002 sub r6, r6, #2 <== NOT EXECUTED
223a0: e0836216 add r6, r3, r6, 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) <<
223a4: e5d43003 ldrb r3, [r4, #3] <== NOT EXECUTED
223a8: e1a06316 lsl r6, r6, r3 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
223ac: 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) +
223b0: e1a022a3 lsr r2, r3, #5 <== NOT EXECUTED
223b4: e08664a3 add r6, r6, r3, lsr #9 <== NOT EXECUTED
223b8: e202200f and r2, r2, #15 <== NOT EXECUTED
223bc: e0826206 add r6, r2, r6, 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;
223c0: e2063001 and r3, r6, #1 <== NOT EXECUTED
223c4: e3a0200c mov r2, #12 <== NOT EXECUTED
223c8: e0070392 mul r7, r2, r3 <== NOT EXECUTED
223cc: e5943064 ldr r3, [r4, #100] ; 0x64 <== NOT EXECUTED
223d0: e0830007 add r0, r3, r7 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
223d4: e2800004 add r0, r0, #4 <== NOT EXECUTED
223d8: e7933007 ldr r3, [r3, r7] <== NOT EXECUTED
223dc: ea00001c b 22454 <fat_file_open+0xf8> <== NOT EXECUTED
223e0: e5932020 ldr r2, [r3, #32] <== NOT EXECUTED
uint32_t cln
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
223e4: 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) +
223e8: e242c002 sub ip, r2, #2 <== NOT EXECUTED
uint32_t cln
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
223ec: 0a00000a beq 2241c <fat_file_open+0xc0> <== 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)) )
223f0: e3520000 cmp r2, #0 <== NOT EXECUTED
223f4: 1a000003 bne 22408 <fat_file_open+0xac> <== NOT EXECUTED
223f8: e5d4200a ldrb r2, [r4, #10] <== NOT EXECUTED
223fc: e3120003 tst r2, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
22400: 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)) )
22404: 1a000002 bne 22414 <fat_file_open+0xb8> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
22408: e5d42005 ldrb r2, [r4, #5] <== NOT EXECUTED
2240c: e5941030 ldr r1, [r4, #48] ; 0x30 <== NOT EXECUTED
22410: e081221c add r2, r1, ip, 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) <<
22414: e5d41003 ldrb r1, [r4, #3] <== NOT EXECUTED
22418: e1a02112 lsl r2, r2, r1 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
2241c: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
{
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)
22420: e1a0c2a1 lsr ip, r1, #5 <== NOT EXECUTED
22424: e20cc00f and ip, ip, #15 <== NOT EXECUTED
22428: e08224a1 add r2, r2, r1, lsr #9 <== NOT EXECUTED
2242c: e08c2202 add r2, ip, r2, lsl #4 <== NOT EXECUTED
22430: e1560002 cmp r6, r2 <== NOT EXECUTED
22434: 1a000005 bne 22450 <fat_file_open+0xf4> <== 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++;
22438: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED
2243c: e2822001 add r2, r2, #1 <== NOT EXECUTED
22440: 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;
22444: e58a3000 str r3, [sl] <== NOT EXECUTED
lfat_fd->links_num++;
22448: e3a00000 mov r0, #0 <== NOT EXECUTED
return rc;
2244c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
22450: 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) ; )
22454: e1530000 cmp r3, r0 <== NOT EXECUTED
22458: 1affffe0 bne 223e0 <fat_file_open+0x84> <== NOT EXECUTED
2245c: ea00004d b 22598 <fat_file_open+0x23c> <== 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) +
22460: e5932020 ldr r2, [r3, #32] <== NOT EXECUTED
uint32_t cln
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
22464: e3520001 cmp r2, #1 <== NOT EXECUTED
22468: 0a00000b beq 2249c <fat_file_open+0x140> <== 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)) )
2246c: e3520000 cmp r2, #0 <== NOT EXECUTED
22470: 1a000003 bne 22484 <fat_file_open+0x128> <== NOT EXECUTED
22474: e5d4100a ldrb r1, [r4, #10] <== NOT EXECUTED
22478: e3110003 tst r1, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2247c: 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)) )
22480: 1a000003 bne 22494 <fat_file_open+0x138> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
22484: e5d4c005 ldrb ip, [r4, #5] <== NOT EXECUTED
22488: e5941030 ldr r1, [r4, #48] ; 0x30 <== NOT EXECUTED
2248c: e2422002 sub r2, r2, #2 <== NOT EXECUTED
22490: e0812c12 add r2, r1, r2, lsl ip <== 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) <<
22494: e5d41003 ldrb r1, [r4, #3] <== NOT EXECUTED
22498: e1a02112 lsl r2, r2, r1 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
2249c: 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)
224a0: e1a0c2a1 lsr ip, r1, #5 <== NOT EXECUTED
224a4: e08224a1 add r2, r2, r1, lsr #9 <== NOT EXECUTED
224a8: e20cc00f and ip, ip, #15 <== NOT EXECUTED
224ac: e08c2202 add r2, ip, r2, lsl #4 <== NOT EXECUTED
224b0: e1560002 cmp r6, r2 <== NOT EXECUTED
224b4: 1a000004 bne 224cc <fat_file_open+0x170> <== NOT EXECUTED
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
224b8: e3560000 cmp r6, #0 <== NOT EXECUTED
224bc: 0a000007 beq 224e0 <fat_file_open+0x184> <== NOT EXECUTED
224c0: e593200c ldr r2, [r3, #12] <== NOT EXECUTED
224c4: e1560002 cmp r6, r2 <== NOT EXECUTED
224c8: 0a000004 beq 224e0 <fat_file_open+0x184> <== NOT EXECUTED
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
224cc: 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) ; )
224d0: e1530000 cmp r3, r0 <== NOT EXECUTED
224d4: 1affffe1 bne 22460 <fat_file_open+0x104> <== NOT EXECUTED
224d8: e3e09000 mvn r9, #0 <== NOT EXECUTED
224dc: ea000000 b 224e4 <fat_file_open+0x188> <== NOT EXECUTED
224e0: e3a09000 mov r9, #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));
224e4: e3a00044 mov r0, #68 ; 0x44 <== NOT EXECUTED
224e8: ebff9618 bl 7d50 <malloc> <== NOT EXECUTED
if ( lfat_fd == NULL )
224ec: 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));
224f0: e1a05000 mov r5, r0 <== NOT EXECUTED
224f4: e58a0000 str r0, [sl] <== NOT EXECUTED
if ( lfat_fd == NULL )
224f8: 1a000004 bne 22510 <fat_file_open+0x1b4> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
224fc: eb006a7f bl 3cf00 <__errno> <== NOT EXECUTED
22500: e3a0300c mov r3, #12 <== NOT EXECUTED
22504: e5803000 str r3, [r0] <== NOT EXECUTED
22508: e3e00000 mvn r0, #0 <== NOT EXECUTED
2250c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
22510: e3a01000 mov r1, #0 <== NOT EXECUTED
22514: e3a02044 mov r2, #68 ; 0x44 <== NOT EXECUTED
22518: eb0077af bl 403dc <memset> <== NOT EXECUTED
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
2251c: e5d5c030 ldrb ip, [r5, #48] ; 0x30 <== NOT EXECUTED
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
22520: 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;
22524: e3cce001 bic lr, ip, #1 <== NOT EXECUTED
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
22528: e285c020 add ip, r5, #32 <== NOT EXECUTED
if ( rc != RC_OK )
2252c: e3590000 cmp r9, #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;
22530: e3e08000 mvn r8, #0 <== NOT EXECUTED
lfat_fd->dir_pos = *dir_pos;
22534: 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;
22538: e3a03001 mov r3, #1 <== NOT EXECUTED
2253c: e5853008 str r3, [r5, #8] <== NOT EXECUTED
lfat_fd->flags &= ~FAT_FILE_REMOVED;
22540: e5c5e030 strb lr, [r5, #48] ; 0x30 <== NOT EXECUTED
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
22544: e585803c str r8, [r5, #60] ; 0x3c <== NOT EXECUTED
lfat_fd->dir_pos = *dir_pos;
if ( rc != RC_OK )
lfat_fd->ino = key;
22548: 1585600c strne r6, [r5, #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 )
2254c: 1a00000b bne 22580 <fat_file_open+0x224> <== NOT EXECUTED
lfat_fd->ino = key;
else
{
lfat_fd->ino = fat_get_unique_ino(mt_entry);
22550: e1a0000b mov r0, fp <== NOT EXECUTED
22554: eb000024 bl 225ec <fat_get_unique_ino> <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
22558: e3500000 cmp r0, #0 <== NOT EXECUTED
if ( rc != RC_OK )
lfat_fd->ino = key;
else
{
lfat_fd->ino = fat_get_unique_ino(mt_entry);
2255c: e585000c str r0, [r5, #12] <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
22560: 1a000006 bne 22580 <fat_file_open+0x224> <== NOT EXECUTED
{
free((*fat_fd));
22564: e59a0000 ldr r0, [sl] <== NOT EXECUTED
22568: ebff9451 bl 76b4 <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 );
2256c: eb006a63 bl 3cf00 <__errno> <== NOT EXECUTED
22570: e3a0300c mov r3, #12 <== NOT EXECUTED
22574: e5803000 str r3, [r0] <== NOT EXECUTED
22578: e1a00008 mov r0, r8 <== NOT EXECUTED
2257c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== 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 );
22580: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED
22584: e1a01005 mov r1, r5 <== NOT EXECUTED
22588: e0800007 add r0, r0, r7 <== NOT EXECUTED
2258c: ebffa7a0 bl c414 <_Chain_Append> <== NOT EXECUTED
22590: e3a00000 mov r0, #0 <== NOT EXECUTED
* other fields of fat-file descriptor will be initialized on upper
* level
*/
return RC_OK;
}
22594: 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;
22598: e5943068 ldr r3, [r4, #104] ; 0x68 <== NOT EXECUTED
2259c: e0830007 add r0, r3, r7 <== NOT EXECUTED
225a0: e2800004 add r0, r0, #4 <== NOT EXECUTED
225a4: e7933007 ldr r3, [r3, r7] <== NOT EXECUTED
225a8: eaffffc8 b 224d0 <fat_file_open+0x174> <== NOT EXECUTED
000220d0 <fat_file_read>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
220d0: e92d4fff push {r0, r1, r2, r3, 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)
220d4: e2535000 subs r5, r3, #0 <== NOT EXECUTED
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
220d8: e1a08000 mov r8, r0 <== NOT EXECUTED
220dc: e1a06001 mov r6, r1 <== NOT EXECUTED
220e0: e1a07002 mov r7, r2 <== NOT EXECUTED
int rc = RC_OK;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
220e4: e5904034 ldr r4, [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)
220e8: 0a00006d beq 222a4 <fat_file_read+0x1d4> <== NOT EXECUTED
/*
* >= because start is offset and computed from 0 and file_size
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
220ec: e5913018 ldr r3, [r1, #24] <== NOT EXECUTED
220f0: e1520003 cmp r2, r3 <== NOT EXECUTED
220f4: 2a00006a bcs 222a4 <fat_file_read+0x1d4> <== NOT EXECUTED
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
220f8: e1550003 cmp r5, r3 <== NOT EXECUTED
220fc: 8a000002 bhi 2210c <fat_file_read+0x3c> <== NOT EXECUTED
22100: e0652003 rsb r2, r5, r3 <== NOT EXECUTED
22104: e1570002 cmp r7, r2 <== NOT EXECUTED
22108: 9a000000 bls 22110 <fat_file_read+0x40> <== NOT EXECUTED
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
2210c: e0675003 rsb r5, r7, r3 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
22110: e5963020 ldr r3, [r6, #32] <== NOT EXECUTED
22114: 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;
22118: e3a03000 mov r3, #0 <== NOT EXECUTED
2211c: e58d300c str r3, [sp, #12] <== 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)) &&
22120: 1a000019 bne 2218c <fat_file_read+0xbc> <== NOT EXECUTED
22124: e5963024 ldr r3, [r6, #36] ; 0x24 <== NOT EXECUTED
22128: e3530000 cmp r3, #0 <== NOT EXECUTED
2212c: 1a000016 bne 2218c <fat_file_read+0xbc> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
22130: e5d4300a ldrb r3, [r4, #10] <== NOT EXECUTED
22134: e3130003 tst r3, #3 <== NOT EXECUTED
22138: 0a000013 beq 2218c <fat_file_read+0xbc> <== NOT EXECUTED
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
2213c: e596201c ldr r2, [r6, #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)) )
22140: e3520000 cmp r2, #0 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
22144: 15d40005 ldrbne r0, [r4, #5] <== NOT EXECUTED
22148: 15941030 ldrne r1, [r4, #48] ; 0x30 <== NOT EXECUTED
2214c: 12423002 subne r3, r2, #2 <== NOT EXECUTED
22150: 10813013 addne r3, r1, r3, lsl r0 <== 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);
22154: e1d420b0 ldrh r2, [r4] <== 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;
22158: 0594301c ldreq r3, [r4, #28] <== NOT EXECUTED
2215c: e5d41002 ldrb r1, [r4, #2] <== NOT EXECUTED
22160: e59dc034 ldr ip, [sp, #52] ; 0x34 <== NOT EXECUTED
22164: e2422001 sub r2, r2, #1 <== NOT EXECUTED
22168: e0831137 add r1, r3, r7, lsr r1 <== NOT EXECUTED
2216c: e0072002 and r2, r7, r2 <== NOT EXECUTED
22170: e1a00008 mov r0, r8 <== NOT EXECUTED
22174: e1a03005 mov r3, r5 <== NOT EXECUTED
22178: e58dc000 str ip, [sp] <== NOT EXECUTED
2217c: eb0002c9 bl 22ca8 <_fat_block_read> <== NOT EXECUTED
if ( ret < 0 )
22180: e3500000 cmp r0, #0 <== NOT EXECUTED
22184: aa000049 bge 222b0 <fat_file_read+0x1e0> <== NOT EXECUTED
22188: ea000047 b 222ac <fat_file_read+0x1dc> <== NOT EXECUTED
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
2218c: e5d43008 ldrb r3, [r4, #8] <== NOT EXECUTED
22190: e1a03337 lsr r3, r7, r3 <== NOT EXECUTED
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
22194: e28db00c add fp, sp, #12 <== NOT EXECUTED
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
22198: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
2219c: e1a02003 mov r2, r3 <== NOT EXECUTED
221a0: e1a00008 mov r0, r8 <== NOT EXECUTED
221a4: e1a01006 mov r1, r6 <== NOT EXECUTED
221a8: 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);
221ac: e1d4a0b6 ldrh sl, [r4, #6] <== NOT EXECUTED
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
221b0: ebfffde1 bl 2193c <fat_file_lseek> <== NOT EXECUTED
if (rc != RC_OK)
221b4: e3500000 cmp r0, #0 <== NOT EXECUTED
221b8: 1a00003c bne 222b0 <fat_file_read+0x1e0> <== NOT EXECUTED
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
221bc: e24aa001 sub sl, sl, #1 <== NOT EXECUTED
221c0: e007a00a and sl, r7, sl <== NOT EXECUTED
221c4: e58da004 str sl, [sp, #4] <== NOT EXECUTED
221c8: e1a0100a mov r1, sl <== NOT EXECUTED
221cc: e1a09000 mov r9, r0 <== NOT EXECUTED
221d0: e1a0a000 mov sl, r0 <== NOT EXECUTED
221d4: ea000026 b 22274 <fat_file_read+0x1a4> <== NOT EXECUTED
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
221d8: e1d4c0b6 ldrh ip, [r4, #6] <== NOT EXECUTED
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
221dc: e59d700c ldr r7, [sp, #12] <== NOT EXECUTED
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
221e0: e061c00c rsb ip, r1, ip <== NOT EXECUTED
221e4: e15c0005 cmp ip, r5 <== NOT EXECUTED
221e8: 21a0c005 movcs ip, 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)) )
221ec: e3570000 cmp r7, #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;
221f0: e5983034 ldr r3, [r8, #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) +
221f4: e2477002 sub r7, r7, #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)) )
221f8: 1a000003 bne 2220c <fat_file_read+0x13c> <== NOT EXECUTED
221fc: e5d3200a ldrb r2, [r3, #10] <== NOT EXECUTED
22200: e3120003 tst r2, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
22204: 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)) )
22208: 1a000002 bne 22218 <fat_file_read+0x148> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2220c: e5932030 ldr r2, [r3, #48] ; 0x30 <== NOT EXECUTED
22210: e5d33005 ldrb r3, [r3, #5] <== NOT EXECUTED
22214: e0827317 add r7, r2, r7, lsl r3 <== 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);
22218: e1d420b0 ldrh r2, [r4] <== NOT EXECUTED
2221c: e5d49002 ldrb r9, [r4, #2] <== NOT EXECUTED
22220: e59d3034 ldr r3, [sp, #52] ; 0x34 <== NOT EXECUTED
22224: e2422001 sub r2, r2, #1 <== NOT EXECUTED
22228: e083e00a add lr, r3, sl <== NOT EXECUTED
2222c: e0012002 and r2, r1, r2 <== NOT EXECUTED
22230: e1a0300c mov r3, ip <== NOT EXECUTED
22234: e1a00008 mov r0, r8 <== NOT EXECUTED
22238: e0871931 add r1, r7, r1, lsr r9 <== NOT EXECUTED
2223c: e58de000 str lr, [sp] <== NOT EXECUTED
if ( ret < 0 )
return -1;
count -= c;
cmpltd += c;
22240: e08aa00c add sl, sl, ip <== NOT EXECUTED
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
22244: e06c5005 rsb r5, ip, 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_read(mt_entry, sec, byte, c, buf + cmpltd);
22248: eb000296 bl 22ca8 <_fat_block_read> <== NOT EXECUTED
if ( ret < 0 )
2224c: 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);
22250: e1a0200b mov r2, fp <== NOT EXECUTED
22254: e1a00008 mov r0, r8 <== 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 )
22258: ba000013 blt 222ac <fat_file_read+0x1dc> <== NOT EXECUTED
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
2225c: e59d900c ldr r9, [sp, #12] <== NOT EXECUTED
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
22260: e1a01009 mov r1, r9 <== NOT EXECUTED
22264: eb005c2b bl 39318 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
22268: e3500000 cmp r0, #0 <== NOT EXECUTED
2226c: 1a00000f bne 222b0 <fat_file_read+0x1e0> <== NOT EXECUTED
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
cmpltd += c;
22270: e1a01000 mov r1, r0 <== NOT EXECUTED
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
22274: e3550000 cmp r5, #0 <== NOT EXECUTED
22278: 1affffd6 bne 221d8 <fat_file_read+0x108> <== NOT EXECUTED
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
2227c: e59dc004 ldr ip, [sp, #4] <== NOT EXECUTED
22280: e5d43008 ldrb r3, [r4, #8] <== NOT EXECUTED
22284: e24c7001 sub r7, ip, #1 <== NOT EXECUTED
22288: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED
2228c: e087700a add r7, r7, sl <== NOT EXECUTED
22290: e0827337 add r7, r2, r7, lsr r3 <== NOT EXECUTED
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
22294: e5869038 str r9, [r6, #56] ; 0x38 <== NOT EXECUTED
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
22298: e5867034 str r7, [r6, #52] ; 0x34 <== NOT EXECUTED
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
2229c: e1a0000a mov r0, sl <== NOT EXECUTED
222a0: ea000002 b 222b0 <fat_file_read+0x1e0> <== NOT EXECUTED
222a4: e3a00000 mov r0, #0 <== NOT EXECUTED
222a8: ea000000 b 222b0 <fat_file_read+0x1e0> <== NOT EXECUTED
222ac: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
222b0: e28dd010 add sp, sp, #16 <== NOT EXECUTED
222b4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00021884 <fat_file_reopen>:
* RC_OK
*/
int
fat_file_reopen(fat_file_fd_t *fat_fd)
{
fat_fd->links_num++;
21884: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED
21888: e2833001 add r3, r3, #1 <== NOT EXECUTED
2188c: e5803008 str r3, [r0, #8] <== NOT EXECUTED
return RC_OK;
}
21890: e3a00000 mov r0, #0 <== NOT EXECUTED
21894: e12fff1e bx lr <== NOT EXECUTED
00021898 <fat_file_size>:
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)) &&
21898: e5913020 ldr r3, [r1, #32] <== NOT EXECUTED
2189c: e3530001 cmp r3, #1 <== NOT EXECUTED
int
fat_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
218a0: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
218a4: e591301c ldr r3, [r1, #28] <== NOT EXECUTED
int
fat_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
218a8: e1a04001 mov r4, r1 <== NOT EXECUTED
218ac: e1a08000 mov r8, r0 <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
218b0: e5905034 ldr r5, [r0, #52] ; 0x34 <== NOT EXECUTED
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)) &&
218b4: 1a000007 bne 218d8 <fat_file_size+0x40> <== NOT EXECUTED
218b8: e5910024 ldr r0, [r1, #36] ; 0x24 <== NOT EXECUTED
218bc: e3500000 cmp r0, #0 <== NOT EXECUTED
218c0: 1a000004 bne 218d8 <fat_file_size+0x40> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
218c4: e5d5200a ldrb r2, [r5, #10] <== NOT EXECUTED
218c8: e3120003 tst r2, #3 <== NOT EXECUTED
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
218cc: 15953028 ldrne r3, [r5, #40] ; 0x28 <== NOT EXECUTED
218d0: 15813018 strne r3, [r1, #24] <== NOT EXECUTED
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)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
218d4: 1a000017 bne 21938 <fat_file_size+0xa0> <== NOT EXECUTED
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
return rc;
}
fat_fd->fat_file_size = 0;
218d8: e3a0c000 mov ip, #0 <== 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;
218dc: e28d6004 add r6, sp, #4 <== NOT EXECUTED
218e0: e5263004 str r3, [r6, #-4]! <== NOT EXECUTED
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
return rc;
}
fat_fd->fat_file_size = 0;
218e4: e584c018 str ip, [r4, #24] <== NOT EXECUTED
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
218e8: ea000007 b 2190c <fat_file_size+0x74> <== NOT EXECUTED
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
218ec: eb005e89 bl 39318 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
218f0: e3500000 cmp r0, #0 <== NOT EXECUTED
218f4: 1a00000f bne 21938 <fat_file_size+0xa0> <== NOT EXECUTED
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
218f8: e5942018 ldr r2, [r4, #24] <== NOT EXECUTED
218fc: e1d530b6 ldrh r3, [r5, #6] <== NOT EXECUTED
21900: e0823003 add r3, r2, r3 <== NOT EXECUTED
21904: e5843018 str r3, [r4, #24] <== NOT EXECUTED
21908: e1a0c007 mov ip, r7 <== NOT EXECUTED
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
2190c: e59d7000 ldr r7, [sp] <== NOT EXECUTED
21910: e285300c add r3, r5, #12 <== NOT EXECUTED
21914: e8930408 ldm r3, {r3, sl} <== NOT EXECUTED
21918: e0073003 and r3, r7, r3 <== NOT EXECUTED
2191c: e153000a cmp r3, sl <== NOT EXECUTED
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
21920: e1a00008 mov r0, r8 <== NOT EXECUTED
21924: e1a0200d mov r2, sp <== NOT EXECUTED
21928: e1a01007 mov r1, r7 <== NOT EXECUTED
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
2192c: 3affffee bcc 218ec <fat_file_size+0x54> <== NOT EXECUTED
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
21930: e584c03c str ip, [r4, #60] ; 0x3c <== NOT EXECUTED
21934: e3a00000 mov r0, #0 <== NOT EXECUTED
return rc;
}
21938: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
00021bd4 <fat_file_truncate>:
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 )
21bd4: e5913018 ldr r3, [r1, #24] <== NOT EXECUTED
21bd8: e1520003 cmp r2, r3 <== NOT EXECUTED
fat_file_truncate(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
21bdc: e92d4073 push {r0, r1, r4, r5, r6, lr} <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
21be0: e590c034 ldr ip, [r0, #52] ; 0x34 <== NOT EXECUTED
fat_file_truncate(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
21be4: e1a05001 mov r5, r1 <== NOT EXECUTED
21be8: e1a06000 mov r6, r0 <== 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 )
21bec: 2a000030 bcs 21cb4 <fat_file_truncate+0xe0> <== 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;
21bf0: e3a04000 mov r4, #0 <== NOT EXECUTED
21bf4: e58d4004 str r4, [sp, #4] <== NOT EXECUTED
if ( new_length >= fat_fd->fat_file_size )
return rc;
assert(fat_fd->fat_file_size);
21bf8: 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;
21bfc: e3e04000 mvn r4, #0 <== NOT EXECUTED
21c00: e58d4000 str r4, [sp] <== NOT EXECUTED
if ( new_length >= fat_fd->fat_file_size )
return rc;
assert(fat_fd->fat_file_size);
21c04: 059f00b0 ldreq r0, [pc, #176] ; 21cbc <fat_file_truncate+0xe8><== NOT EXECUTED
21c08: 059f10b0 ldreq r1, [pc, #176] ; 21cc0 <fat_file_truncate+0xec><== NOT EXECUTED
21c0c: 059f20b0 ldreq r2, [pc, #176] ; 21cc4 <fat_file_truncate+0xf0><== NOT EXECUTED
21c10: 059f30b0 ldreq r3, [pc, #176] ; 21cc8 <fat_file_truncate+0xf4><== NOT EXECUTED
21c14: 0b000c06 bleq 24c34 <__assert_func> <== NOT EXECUTED
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
21c18: e1dc40b6 ldrh r4, [ip, #6] <== NOT EXECUTED
21c1c: e5dcc008 ldrb ip, [ip, #8] <== NOT EXECUTED
21c20: e2444001 sub r4, r4, #1 <== NOT EXECUTED
21c24: e0844002 add r4, r4, r2 <== NOT EXECUTED
21c28: e1a04c34 lsr r4, r4, ip <== NOT EXECUTED
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
21c2c: e1530c14 cmp r3, r4, lsl ip <== NOT EXECUTED
21c30: 9a00001f bls 21cb4 <fat_file_truncate+0xe0> <== NOT EXECUTED
return RC_OK;
if (cl_start != 0)
21c34: e3540000 cmp r4, #0 <== NOT EXECUTED
21c38: 0a000004 beq 21c50 <fat_file_truncate+0x7c> <== NOT EXECUTED
{
rc = fat_file_lseek(mt_entry, fat_fd, cl_start - 1, &new_last_cln);
21c3c: e2442001 sub r2, r4, #1 <== NOT EXECUTED
21c40: e1a0300d mov r3, sp <== NOT EXECUTED
21c44: ebffff3c bl 2193c <fat_file_lseek> <== NOT EXECUTED
if (rc != RC_OK)
21c48: e3500000 cmp r0, #0 <== NOT EXECUTED
21c4c: 1a000019 bne 21cb8 <fat_file_truncate+0xe4> <== NOT EXECUTED
return rc;
}
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
21c50: e1a00006 mov r0, r6 <== NOT EXECUTED
21c54: e1a01005 mov r1, r5 <== NOT EXECUTED
21c58: e1a02004 mov r2, r4 <== NOT EXECUTED
21c5c: e28d3004 add r3, sp, #4 <== NOT EXECUTED
21c60: ebffff35 bl 2193c <fat_file_lseek> <== NOT EXECUTED
if (rc != RC_OK)
21c64: e3500000 cmp r0, #0 <== NOT EXECUTED
21c68: 1a000012 bne 21cb8 <fat_file_truncate+0xe4> <== NOT EXECUTED
return rc;
rc = fat_free_fat_clusters_chain(mt_entry, cur_cln);
21c6c: e1a00006 mov r0, r6 <== NOT EXECUTED
21c70: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
21c74: eb005e01 bl 39480 <fat_free_fat_clusters_chain> <== NOT EXECUTED
if (rc != RC_OK)
21c78: e3500000 cmp r0, #0 <== NOT EXECUTED
21c7c: 1a00000d bne 21cb8 <fat_file_truncate+0xe4> <== NOT EXECUTED
return rc;
if (cl_start != 0)
21c80: e3540000 cmp r4, #0 <== NOT EXECUTED
21c84: 0a00000b beq 21cb8 <fat_file_truncate+0xe4> <== NOT EXECUTED
{
rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
21c88: e1a00006 mov r0, r6 <== NOT EXECUTED
21c8c: e59d1000 ldr r1, [sp] <== NOT EXECUTED
21c90: e3e02000 mvn r2, #0 <== NOT EXECUTED
21c94: eb005d07 bl 390b8 <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
21c98: e3500000 cmp r0, #0 <== NOT EXECUTED
return rc;
fat_fd->map.file_cln = cl_start - 1;
fat_fd->map.disk_cln = new_last_cln;
21c9c: 059d3000 ldreq 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;
21ca0: 02444001 subeq r4, r4, #1 <== NOT EXECUTED
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
21ca4: 0585303c streq 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;
21ca8: 05854034 streq r4, [r5, #52] ; 0x34 <== NOT EXECUTED
fat_fd->map.disk_cln = new_last_cln;
21cac: 05853038 streq r3, [r5, #56] ; 0x38 <== NOT EXECUTED
21cb0: ea000000 b 21cb8 <fat_file_truncate+0xe4> <== NOT EXECUTED
fat_fd->map.last_cln = new_last_cln;
21cb4: e3a00000 mov r0, #0 <== NOT EXECUTED
}
return RC_OK;
}
21cb8: e8bd807c pop {r2, r3, r4, r5, r6, pc} <== NOT EXECUTED
00021e9c <fat_file_write>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
21e9c: e92d4fff push {r0, r1, r2, r3, 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 )
21ea0: e2534000 subs r4, r3, #0 <== NOT EXECUTED
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
21ea4: e1a06001 mov r6, r1 <== NOT EXECUTED
21ea8: e1a08000 mov r8, r0 <== NOT EXECUTED
21eac: e1a07002 mov r7, r2 <== NOT EXECUTED
int rc = 0;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
21eb0: e5905034 ldr r5, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t save_ofs;
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
if ( count == 0 )
21eb4: 01a01004 moveq r1, r4 <== NOT EXECUTED
21eb8: 0a000081 beq 220c4 <fat_file_write+0x228> <== NOT EXECUTED
return cmpltd;
if ( start > fat_fd->fat_file_size )
21ebc: e5963018 ldr r3, [r6, #24] <== NOT EXECUTED
21ec0: e1520003 cmp r2, r3 <== 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;
21ec4: 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;
21ec8: e58d3008 str r3, [sp, #8] <== 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;
21ecc: e58d300c str r3, [sp, #12] <== NOT EXECUTED
uint32_t c = 0;
if ( count == 0 )
return cmpltd;
if ( start > fat_fd->fat_file_size )
21ed0: 8a000005 bhi 21eec <fat_file_write+0x50> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
if ((count > fat_fd->size_limit) ||
21ed4: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED
21ed8: e1540003 cmp r4, r3 <== NOT EXECUTED
21edc: 8a000002 bhi 21eec <fat_file_write+0x50> <== NOT EXECUTED
21ee0: e0643003 rsb r3, r4, r3 <== NOT EXECUTED
21ee4: e1520003 cmp r2, r3 <== NOT EXECUTED
21ee8: 9a000003 bls 21efc <fat_file_write+0x60> <== NOT EXECUTED
(start > fat_fd->size_limit - count))
rtems_set_errno_and_return_minus_one( EIO );
21eec: eb006c03 bl 3cf00 <__errno> <== NOT EXECUTED
21ef0: e3a03005 mov r3, #5 <== NOT EXECUTED
21ef4: e5803000 str r3, [r0] <== NOT EXECUTED
21ef8: ea000070 b 220c0 <fat_file_write+0x224> <== NOT EXECUTED
rc = fat_file_extend(mt_entry, fat_fd, start + count, &c);
21efc: e084a002 add sl, r4, r2 <== NOT EXECUTED
21f00: e1a0200a mov r2, sl <== NOT EXECUTED
21f04: e28d3008 add r3, sp, #8 <== NOT EXECUTED
21f08: ebffff6f bl 21ccc <fat_file_extend> <== NOT EXECUTED
if (rc != RC_OK)
21f0c: e2501000 subs r1, r0, #0 <== NOT EXECUTED
21f10: 1a00006b bne 220c4 <fat_file_write+0x228> <== NOT EXECUTED
/*
* check whether there was enough room on device to locate
* file of 'start + count' bytes
*/
if (c != (start + count))
21f14: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
21f18: e153000a cmp r3, sl <== NOT EXECUTED
count = c - start;
21f1c: 10674003 rsbne r4, r7, r3 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
21f20: e5963020 ldr r3, [r6, #32] <== NOT EXECUTED
21f24: e3530001 cmp r3, #1 <== NOT EXECUTED
21f28: 1a00001e bne 21fa8 <fat_file_write+0x10c> <== NOT EXECUTED
21f2c: e5963024 ldr r3, [r6, #36] ; 0x24 <== NOT EXECUTED
21f30: e3530000 cmp r3, #0 <== NOT EXECUTED
21f34: 1a00001b bne 21fa8 <fat_file_write+0x10c> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
21f38: e5d5300a ldrb r3, [r5, #10] <== NOT EXECUTED
21f3c: e3130003 tst r3, #3 <== NOT EXECUTED
21f40: 0a000018 beq 21fa8 <fat_file_write+0x10c> <== NOT EXECUTED
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
21f44: e596201c ldr r2, [r6, #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)) )
21f48: 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;
21f4c: e5983034 ldr r3, [r8, #52] ; 0x34 <== NOT EXECUTED
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
21f50: 1a000003 bne 21f64 <fat_file_write+0xc8> <== NOT EXECUTED
21f54: e5d3100a ldrb r1, [r3, #10] <== NOT EXECUTED
21f58: e3110003 tst r1, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
21f5c: 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)) )
21f60: 1a000003 bne 21f74 <fat_file_write+0xd8> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
21f64: e5931030 ldr r1, [r3, #48] ; 0x30 <== NOT EXECUTED
21f68: e5d30005 ldrb r0, [r3, #5] <== NOT EXECUTED
21f6c: e2423002 sub r3, r2, #2 <== NOT EXECUTED
21f70: e0813013 add r3, r1, r3, lsl r0 <== 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);
21f74: e1d520b0 ldrh r2, [r5] <== NOT EXECUTED
21f78: e5d51002 ldrb r1, [r5, #2] <== NOT EXECUTED
21f7c: e59dc034 ldr ip, [sp, #52] ; 0x34 <== NOT EXECUTED
21f80: e2422001 sub r2, r2, #1 <== NOT EXECUTED
21f84: e0831137 add r1, r3, r7, lsr r1 <== NOT EXECUTED
21f88: e0072002 and r2, r7, r2 <== NOT EXECUTED
21f8c: e1a00008 mov r0, r8 <== NOT EXECUTED
21f90: e1a03004 mov r3, r4 <== NOT EXECUTED
21f94: e58dc000 str ip, [sp] <== NOT EXECUTED
21f98: eb000287 bl 229bc <_fat_block_write> <== NOT EXECUTED
if ( ret < 0 )
21f9c: e2501000 subs r1, r0, #0 <== NOT EXECUTED
21fa0: aa000047 bge 220c4 <fat_file_write+0x228> <== NOT EXECUTED
21fa4: ea000045 b 220c0 <fat_file_write+0x224> <== NOT EXECUTED
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
21fa8: e5d53008 ldrb r3, [r5, #8] <== NOT EXECUTED
21fac: e1a03337 lsr r3, r7, r3 <== NOT EXECUTED
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
21fb0: e28da00c add sl, sp, #12 <== NOT EXECUTED
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
21fb4: 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);
21fb8: e1a02003 mov r2, r3 <== NOT EXECUTED
21fbc: e1a00008 mov r0, r8 <== NOT EXECUTED
21fc0: e1a01006 mov r1, r6 <== NOT EXECUTED
21fc4: e1a0300a mov r3, sl <== NOT EXECUTED
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
21fc8: e1d5b0b6 ldrh fp, [r5, #6] <== NOT EXECUTED
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
21fcc: ebfffe5a bl 2193c <fat_file_lseek> <== NOT EXECUTED
if (rc != RC_OK)
21fd0: e3500000 cmp r0, #0 <== 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);
21fd4: e1a01000 mov r1, r0 <== NOT EXECUTED
if (rc != RC_OK)
21fd8: 1a000039 bne 220c4 <fat_file_write+0x228> <== NOT EXECUTED
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
21fdc: e24bb001 sub fp, fp, #1 <== NOT EXECUTED
21fe0: e007b00b and fp, r7, fp <== NOT EXECUTED
21fe4: e1a09000 mov r9, r0 <== NOT EXECUTED
21fe8: e1a0100b mov r1, fp <== NOT EXECUTED
21fec: e1a0a000 mov sl, r0 <== NOT EXECUTED
21ff0: ea000027 b 22094 <fat_file_write+0x1f8> <== NOT EXECUTED
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
21ff4: e1d5c0b6 ldrh ip, [r5, #6] <== NOT EXECUTED
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
21ff8: e59d700c ldr r7, [sp, #12] <== NOT EXECUTED
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
21ffc: e061c00c rsb ip, r1, ip <== NOT EXECUTED
22000: e15c0004 cmp ip, r4 <== NOT EXECUTED
22004: 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)) )
22008: e3570000 cmp r7, #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;
2200c: e5983034 ldr r3, [r8, #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) +
22010: e2477002 sub r7, r7, #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)) )
22014: 1a000003 bne 22028 <fat_file_write+0x18c> <== NOT EXECUTED
22018: e5d3200a ldrb r2, [r3, #10] <== NOT EXECUTED
2201c: e3120003 tst r2, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
22020: 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)) )
22024: 1a000002 bne 22034 <fat_file_write+0x198> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
22028: e5932030 ldr r2, [r3, #48] ; 0x30 <== NOT EXECUTED
2202c: e5d33005 ldrb r3, [r3, #5] <== NOT EXECUTED
22030: e0827317 add r7, r2, r7, lsl r3 <== 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);
22034: e1d520b0 ldrh r2, [r5] <== NOT EXECUTED
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
22038: e5d59002 ldrb r9, [r5, #2] <== NOT EXECUTED
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
2203c: e59d0034 ldr r0, [sp, #52] ; 0x34 <== NOT EXECUTED
{
c = MIN(count, (fs_info->vol.bpc - ofs));
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);
22040: e2422001 sub r2, r2, #1 <== NOT EXECUTED
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
22044: e0012002 and r2, r1, r2 <== NOT EXECUTED
22048: e080e00a add lr, r0, sl <== NOT EXECUTED
2204c: e1a0300c mov r3, ip <== NOT EXECUTED
22050: e1a00008 mov r0, r8 <== NOT EXECUTED
22054: e0871931 add r1, r7, r1, lsr r9 <== NOT EXECUTED
22058: e58de000 str lr, [sp] <== NOT EXECUTED
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
2205c: e58dc008 str ip, [sp, #8] <== 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);
22060: eb000255 bl 229bc <_fat_block_write> <== NOT EXECUTED
if ( ret < 0 )
22064: 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);
22068: e28d200c add r2, sp, #12 <== NOT EXECUTED
2206c: e1a00008 mov r0, r8 <== 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 )
22070: ba000012 blt 220c0 <fat_file_write+0x224> <== NOT EXECUTED
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
22074: e59d900c ldr r9, [sp, #12] <== NOT EXECUTED
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
22078: e1a01009 mov r1, r9 <== NOT EXECUTED
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
2207c: e59d7008 ldr r7, [sp, #8] <== NOT EXECUTED
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
22080: eb005ca4 bl 39318 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
22084: e2501000 subs r1, r0, #0 <== NOT EXECUTED
22088: 1a00000d bne 220c4 <fat_file_write+0x228> <== NOT EXECUTED
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
cmpltd += c;
2208c: e08aa007 add sl, sl, r7 <== NOT EXECUTED
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
22090: e0674004 rsb r4, r7, r4 <== NOT EXECUTED
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
22094: e3540000 cmp r4, #0 <== NOT EXECUTED
22098: 1affffd5 bne 21ff4 <fat_file_write+0x158> <== NOT EXECUTED
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
2209c: e5d53008 ldrb r3, [r5, #8] <== NOT EXECUTED
220a0: e24bb001 sub fp, fp, #1 <== NOT EXECUTED
220a4: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED
220a8: e08bb00a add fp, fp, sl <== NOT EXECUTED
220ac: e082b33b add fp, r2, fp, lsr r3 <== NOT EXECUTED
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
220b0: e5869038 str r9, [r6, #56] ; 0x38 <== NOT EXECUTED
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
220b4: e586b034 str fp, [r6, #52] ; 0x34 <== NOT EXECUTED
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
220b8: e1a0100a mov r1, sl <== NOT EXECUTED
220bc: ea000000 b 220c4 <fat_file_write+0x228> <== NOT EXECUTED
220c0: e3e01000 mvn r1, #0 <== NOT EXECUTED
}
220c4: e1a00001 mov r0, r1 <== NOT EXECUTED
220c8: e28dd010 add sp, sp, #16 <== NOT EXECUTED
220cc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00039480 <fat_free_fat_clusters_chain>:
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
39480: e92d47f1 push {r0, 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;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
39484: e3a03000 mov r3, #0 <== NOT EXECUTED
39488: e28da004 add sl, sp, #4 <== NOT EXECUTED
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
3948c: e1a08000 mov r8, r0 <== NOT EXECUTED
39490: 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;
39494: e1a05003 mov r5, r3 <== NOT EXECUTED
39498: e52a3004 str r3, [sl, #-4]! <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
3949c: e5904034 ldr r4, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
394a0: e1a06001 mov r6, r1 <== NOT EXECUTED
394a4: e1a07003 mov r7, r3 <== NOT EXECUTED
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
394a8: ea000011 b 394f4 <fat_free_fat_clusters_chain+0x74> <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
394ac: ebffff99 bl 39318 <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);
394b0: e1a01006 mov r1, 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 )
394b4: e2506000 subs r6, r0, #0 <== NOT EXECUTED
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
394b8: e1a02006 mov r2, r6 <== NOT EXECUTED
394bc: e1a00008 mov r0, r8 <== 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 )
394c0: 0a000006 beq 394e0 <fat_free_fat_clusters_chain+0x60> <== NOT EXECUTED
{
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
394c4: e5943040 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED
394c8: e3730001 cmn r3, #1 <== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
394cc: 10855003 addne r5, r5, r3 <== NOT EXECUTED
394d0: 15845040 strne r5, [r4, #64] ; 0x40 <== NOT EXECUTED
fat_buf_release(fs_info);
394d4: e1a00004 mov r0, r4 <== NOT EXECUTED
394d8: ebffa471 bl 226a4 <fat_buf_release> <== NOT EXECUTED
return rc;
394dc: ea000014 b 39534 <fat_free_fat_clusters_chain+0xb4> <== NOT EXECUTED
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
394e0: ebfffef4 bl 390b8 <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
rc1 = rc;
freed_cls_cnt++;
cur_cln = next_cln;
394e4: e59d6000 ldr r6, [sp] <== 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 )
394e8: e3500000 cmp r0, #0 <== NOT EXECUTED
394ec: 11a07000 movne r7, r0 <== NOT EXECUTED
rc1 = rc;
freed_cls_cnt++;
394f0: e2855001 add r5, r5, #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)
394f4: e284300c add r3, r4, #12 <== NOT EXECUTED
394f8: e8931008 ldm r3, {r3, ip} <== NOT EXECUTED
394fc: e0063003 and r3, r6, r3 <== NOT EXECUTED
39500: e153000c cmp r3, ip <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
39504: e1a01006 mov r1, r6 <== NOT EXECUTED
39508: e1a0200d mov r2, sp <== NOT EXECUTED
3950c: e1a00008 mov r0, r8 <== 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)
39510: 3affffe5 bcc 394ac <fat_free_fat_clusters_chain+0x2c> <== NOT EXECUTED
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
39514: e5943040 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED
39518: e3730001 cmn r3, #1 <== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
3951c: 10855003 addne r5, r5, r3 <== NOT EXECUTED
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
39520: e5849044 str r9, [r4, #68] ; 0x44 <== NOT EXECUTED
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
fs_info->vol.free_cls += freed_cls_cnt;
39524: 15845040 strne r5, [r4, #64] ; 0x40 <== NOT EXECUTED
fat_buf_release(fs_info);
39528: e1a00004 mov r0, r4 <== NOT EXECUTED
3952c: ebffa45c bl 226a4 <fat_buf_release> <== NOT EXECUTED
39530: e1a06007 mov r6, r7 <== NOT EXECUTED
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
39534: e1a00006 mov r0, r6 <== NOT EXECUTED
39538: e8bd87f8 pop {r3, r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
000225ac <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;
225ac: e5903034 ldr r3, [r0, #52] ; 0x34 <== NOT EXECUTED
FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino);
225b0: e5932078 ldr r2, [r3, #120] ; 0x78 <== NOT EXECUTED
225b4: e593306c ldr r3, [r3, #108] ; 0x6c <== NOT EXECUTED
225b8: e0622001 rsb r2, r2, r1 <== NOT EXECUTED
225bc: e7d301a2 ldrb r0, [r3, r2, lsr #3] <== NOT EXECUTED
225c0: e2021007 and r1, r2, #7 <== NOT EXECUTED
225c4: e3a0c001 mov ip, #1 <== NOT EXECUTED
225c8: e1c0111c bic r1, r0, ip, lsl r1 <== NOT EXECUTED
225cc: e7c311a2 strb r1, [r3, r2, lsr #3] <== NOT EXECUTED
}
225d0: e12fff1e bx lr <== NOT EXECUTED
00039318 <fat_get_fat_cluster>:
fat_get_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t *ret_val
)
{
39318: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
rtems_bdbuf_buffer *block0 = NULL;
3931c: e3a03000 mov r3, #0 <== NOT EXECUTED
uint32_t sec = 0;
uint32_t ofs = 0;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
39320: 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
)
{
39324: e1a04001 mov r4, r1 <== NOT EXECUTED
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
rtems_bdbuf_buffer *block0 = NULL;
39328: 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
)
{
3932c: e1a05002 mov r5, r2 <== NOT EXECUTED
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
39330: e5906034 ldr r6, [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)) )
39334: 9a00004b bls 39468 <fat_get_fat_cluster+0x150> <== NOT EXECUTED
39338: e5963034 ldr r3, [r6, #52] ; 0x34 <== NOT EXECUTED
3933c: e2833001 add r3, r3, #1 <== NOT EXECUTED
39340: e1510003 cmp r1, r3 <== NOT EXECUTED
39344: 8a000047 bhi 39468 <fat_get_fat_cluster+0x150> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
39348: e5d6300a ldrb r3, [r6, #10] <== NOT EXECUTED
3934c: e2130001 ands r0, r3, #1 <== NOT EXECUTED
39350: 108120a1 addne r2, r1, r1, lsr #1 <== NOT EXECUTED
39354: 1a000002 bne 39364 <fat_get_fat_cluster+0x4c> <== NOT EXECUTED
39358: e3130002 tst r3, #2 <== NOT EXECUTED
3935c: 11a02081 lslne r2, r1, #1 <== NOT EXECUTED
39360: 01a02101 lsleq r2, r1, #2 <== NOT EXECUTED
39364: e5d6a002 ldrb sl, [r6, #2] <== NOT EXECUTED
39368: e596104c ldr r1, [r6, #76] ; 0x4c <== NOT EXECUTED
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
3936c: e3500000 cmp r0, #0 <== 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) +
39370: e081aa32 add sl, r1, r2, lsr sl <== NOT EXECUTED
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
39374: 108480a4 addne r8, r4, r4, lsr #1 <== NOT EXECUTED
39378: 1a000002 bne 39388 <fat_get_fat_cluster+0x70> <== NOT EXECUTED
3937c: e3130002 tst r3, #2 <== NOT EXECUTED
39380: 11a08084 lslne r8, r4, #1 <== NOT EXECUTED
39384: 01a08104 lsleq r8, r4, #2 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
39388: e1a00006 mov r0, r6 <== NOT EXECUTED
3938c: e1a0100a mov r1, sl <== NOT EXECUTED
39390: e3a02001 mov r2, #1 <== NOT EXECUTED
39394: 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);
39398: e1d6b0b0 ldrh fp, [r6] <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
3939c: ebffa510 bl 227e4 <fat_buf_access> <== NOT EXECUTED
if (rc != RC_OK)
393a0: e2507000 subs r7, 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);
393a4: e1a0900d mov r9, sp <== NOT EXECUTED
if (rc != RC_OK)
393a8: 1a000032 bne 39478 <fat_get_fat_cluster+0x160> <== NOT EXECUTED
return rc;
switch ( fs_info->vol.type )
393ac: e5d6200a ldrb r2, [r6, #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);
393b0: e24bb001 sub fp, fp, #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 )
393b4: 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);
393b8: e008800b and r8, r8, fp <== 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 )
393bc: 0a000020 beq 39444 <fat_get_fat_cluster+0x12c> <== NOT EXECUTED
393c0: e3520004 cmp r2, #4 <== NOT EXECUTED
393c4: 0a000022 beq 39454 <fat_get_fat_cluster+0x13c> <== NOT EXECUTED
393c8: e3520001 cmp r2, #1 <== NOT EXECUTED
393cc: 1a000025 bne 39468 <fat_get_fat_cluster+0x150> <== 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)));
393d0: e59d3000 ldr r3, [sp] <== NOT EXECUTED
393d4: e593b020 ldr fp, [r3, #32] <== NOT EXECUTED
if ( ofs == (fs_info->vol.bps - 1) )
393d8: e1d610b0 ldrh r1, [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)));
393dc: e7db3008 ldrb r3, [fp, r8] <== NOT EXECUTED
if ( ofs == (fs_info->vol.bps - 1) )
393e0: e2411001 sub r1, r1, #1 <== NOT EXECUTED
393e4: e1580001 cmp r8, r1 <== 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)));
393e8: e5853000 str r3, [r5] <== NOT EXECUTED
*ret_val |= (*((uint8_t *)(block0->buffer)))<<8;
}
else
{
*ret_val |= (*((uint8_t *)(block0->buffer + ofs + 1)))<<8;
393ec: 108b8008 addne r8, fp, r8 <== NOT EXECUTED
393f0: 15d82001 ldrbne r2, [r8, #1] <== NOT EXECUTED
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
if ( ofs == (fs_info->vol.bps - 1) )
393f4: 1a00000a bne 39424 <fat_get_fat_cluster+0x10c> <== NOT EXECUTED
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
393f8: e1a00006 mov r0, r6 <== NOT EXECUTED
393fc: e28a1001 add r1, sl, #1 <== NOT EXECUTED
39400: e1a0300d mov r3, sp <== NOT EXECUTED
39404: ebffa4f6 bl 227e4 <fat_buf_access> <== NOT EXECUTED
&block0);
if (rc != RC_OK)
39408: e3500000 cmp r0, #0 <== NOT EXECUTED
3940c: 11a07000 movne r7, r0 <== NOT EXECUTED
39410: 1a000018 bne 39478 <fat_get_fat_cluster+0x160> <== NOT EXECUTED
return rc;
*ret_val |= (*((uint8_t *)(block0->buffer)))<<8;
39414: e59d3000 ldr r3, [sp] <== NOT EXECUTED
39418: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
3941c: e5d32000 ldrb r2, [r3] <== NOT EXECUTED
39420: e5953000 ldr r3, [r5] <== NOT EXECUTED
}
else
{
*ret_val |= (*((uint8_t *)(block0->buffer + ofs + 1)))<<8;
39424: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
39428: e5853000 str r3, [r5] <== NOT EXECUTED
3942c: e5953000 ldr r3, [r5] <== NOT EXECUTED
}
if ( FAT_CLUSTER_IS_ODD(cln) )
39430: e3140001 tst r4, #1 <== NOT EXECUTED
*ret_val = (*ret_val) >> FAT12_SHIFT;
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
39434: 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;
39438: 11a03223 lsrne r3, r3, #4 <== NOT EXECUTED
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
3943c: 01a03a23 lsreq r3, r3, #20 <== NOT EXECUTED
39440: ea000006 b 39460 <fat_get_fat_cluster+0x148> <== NOT EXECUTED
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
*ret_val = CF_LE_W(*ret_val);
39444: e59d3000 ldr r3, [sp] <== NOT EXECUTED
39448: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
3944c: e19330b8 ldrh r3, [r3, r8] <== NOT EXECUTED
39450: ea000002 b 39460 <fat_get_fat_cluster+0x148> <== NOT EXECUTED
break;
case FAT_FAT32:
*ret_val = *((uint32_t *)(block0->buffer + ofs));
*ret_val = CF_LE_L(*ret_val);
39454: e59d3000 ldr r3, [sp] <== NOT EXECUTED
39458: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
3945c: e7933008 ldr r3, [r3, r8] <== NOT EXECUTED
39460: e5853000 str r3, [r5] <== NOT EXECUTED
break;
39464: ea000003 b 39478 <fat_get_fat_cluster+0x160> <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one(EIO);
39468: eb000ea4 bl 3cf00 <__errno> <== NOT EXECUTED
3946c: e3a03005 mov r3, #5 <== NOT EXECUTED
39470: e5803000 str r3, [r0] <== NOT EXECUTED
39474: e3e07000 mvn r7, #0 <== NOT EXECUTED
break;
}
return RC_OK;
}
39478: e1a00007 mov r0, r7 <== NOT EXECUTED
3947c: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
000225ec <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry)
{
225ec: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
register fat_fs_info_t *fs_info = mt_entry->fs_info;
225f0: e5904034 ldr r4, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
225f4: e3a05000 mov r5, #0 <== NOT EXECUTED
225f8: ea000024 b 22690 <fat_get_unique_ino+0xa4> <== NOT EXECUTED
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
225fc: e5943070 ldr r3, [r4, #112] ; 0x70 <== NOT EXECUTED
22600: e594706c ldr r7, [r4, #108] ; 0x6c <== NOT EXECUTED
22604: e7d701a3 ldrb r0, [r7, r3, lsr #3] <== NOT EXECUTED
22608: e203c007 and ip, r3, #7 <== NOT EXECUTED
2260c: e1a08c50 asr r8, r0, ip <== NOT EXECUTED
22610: e3180001 tst r8, #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++;
22614: e2836001 add r6, r3, #1 <== 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))
22618: e08731a3 add r3, r7, r3, lsr #3 <== NOT EXECUTED
2261c: 1a000006 bne 2263c <fat_get_unique_ino+0x50> <== NOT EXECUTED
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
22620: e3a02001 mov r2, #1 <== NOT EXECUTED
22624: e1800c12 orr r0, r0, r2, lsl ip <== NOT EXECUTED
22628: e5c30000 strb r0, [r3] <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
2262c: e5943078 ldr r3, [r4, #120] ; 0x78 <== NOT EXECUTED
22630: e5940070 ldr r0, [r4, #112] ; 0x70 <== NOT EXECUTED
22634: e0800003 add r0, r0, r3 <== NOT EXECUTED
22638: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
}
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
2263c: e5943074 ldr r3, [r4, #116] ; 0x74 <== NOT EXECUTED
22640: e1560003 cmp r6, r3 <== NOT EXECUTED
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);
}
fs_info->index++;
22644: e5846070 str r6, [r4, #112] ; 0x70 <== NOT EXECUTED
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
22648: 25845070 strcs r5, [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++)
2264c: e2822001 add r2, r2, #1 <== NOT EXECUTED
22650: e1520001 cmp r2, r1 <== NOT EXECUTED
22654: 3affffe8 bcc 225fc <fat_get_unique_ino+0x10> <== 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))
22658: e5942078 ldr r2, [r4, #120] ; 0x78 <== NOT EXECUTED
2265c: e3e0320f mvn r3, #-268435456 ; 0xf0000000 <== NOT EXECUTED
22660: e0623003 rsb r3, r2, r3 <== NOT EXECUTED
22664: e1a01081 lsl r1, r1, #1 <== NOT EXECUTED
22668: e1510003 cmp r1, r3 <== NOT EXECUTED
2266c: 2a00000a bcs 2269c <fat_get_unique_ino+0xb0> <== NOT EXECUTED
{
fs_info->uino_pool_size <<= 1;
22670: e5841074 str r1, [r4, #116] ; 0x74 <== NOT EXECUTED
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
22674: e594006c ldr r0, [r4, #108] ; 0x6c <== NOT EXECUTED
22678: ebff9919 bl 8ae4 <realloc> <== NOT EXECUTED
if (fs_info->uino != NULL)
2267c: 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);
22680: e584006c str r0, [r4, #108] ; 0x6c <== NOT EXECUTED
if (fs_info->uino != NULL)
22684: 0a000004 beq 2269c <fat_get_unique_ino+0xb0> <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
22688: e5943074 ldr r3, [r4, #116] ; 0x74 <== NOT EXECUTED
2268c: e5843070 str r3, [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++)
22690: e5941074 ldr r1, [r4, #116] ; 0x74 <== NOT EXECUTED
22694: e3a02000 mov r2, #0 <== NOT EXECUTED
22698: eaffffec b 22650 <fat_get_unique_ino+0x64> <== NOT EXECUTED
2269c: e3a00000 mov r0, #0 <== NOT EXECUTED
}
else
resrc_unsuff = true;
}
return 0;
}
226a0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00022c00 <fat_init_clusters_chain>:
int
fat_init_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start_cln
)
{
22c00: e92d41f1 push {r0, 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;
22c04: e5905034 ldr r5, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t cur_cln = start_cln;
22c08: e58d1000 str r1, [sp] <== NOT EXECUTED
int
fat_init_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start_cln
)
{
22c0c: e1a06000 mov r6, 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));
22c10: e3a01001 mov r1, #1 <== NOT EXECUTED
22c14: e1d500b6 ldrh r0, [r5, #6] <== NOT EXECUTED
22c18: ebff9135 bl 70f4 <calloc> <== NOT EXECUTED
if ( buf == NULL )
22c1c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
{
free(buf);
return -1;
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
22c20: 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 )
22c24: 1a000011 bne 22c70 <fat_init_clusters_chain+0x70> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
22c28: eb0068b4 bl 3cf00 <__errno> <== NOT EXECUTED
22c2c: e3a03005 mov r3, #5 <== NOT EXECUTED
22c30: e5803000 str r3, [r0] <== NOT EXECUTED
22c34: e3e08000 mvn r8, #0 <== NOT EXECUTED
22c38: ea000018 b 22ca0 <fat_init_clusters_chain+0xa0> <== NOT EXECUTED
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
22c3c: ebffffdb bl 22bb0 <fat_cluster_write> <== NOT EXECUTED
22c40: e1a08000 mov r8, r0 <== NOT EXECUTED
if ( ret == -1 )
22c44: e3780001 cmn r8, #1 <== NOT EXECUTED
{
free(buf);
return -1;
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
22c48: e1a0200d mov r2, sp <== NOT EXECUTED
22c4c: e1a00006 mov r0, r6 <== 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 )
22c50: 0a000003 beq 22c64 <fat_init_clusters_chain+0x64> <== NOT EXECUTED
{
free(buf);
return -1;
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
22c54: e59d1000 ldr r1, [sp] <== NOT EXECUTED
22c58: eb0059ae bl 39318 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
22c5c: e2508000 subs r8, r0, #0 <== NOT EXECUTED
22c60: 0a000002 beq 22c70 <fat_init_clusters_chain+0x70> <== NOT EXECUTED
{
free(buf);
22c64: e1a00004 mov r0, r4 <== NOT EXECUTED
22c68: ebff9291 bl 76b4 <free> <== NOT EXECUTED
return rc;
22c6c: ea00000b b 22ca0 <fat_init_clusters_chain+0xa0> <== 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)
22c70: e59d3000 ldr r3, [sp] <== NOT EXECUTED
22c74: e595e00c ldr lr, [r5, #12] <== NOT EXECUTED
22c78: e595c010 ldr ip, [r5, #16] <== NOT EXECUTED
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
22c7c: 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)
22c80: e003300e and r3, r3, lr <== NOT EXECUTED
22c84: e153000c cmp r3, ip <== NOT EXECUTED
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
22c88: e1a02004 mov r2, r4 <== NOT EXECUTED
22c8c: e1a00006 mov r0, r6 <== 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)
22c90: 3affffe9 bcc 22c3c <fat_init_clusters_chain+0x3c> <== NOT EXECUTED
free(buf);
return rc;
}
}
free(buf);
22c94: e1a00004 mov r0, r4 <== NOT EXECUTED
22c98: ebff9285 bl 76b4 <free> <== NOT EXECUTED
22c9c: e3a08000 mov r8, #0 <== NOT EXECUTED
return rc;
}
22ca0: e1a00008 mov r0, r8 <== NOT EXECUTED
22ca4: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00022d38 <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)
{
22d38: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
22d3c: e24dd0b8 sub sp, sp, #184 ; 0xb8 <== NOT EXECUTED
22d40: 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;
22d44: e3a06000 mov r6, #0 <== NOT EXECUTED
rc = stat(mt_entry->dev, &stat_buf);
22d48: e5900070 ldr r0, [r0, #112] ; 0x70 <== NOT EXECUTED
22d4c: 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;
22d50: 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;
22d54: 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);
22d58: ebff9835 bl 8e34 <stat> <== NOT EXECUTED
if (rc == -1)
22d5c: 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);
22d60: e1a07000 mov r7, r0 <== NOT EXECUTED
if (rc == -1)
22d64: 0a000167 beq 23308 <fat_init_volume_info+0x5d0> <== NOT EXECUTED
return rc;
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
22d68: e59d306c ldr r3, [sp, #108] ; 0x6c <== NOT EXECUTED
22d6c: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
22d70: e3530a06 cmp r3, #24576 ; 0x6000 <== NOT EXECUTED
22d74: 0a000002 beq 22d84 <fat_init_volume_info+0x4c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOTTY);
22d78: eb006860 bl 3cf00 <__errno> <== NOT EXECUTED
22d7c: e3a03019 mov r3, #25 <== NOT EXECUTED
22d80: ea00015e b 23300 <fat_init_volume_info+0x5c8> <== NOT EXECUTED
/* check that device is registred as block device and lock it */
vol->dd = rtems_disk_obtain(stat_buf.st_rdev);
22d84: e28d1078 add r1, sp, #120 ; 0x78 <== NOT EXECUTED
22d88: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
22d8c: ebff8d42 bl 629c <rtems_disk_obtain> <== NOT EXECUTED
if (vol->dd == NULL)
22d90: 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);
22d94: e584005c str r0, [r4, #92] ; 0x5c <== NOT EXECUTED
if (vol->dd == NULL)
22d98: 0a00000a beq 22dc8 <fat_init_volume_info+0x90> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
vol->dev = stat_buf.st_rdev;
22d9c: e28d1078 add r1, sp, #120 ; 0x78 <== NOT EXECUTED
22da0: 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);
22da4: 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;
22da8: e5840054 str r0, [r4, #84] ; 0x54 <== NOT EXECUTED
22dac: 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);
22db0: e28d30b4 add r3, sp, #180 ; 0xb4 <== NOT EXECUTED
22db4: ebff894b bl 52e8 <rtems_bdbuf_read> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
22db8: e3500000 cmp r0, #0 <== NOT EXECUTED
22dbc: 0a000004 beq 22dd4 <fat_init_volume_info+0x9c> <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
22dc0: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED
22dc4: ebff8db0 bl 648c <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO);
22dc8: eb00684c bl 3cf00 <__errno> <== NOT EXECUTED
22dcc: e3a03005 mov r3, #5 <== NOT EXECUTED
22dd0: ea00014a b 23300 <fat_init_volume_info+0x5c8> <== NOT EXECUTED
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
22dd4: e59d30b4 ldr r3, [sp, #180] ; 0xb4 <== NOT EXECUTED
22dd8: e3a0205a mov r2, #90 ; 0x5a <== NOT EXECUTED
22ddc: e5931020 ldr r1, [r3, #32] <== NOT EXECUTED
22de0: e28d0004 add r0, sp, #4 <== NOT EXECUTED
22de4: eb0074f5 bl 401c0 <memcpy> <== NOT EXECUTED
sc = rtems_bdbuf_release( block);
22de8: e59d00b4 ldr r0, [sp, #180] ; 0xb4 <== NOT EXECUTED
22dec: ebff84fd bl 41e8 <rtems_bdbuf_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
22df0: e3500000 cmp r0, #0 <== NOT EXECUTED
22df4: 1afffff1 bne 22dc0 <fat_init_volume_info+0x88> <== 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);
22df8: e5dd2010 ldrb r2, [sp, #16] <== NOT EXECUTED
22dfc: e5dd300f ldrb r3, [sp, #15] <== NOT EXECUTED
22e00: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
if ( (vol->bps != 512) &&
22e04: e3530b01 cmp r3, #1024 ; 0x400 <== NOT EXECUTED
22e08: 13530c02 cmpne r3, #512 ; 0x200 <== 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);
22e0c: e1c430b0 strh r3, [r4] <== NOT EXECUTED
if ( (vol->bps != 512) &&
22e10: 0a000003 beq 22e24 <fat_init_volume_info+0xec> <== NOT EXECUTED
22e14: e3530b02 cmp r3, #2048 ; 0x800 <== NOT EXECUTED
22e18: 0a000001 beq 22e24 <fat_init_volume_info+0xec> <== NOT EXECUTED
22e1c: e3530a01 cmp r3, #4096 ; 0x1000 <== NOT EXECUTED
22e20: 1a0000ad bne 230dc <fat_init_volume_info+0x3a4> <== 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;
22e24: e3a02000 mov r2, #0 <== NOT EXECUTED
22e28: e5c42003 strb r2, [r4, #3] <== NOT EXECUTED
22e2c: e1a034a3 lsr r3, r3, #9 <== NOT EXECUTED
22e30: ea000003 b 22e44 <fat_init_volume_info+0x10c> <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
22e34: e5d42003 ldrb r2, [r4, #3] <== NOT EXECUTED
22e38: e2822001 add r2, r2, #1 <== NOT EXECUTED
22e3c: e5c42003 strb r2, [r4, #3] <== NOT EXECUTED
22e40: e1a030c3 asr r3, r3, #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;
22e44: e3130001 tst r3, #1 <== NOT EXECUTED
22e48: 0afffff9 beq 22e34 <fat_init_volume_info+0xfc> <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
22e4c: e3a03000 mov r3, #0 <== NOT EXECUTED
22e50: e5c43002 strb r3, [r4, #2] <== NOT EXECUTED
22e54: e1d430b0 ldrh r3, [r4] <== NOT EXECUTED
22e58: ea000003 b 22e6c <fat_init_volume_info+0x134> <== NOT EXECUTED
i >>= 1, vol->sec_log2++);
22e5c: e5d42002 ldrb r2, [r4, #2] <== NOT EXECUTED
22e60: e2822001 add r2, r2, #1 <== NOT EXECUTED
22e64: e5c42002 strb r2, [r4, #2] <== NOT EXECUTED
22e68: e1a030c3 asr r3, r3, #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;
22e6c: e3130001 tst r3, #1 <== NOT EXECUTED
22e70: 0afffff9 beq 22e5c <fat_init_volume_info+0x124> <== NOT EXECUTED
i >>= 1, vol->sec_log2++);
vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
22e74: e5dd2011 ldrb r2, [sp, #17] <== NOT EXECUTED
/*
* "sectors per cluster" of zero is invalid
* (and would hang the following loop)
*/
if (vol->spc == 0)
22e78: e3520000 cmp r2, #0 <== 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;
22e7c: 13a03000 movne 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);
22e80: e5c42004 strb r2, [r4, #4] <== 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;
22e84: 15c43005 strbne r3, [r4, #5] <== NOT EXECUTED
vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
/*
* "sectors per cluster" of zero is invalid
* (and would hang the following loop)
*/
if (vol->spc == 0)
22e88: 1a000003 bne 22e9c <fat_init_volume_info+0x164> <== NOT EXECUTED
22e8c: ea000092 b 230dc <fat_init_volume_info+0x3a4> <== 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;
i >>= 1, vol->spc_log2++);
22e90: e2833001 add r3, r3, #1 <== NOT EXECUTED
22e94: e5c43005 strb r3, [r4, #5] <== NOT EXECUTED
22e98: e1a020c2 asr r2, 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;
22e9c: e3120001 tst r2, #1 <== NOT EXECUTED
22ea0: e5d43005 ldrb r3, [r4, #5] <== NOT EXECUTED
22ea4: 0afffff9 beq 22e90 <fat_init_volume_info+0x158> <== 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)
22ea8: e1d420b0 ldrh r2, [r4] <== NOT EXECUTED
22eac: e1a03312 lsl r3, r2, r3 <== NOT EXECUTED
22eb0: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED
22eb4: e1a03823 lsr r3, r3, #16 <== NOT EXECUTED
22eb8: e3530902 cmp r3, #32768 ; 0x8000 <== 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;
22ebc: 93a02000 movls r2, #0 <== 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)
22ec0: e1c430b6 strh r3, [r4, #6] <== 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;
22ec4: 95c42008 strbls r2, [r4, #8] <== 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)
22ec8: 9a000004 bls 22ee0 <fat_init_volume_info+0x1a8> <== NOT EXECUTED
22ecc: ea000082 b 230dc <fat_init_volume_info+0x3a4> <== 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;
i >>= 1, vol->bpc_log2++);
22ed0: e5d42008 ldrb r2, [r4, #8] <== NOT EXECUTED
22ed4: e2822001 add r2, r2, #1 <== NOT EXECUTED
22ed8: e5c42008 strb r2, [r4, #8] <== NOT EXECUTED
22edc: e1a030c3 asr r3, r3, #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;
22ee0: e3130001 tst r3, #1 <== NOT EXECUTED
22ee4: 0afffff9 beq 22ed0 <fat_init_volume_info+0x198> <== NOT EXECUTED
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
22ee8: e5dd3014 ldrb r3, [sp, #20] <== NOT EXECUTED
22eec: e5c43009 strb r3, [r4, #9] <== NOT EXECUTED
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
22ef0: e5dd2013 ldrb r2, [sp, #19] <== NOT EXECUTED
22ef4: e5dd3012 ldrb r3, [sp, #18] <== NOT EXECUTED
22ef8: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
22efc: e1c431b4 strh r3, [r4, #20] <== NOT EXECUTED
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)) /
22f00: e1d410b0 ldrh r1, [r4] <== 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);
22f04: e5dd2016 ldrb r2, [sp, #22] <== NOT EXECUTED
22f08: 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)) /
22f0c: 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);
22f10: 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)) /
22f14: 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);
22f18: 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)) /
22f1c: eb00c7f9 bl 54f08 <__aeabi_idiv> <== NOT EXECUTED
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
22f20: e5d43002 ldrb r3, [r4, #2] <== NOT EXECUTED
22f24: 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)) /
22f28: e5840024 str r0, [r4, #36] ; 0x24 <== NOT EXECUTED
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
22f2c: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
22f30: e5dd201b ldrb r2, [sp, #27] <== NOT EXECUTED
22f34: e5dd301a ldrb r3, [sp, #26] <== NOT EXECUTED
22f38: e1933402 orrs r3, 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);
22f3c: 05dd302a ldrbeq r3, [sp, #42] ; 0x2a <== NOT EXECUTED
22f40: 05dd2029 ldrbeq r2, [sp, #41] ; 0x29 <== NOT EXECUTED
22f44: 05dd1028 ldrbeq r1, [sp, #40] ; 0x28 <== NOT EXECUTED
22f48: 01a03803 lsleq r3, r3, #16 <== NOT EXECUTED
22f4c: 01833402 orreq r3, r3, r2, lsl #8 <== NOT EXECUTED
22f50: 05dd202b ldrbeq r2, [sp, #43] ; 0x2b <== NOT EXECUTED
22f54: 01833001 orreq r3, r3, r1 <== NOT EXECUTED
22f58: 01833c02 orreq r3, r3, r2, lsl #24 <== NOT EXECUTED
22f5c: e5843018 str r3, [r4, #24] <== NOT EXECUTED
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
22f60: e5d42009 ldrb r2, [r4, #9] <== NOT EXECUTED
22f64: e5941018 ldr r1, [r4, #24] <== NOT EXECUTED
22f68: e0030291 mul r3, r1, r2 <== NOT EXECUTED
22f6c: e1d421b4 ldrh r2, [r4, #20] <== NOT EXECUTED
22f70: e5941024 ldr r1, [r4, #36] ; 0x24 <== NOT EXECUTED
22f74: e0821001 add r1, r2, r1 <== NOT EXECUTED
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
22f78: e0832002 add r2, r3, r2 <== 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 +
22f7c: e0813003 add r3, r1, r3 <== NOT EXECUTED
22f80: 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;
22f84: e584201c str r2, [r4, #28] <== NOT EXECUTED
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
22f88: e5dd2018 ldrb r2, [sp, #24] <== NOT EXECUTED
22f8c: e5dd3017 ldrb r3, [sp, #23] <== NOT EXECUTED
22f90: e1933402 orrs r3, r3, r2, 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);
22f94: 05dd3026 ldrbeq r3, [sp, #38] ; 0x26 <== NOT EXECUTED
22f98: 05dd2025 ldrbeq r2, [sp, #37] ; 0x25 <== NOT EXECUTED
22f9c: 01a03803 lsleq r3, r3, #16 <== NOT EXECUTED
22fa0: 05dd1024 ldrbeq r1, [sp, #36] ; 0x24 <== NOT EXECUTED
22fa4: 01833402 orreq r3, r3, r2, lsl #8 <== NOT EXECUTED
22fa8: 05dd2027 ldrbeq r2, [sp, #39] ; 0x27 <== NOT EXECUTED
22fac: 01833001 orreq r3, r3, r1 <== NOT EXECUTED
22fb0: 01833c02 orreq r3, r3, r2, lsl #24 <== NOT EXECUTED
22fb4: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
data_secs = vol->tot_secs - vol->data_fsec;
vol->data_cls = data_secs / vol->spc;
22fb8: e5d41004 ldrb r1, [r4, #4] <== NOT EXECUTED
22fbc: e284302c add r3, r4, #44 ; 0x2c <== NOT EXECUTED
22fc0: e8930009 ldm r3, {r0, r3} <== NOT EXECUTED
22fc4: e0400003 sub r0, r0, r3 <== NOT EXECUTED
22fc8: eb00c78a bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
22fcc: e59f3340 ldr r3, [pc, #832] ; 23314 <fat_init_volume_info+0x5dc><== NOT EXECUTED
22fd0: 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;
22fd4: e5840034 str r0, [r4, #52] ; 0x34 <== NOT EXECUTED
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
{
vol->type = FAT_FAT12;
22fd8: 93a03001 movls r3, #1 <== NOT EXECUTED
22fdc: 95c4300a strbls r3, [r4, #10] <== NOT EXECUTED
vol->mask = FAT_FAT12_MASK;
22fe0: 959f3330 ldrls r3, [pc, #816] ; 23318 <fat_init_volume_info+0x5e0><== NOT EXECUTED
22fe4: 9a000005 bls 23000 <fat_init_volume_info+0x2c8> <== NOT EXECUTED
vol->eoc_val = FAT_FAT12_EOC;
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
22fe8: e59f332c ldr r3, [pc, #812] ; 2331c <fat_init_volume_info+0x5e4><== NOT EXECUTED
22fec: e1500003 cmp r0, r3 <== NOT EXECUTED
22ff0: 8a000005 bhi 2300c <fat_init_volume_info+0x2d4> <== NOT EXECUTED
{
vol->type = FAT_FAT16;
22ff4: e3a03002 mov r3, #2 <== NOT EXECUTED
22ff8: e5c4300a strb r3, [r4, #10] <== NOT EXECUTED
vol->mask = FAT_FAT16_MASK;
22ffc: e59f331c ldr r3, [pc, #796] ; 23320 <fat_init_volume_info+0x5e8><== NOT EXECUTED
23000: e584300c str r3, [r4, #12] <== NOT EXECUTED
vol->eoc_val = FAT_FAT16_EOC;
23004: e2433007 sub r3, r3, #7 <== NOT EXECUTED
23008: ea000004 b 23020 <fat_init_volume_info+0x2e8> <== NOT EXECUTED
}
else
{
vol->type = FAT_FAT32;
2300c: e3a03004 mov r3, #4 <== NOT EXECUTED
23010: e5c4300a strb r3, [r4, #10] <== NOT EXECUTED
vol->mask = FAT_FAT32_MASK;
23014: e3e0320f mvn r3, #-268435456 ; 0xf0000000 <== NOT EXECUTED
23018: e584300c str r3, [r4, #12] <== NOT EXECUTED
vol->eoc_val = FAT_FAT32_EOC;
2301c: e3e0327f mvn r3, #-268435449 ; 0xf0000007 <== NOT EXECUTED
23020: e5843010 str r3, [r4, #16] <== NOT EXECUTED
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;
register fat_vol_t *vol = &fs_info->vol;
23024: e5d4300a ldrb r3, [r4, #10] <== NOT EXECUTED
23028: e3530004 cmp r3, #4 <== NOT EXECUTED
2302c: 1a000059 bne 23198 <fat_init_volume_info+0x460> <== NOT EXECUTED
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
23030: e5dd3032 ldrb r3, [sp, #50] ; 0x32 <== NOT EXECUTED
23034: e5dd2031 ldrb r2, [sp, #49] ; 0x31 <== NOT EXECUTED
23038: e5dd1030 ldrb r1, [sp, #48] ; 0x30 <== NOT EXECUTED
2303c: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED
23040: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
23044: e5dd2033 ldrb r2, [sp, #51] ; 0x33 <== NOT EXECUTED
23048: e1833001 orr r3, r3, r1 <== NOT EXECUTED
2304c: e1833c02 orr r3, r3, r2, lsl #24 <== NOT EXECUTED
23050: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
23054: e5dd302c ldrb r3, [sp, #44] ; 0x2c <== NOT EXECUTED
23058: e2033080 and r3, r3, #128 ; 0x80 <== NOT EXECUTED
2305c: e5c43048 strb r3, [r4, #72] ; 0x48 <== NOT EXECUTED
if (vol->mirror)
23060: e3530000 cmp r3, #0 <== NOT EXECUTED
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
23064: 15dd302c ldrbne r3, [sp, #44] ; 0x2c <== NOT EXECUTED
23068: 1203300f andne r3, r3, #15 <== NOT EXECUTED
else
vol->afat = 0;
2306c: e5c43050 strb r3, [r4, #80] ; 0x50 <== NOT EXECUTED
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
23070: e5dd1035 ldrb r1, [sp, #53] ; 0x35 <== NOT EXECUTED
23074: e5dd3034 ldrb r3, [sp, #52] ; 0x34 <== NOT EXECUTED
23078: e1831401 orr r1, r3, r1, lsl #8 <== NOT EXECUTED
if( vol->info_sec == 0 )
2307c: 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);
23080: e1c413bc strh r1, [r4, #60] ; 0x3c <== NOT EXECUTED
if( vol->info_sec == 0 )
23084: 0a000014 beq 230dc <fat_init_volume_info+0x3a4> <== 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,
23088: e28d60a8 add r6, sp, #168 ; 0xa8 <== NOT EXECUTED
2308c: e1a00005 mov r0, r5 <== NOT EXECUTED
23090: e3a02000 mov r2, #0 <== NOT EXECUTED
23094: e3a03004 mov r3, #4 <== NOT EXECUTED
23098: e58d6000 str r6, [sp] <== NOT EXECUTED
2309c: ebffff01 bl 22ca8 <_fat_block_read> <== NOT EXECUTED
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
230a0: e3500000 cmp r0, #0 <== NOT EXECUTED
230a4: ba00001b blt 23118 <fat_init_volume_info+0x3e0> <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
230a8: e5dd20aa ldrb r2, [sp, #170] ; 0xaa <== NOT EXECUTED
230ac: e5dd30a9 ldrb r3, [sp, #169] ; 0xa9 <== NOT EXECUTED
230b0: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
230b4: e5dd10a8 ldrb r1, [sp, #168] ; 0xa8 <== NOT EXECUTED
230b8: e1822403 orr r2, r2, r3, lsl #8 <== NOT EXECUTED
230bc: e5dd30ab ldrb r3, [sp, #171] ; 0xab <== NOT EXECUTED
230c0: e1822001 orr r2, r2, r1 <== NOT EXECUTED
230c4: e1822c03 orr r2, r2, r3, lsl #24 <== NOT EXECUTED
230c8: e59f3254 ldr r3, [pc, #596] ; 23324 <fat_init_volume_info+0x5ec><== NOT EXECUTED
230cc: e1520003 cmp r2, r3 <== NOT EXECUTED
230d0: 0a000006 beq 230f0 <fat_init_volume_info+0x3b8> <== 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);
230d4: e5950034 ldr r0, [r5, #52] ; 0x34 <== NOT EXECUTED
230d8: ebfffd71 bl 226a4 <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);
230dc: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED
230e0: ebff8ce9 bl 648c <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
230e4: eb006785 bl 3cf00 <__errno> <== NOT EXECUTED
230e8: e3a03016 mov r3, #22 <== NOT EXECUTED
230ec: ea000083 b 23300 <fat_init_volume_info+0x5c8> <== NOT EXECUTED
}
else
{
ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
230f0: e1d413bc ldrh r1, [r4, #60] ; 0x3c <== NOT EXECUTED
230f4: e1a00005 mov r0, r5 <== NOT EXECUTED
230f8: e3a02f79 mov r2, #484 ; 0x1e4 <== NOT EXECUTED
230fc: e3a0300c mov r3, #12 <== NOT EXECUTED
23100: e58d6000 str r6, [sp] <== NOT EXECUTED
23104: ebfffee7 bl 22ca8 <_fat_block_read> <== NOT EXECUTED
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
23108: e3500000 cmp r0, #0 <== NOT EXECUTED
2310c: aa000004 bge 23124 <fat_init_volume_info+0x3ec> <== 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);
23110: e5950034 ldr r0, [r5, #52] ; 0x34 <== NOT EXECUTED
23114: ebfffd62 bl 226a4 <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);
23118: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED
2311c: ebff8cda bl 648c <rtems_disk_release> <== NOT EXECUTED
23120: ea000077 b 23304 <fat_init_volume_info+0x5cc> <== NOT EXECUTED
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
23124: e5dd30ae ldrb r3, [sp, #174] ; 0xae <== NOT EXECUTED
23128: e5dd20ad ldrb r2, [sp, #173] ; 0xad <== NOT EXECUTED
2312c: e5dd10ac ldrb r1, [sp, #172] ; 0xac <== NOT EXECUTED
23130: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED
23134: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
23138: e5dd20af ldrb r2, [sp, #175] ; 0xaf <== NOT EXECUTED
2313c: e1833001 orr r3, r3, r1 <== NOT EXECUTED
23140: e1833c02 orr r3, r3, r2, lsl #24 <== NOT EXECUTED
23144: e5843040 str r3, [r4, #64] ; 0x40 <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
23148: e5dd30b2 ldrb r3, [sp, #178] ; 0xb2 <== NOT EXECUTED
2314c: e5dd20b1 ldrb r2, [sp, #177] ; 0xb1 <== NOT EXECUTED
23150: e5dd10b0 ldrb r1, [sp, #176] ; 0xb0 <== NOT EXECUTED
23154: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED
23158: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
2315c: e5dd20b3 ldrb r2, [sp, #179] ; 0xb3 <== NOT EXECUTED
23160: e1833001 orr r3, r3, r1 <== NOT EXECUTED
23164: e1833c02 orr r3, r3, r2, lsl #24 <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
23168: 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);
2316c: e5843044 str r3, [r4, #68] ; 0x44 <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
23170: e1a00005 mov r0, r5 <== NOT EXECUTED
23174: e1a02001 mov r2, r1 <== NOT EXECUTED
23178: ebfffe3b bl 22a6c <fat_fat32_update_fsinfo_sector> <== NOT EXECUTED
0xFFFFFFFF);
if ( rc != RC_OK )
2317c: e2507000 subs r7, r0, #0 <== NOT EXECUTED
23180: 0a00000b beq 231b4 <fat_init_volume_info+0x47c> <== 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);
23184: e5950034 ldr r0, [r5, #52] ; 0x34 <== NOT EXECUTED
23188: ebfffd45 bl 226a4 <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);
2318c: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED
23190: ebff8cbd bl 648c <rtems_disk_release> <== NOT EXECUTED
return rc;
23194: ea00005b b 23308 <fat_init_volume_info+0x5d0> <== NOT EXECUTED
}
}
}
else
{
vol->rdir_cl = 0;
23198: e3a03000 mov r3, #0 <== NOT EXECUTED
vol->mirror = 0;
vol->afat = 0;
vol->free_cls = 0xFFFFFFFF;
2319c: e3e02000 mvn r2, #0 <== NOT EXECUTED
}
else
{
vol->rdir_cl = 0;
vol->mirror = 0;
vol->afat = 0;
231a0: e5c43050 strb r3, [r4, #80] ; 0x50 <== NOT EXECUTED
vol->free_cls = 0xFFFFFFFF;
vol->next_cl = 0xFFFFFFFF;
231a4: e5842044 str r2, [r4, #68] ; 0x44 <== NOT EXECUTED
}
}
}
else
{
vol->rdir_cl = 0;
231a8: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
vol->mirror = 0;
231ac: e5c43048 strb r3, [r4, #72] ; 0x48 <== NOT EXECUTED
vol->afat = 0;
vol->free_cls = 0xFFFFFFFF;
231b0: 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);
231b4: e5950034 ldr r0, [r5, #52] ; 0x34 <== NOT EXECUTED
231b8: ebfffd39 bl 226a4 <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;
231bc: e5d41050 ldrb r1, [r4, #80] ; 0x50 <== NOT EXECUTED
231c0: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED
231c4: e1d421b4 ldrh r2, [r4, #20] <== NOT EXECUTED
231c8: 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));
231cc: 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;
231d0: 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));
231d4: e3a0100c mov r1, #12 <== NOT EXECUTED
231d8: ebff8fc5 bl 70f4 <calloc> <== NOT EXECUTED
if ( fs_info->vhash == NULL )
231dc: 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));
231e0: e1a03000 mov r3, r0 <== NOT EXECUTED
231e4: e5840064 str r0, [r4, #100] ; 0x64 <== NOT EXECUTED
if ( fs_info->vhash == NULL )
231e8: 0a000010 beq 23230 <fat_init_volume_info+0x4f8> <== 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);
231ec: 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);
231f0: e280c004 add ip, r0, #4 <== NOT EXECUTED
the_chain->permanent_null = NULL;
231f4: e3a05000 mov r5, #0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
231f8: e280e010 add lr, r0, #16 <== NOT EXECUTED
the_chain->permanent_null = NULL;
231fc: e5835004 str r5, [r3, #4] <== NOT EXECUTED
the_chain->last = _Chain_Head(the_chain);
23200: e5833008 str r3, [r3, #8] <== NOT EXECUTED
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
23204: e3a00002 mov r0, #2 <== NOT EXECUTED
23208: e3a0100c mov r1, #12 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
2320c: e583e00c str lr, [r3, #12] <== NOT EXECUTED
23210: e583c000 str ip, [r3] <== NOT EXECUTED
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
23214: 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;
23218: e5825004 str r5, [r2, #4] <== NOT EXECUTED
2321c: ebff8fb4 bl 70f4 <calloc> <== NOT EXECUTED
if ( fs_info->rhash == NULL )
23220: 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));
23224: e5840068 str r0, [r4, #104] ; 0x68 <== NOT EXECUTED
if ( fs_info->rhash == NULL )
23228: 1a000003 bne 2323c <fat_init_volume_info+0x504> <== NOT EXECUTED
2322c: ea000018 b 23294 <fat_init_volume_info+0x55c> <== 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);
23230: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED
23234: ebff8c94 bl 648c <rtems_disk_release> <== NOT EXECUTED
23238: ea00002e b 232f8 <fat_init_volume_info+0x5c0> <== 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);
2323c: 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);
23240: e2802004 add r2, r0, #4 <== NOT EXECUTED
23244: e2801010 add r1, r0, #16 <== NOT EXECUTED
23248: e580100c str r1, [r0, #12] <== NOT EXECUTED
2324c: e8800024 stm r0, {r2, r5} <== NOT EXECUTED
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
23250: 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;
23254: e5835004 str r5, [r3, #4] <== NOT EXECUTED
the_chain->last = _Chain_Head(the_chain);
23258: 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;
2325c: e594202c ldr r2, [r4, #44] ; 0x2c <== NOT EXECUTED
23260: e5d43003 ldrb r3, [r4, #3] <== NOT EXECUTED
23264: 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;
23268: e3a00c01 mov r0, #256 ; 0x100 <== NOT EXECUTED
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
2326c: e1a03203 lsl r3, r3, #4 <== NOT EXECUTED
23270: 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;
23274: e5840074 str r0, [r4, #116] ; 0x74 <== NOT EXECUTED
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
23278: e5845070 str r5, [r4, #112] ; 0x70 <== NOT EXECUTED
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
2327c: e3a01001 mov r1, #1 <== NOT EXECUTED
23280: ebff8f9b bl 70f4 <calloc> <== NOT EXECUTED
if ( fs_info->uino == NULL )
23284: 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));
23288: e584006c str r0, [r4, #108] ; 0x6c <== NOT EXECUTED
if ( fs_info->uino == NULL )
2328c: 1a00000a bne 232bc <fat_init_volume_info+0x584> <== NOT EXECUTED
23290: ea000003 b 232a4 <fat_init_volume_info+0x56c> <== 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);
23294: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED
23298: ebff8c7b bl 648c <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
2329c: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED
232a0: ea000013 b 232f4 <fat_init_volume_info+0x5bc> <== 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);
232a4: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED
232a8: ebff8c77 bl 648c <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
232ac: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED
232b0: ebff90ff bl 76b4 <free> <== NOT EXECUTED
free(fs_info->rhash);
232b4: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED
232b8: ea00000d b 232f4 <fat_init_volume_info+0x5bc> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
232bc: e1d400b0 ldrh r0, [r4] <== NOT EXECUTED
232c0: e3a01001 mov r1, #1 <== NOT EXECUTED
232c4: ebff8f8a bl 70f4 <calloc> <== NOT EXECUTED
if (fs_info->sec_buf == NULL)
232c8: 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));
232cc: e5840088 str r0, [r4, #136] ; 0x88 <== NOT EXECUTED
if (fs_info->sec_buf == NULL)
232d0: 11a07005 movne r7, r5 <== NOT EXECUTED
232d4: 1a00000b bne 23308 <fat_init_volume_info+0x5d0> <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
232d8: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED
232dc: ebff8c6a bl 648c <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
232e0: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED
232e4: ebff90f2 bl 76b4 <free> <== NOT EXECUTED
free(fs_info->rhash);
232e8: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED
232ec: ebff90f0 bl 76b4 <free> <== NOT EXECUTED
free(fs_info->uino);
232f0: e594006c ldr r0, [r4, #108] ; 0x6c <== NOT EXECUTED
232f4: ebff90ee bl 76b4 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
232f8: eb006700 bl 3cf00 <__errno> <== NOT EXECUTED
232fc: e3a0300c mov r3, #12 <== NOT EXECUTED
23300: e5803000 str r3, [r0] <== NOT EXECUTED
23304: e3e07000 mvn r7, #0 <== NOT EXECUTED
}
return RC_OK;
}
23308: e1a00007 mov r0, r7 <== NOT EXECUTED
2330c: e28dd0b8 add sp, sp, #184 ; 0xb8 <== NOT EXECUTED
23310: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
000225d4 <fat_ino_is_unique>:
inline bool
fat_ino_is_unique(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t ino
)
{
225d4: e5903034 ldr r3, [r0, #52] ; 0x34 <== NOT EXECUTED
225d8: e5930078 ldr r0, [r3, #120] ; 0x78 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
return (ino >= fs_info->uino_base);
}
225dc: e1510000 cmp r1, r0 <== NOT EXECUTED
225e0: 33a00000 movcc r0, #0 <== NOT EXECUTED
225e4: 23a00001 movcs r0, #1 <== NOT EXECUTED
225e8: e12fff1e bx lr <== NOT EXECUTED
0003953c <fat_scan_fat_for_free_clusters>:
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
3953c: e92d4fff push {r0, r1, r2, r3, 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;
39540: e5904034 ldr r4, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
39544: e1a05000 mov r5, r0 <== 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;
39548: e5940034 ldr r0, [r4, #52] ; 0x34 <== NOT EXECUTED
uint32_t i = 2;
*cls_added = 0;
if (count == 0)
3954c: 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;
39550: e3a09000 mov r9, #0 <== NOT EXECUTED
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
39554: e2800002 add r0, r0, #2 <== 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;
39558: e58d900c str r9, [sp, #12] <== NOT EXECUTED
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
3955c: e1a08003 mov r8, r3 <== NOT EXECUTED
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
uint32_t i = 2;
*cls_added = 0;
if (count == 0)
39560: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
39564: e1a0a001 mov sl, r1 <== 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;
39568: e58d0000 str r0, [sp] <== NOT EXECUTED
uint32_t i = 2;
*cls_added = 0;
3956c: e5839000 str r9, [r3] <== NOT EXECUTED
if (count == 0)
39570: 01a07002 moveq r7, r2 <== NOT EXECUTED
39574: 0a000058 beq 396dc <fat_scan_fat_for_free_clusters+0x1a0> <== NOT EXECUTED
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
39578: e5946044 ldr r6, [r4, #68] ; 0x44 <== NOT EXECUTED
3957c: e3760001 cmn r6, #1 <== NOT EXECUTED
39580: 03a06002 moveq r6, #2 <== NOT EXECUTED
39584: e3a0b002 mov fp, #2 <== NOT EXECUTED
39588: ea000042 b 39698 <fat_scan_fat_for_free_clusters+0x15c> <== NOT EXECUTED
* starting at cluster 2, so the maximum valid cluster number is
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
{
rc = fat_get_fat_cluster(mt_entry, cl4find, &next_cln);
3958c: ebffff61 bl 39318 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
39590: e2507000 subs r7, r0, #0 <== NOT EXECUTED
39594: 0a000004 beq 395ac <fat_scan_fat_for_free_clusters+0x70> <== NOT EXECUTED
{
if (*cls_added != 0)
39598: e5983000 ldr r3, [r8] <== NOT EXECUTED
3959c: e3530000 cmp r3, #0 <== NOT EXECUTED
fat_free_fat_clusters_chain(mt_entry, (*chain));
395a0: 11a00005 movne r0, r5 <== 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)
395a4: 0a00004c beq 396dc <fat_scan_fat_for_free_clusters+0x1a0> <== NOT EXECUTED
395a8: ea000015 b 39604 <fat_scan_fat_for_free_clusters+0xc8> <== NOT EXECUTED
fat_free_fat_clusters_chain(mt_entry, (*chain));
return rc;
}
if (next_cln == FAT_GENFAT_FREE)
395ac: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
395b0: e3520000 cmp r2, #0 <== NOT EXECUTED
395b4: e58d2008 str r2, [sp, #8] <== NOT EXECUTED
395b8: 1a000031 bne 39684 <fat_scan_fat_for_free_clusters+0x148> <== 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)
395bc: e5983000 ldr r3, [r8] <== NOT EXECUTED
395c0: 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);
395c4: e1a01006 mov r1, r6 <== NOT EXECUTED
395c8: 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);
395cc: e1a00005 mov r0, r5 <== 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)
395d0: 1a000004 bne 395e8 <fat_scan_fat_for_free_clusters+0xac> <== NOT EXECUTED
{
*chain = cl4find;
395d4: e58a6000 str r6, [sl] <== NOT EXECUTED
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
395d8: ebfffeb6 bl 390b8 <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
395dc: e2507000 subs r7, r0, #0 <== NOT EXECUTED
395e0: 0a000017 beq 39644 <fat_scan_fat_for_free_clusters+0x108> <== NOT EXECUTED
395e4: ea00003c b 396dc <fat_scan_fat_for_free_clusters+0x1a0> <== NOT EXECUTED
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
395e8: e1a00005 mov r0, r5 <== NOT EXECUTED
395ec: ebfffeb1 bl 390b8 <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
395f0: e2507000 subs r7, 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);
395f4: e1a01009 mov r1, r9 <== NOT EXECUTED
395f8: e1a02006 mov r2, r6 <== NOT EXECUTED
395fc: e1a00005 mov r0, r5 <== 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 )
39600: 0a000002 beq 39610 <fat_scan_fat_for_free_clusters+0xd4> <== NOT EXECUTED
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
39604: e59a1000 ldr r1, [sl] <== NOT EXECUTED
39608: ebffff9c bl 39480 <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
3960c: ea000032 b 396dc <fat_scan_fat_for_free_clusters+0x1a0> <== NOT EXECUTED
}
rc = fat_set_fat_cluster(mt_entry, save_cln, cl4find);
39610: ebfffea8 bl 390b8 <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
39614: e2507000 subs r7, r0, #0 <== NOT EXECUTED
39618: 0a000009 beq 39644 <fat_scan_fat_for_free_clusters+0x108> <== NOT EXECUTED
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
3961c: e59a1000 ldr r1, [sl] <== NOT EXECUTED
39620: e1a00005 mov r0, r5 <== NOT EXECUTED
39624: ebffff95 bl 39480 <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);
39628: e1a00005 mov r0, r5 <== NOT EXECUTED
3962c: e1a01006 mov r1, r6 <== NOT EXECUTED
39630: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED
39634: ebfffe9f bl 390b8 <fat_set_fat_cluster> <== NOT EXECUTED
fat_buf_release(fs_info);
39638: e1a00004 mov r0, r4 <== NOT EXECUTED
3963c: ebffa418 bl 226a4 <fat_buf_release> <== NOT EXECUTED
return rc;
39640: ea000025 b 396dc <fat_scan_fat_for_free_clusters+0x1a0> <== NOT EXECUTED
}
}
save_cln = cl4find;
(*cls_added)++;
39644: e5983000 ldr r3, [r8] <== NOT EXECUTED
/* have we satisfied request ? */
if (*cls_added == count)
39648: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED
return rc;
}
}
save_cln = cl4find;
(*cls_added)++;
3964c: e2833001 add r3, r3, #1 <== NOT EXECUTED
/* have we satisfied request ? */
if (*cls_added == count)
39650: e1530002 cmp r3, r2 <== NOT EXECUTED
return rc;
}
}
save_cln = cl4find;
(*cls_added)++;
39654: e5883000 str r3, [r8] <== NOT EXECUTED
/* have we satisfied request ? */
if (*cls_added == count)
39658: 1a000008 bne 39680 <fat_scan_fat_for_free_clusters+0x144> <== NOT EXECUTED
{
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
3965c: e5943040 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED
(*cls_added)++;
/* have we satisfied request ? */
if (*cls_added == count)
{
fs_info->vol.next_cl = save_cln;
39660: e5846044 str r6, [r4, #68] ; 0x44 <== NOT EXECUTED
if (fs_info->vol.free_cls != 0xFFFFFFFF)
39664: e3730001 cmn r3, #1 <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
39668: 15982000 ldrne r2, [r8] <== NOT EXECUTED
3966c: 10623003 rsbne r3, r2, r3 <== NOT EXECUTED
39670: 15843040 strne r3, [r4, #64] ; 0x40 <== NOT EXECUTED
*last_cl = save_cln;
39674: e59d3034 ldr r3, [sp, #52] ; 0x34 <== NOT EXECUTED
39678: e5836000 str r6, [r3] <== NOT EXECUTED
3967c: ea000013 b 396d0 <fat_scan_fat_for_free_clusters+0x194> <== NOT EXECUTED
fat_buf_release(fs_info);
return rc;
39680: e1a09006 mov r9, r6 <== NOT EXECUTED
}
}
i++;
cl4find++;
if (cl4find >= data_cls_val)
39684: e59d2000 ldr r2, [sp] <== NOT EXECUTED
fat_buf_release(fs_info);
return rc;
}
}
i++;
cl4find++;
39688: e2866001 add r6, r6, #1 <== NOT EXECUTED
if (cl4find >= data_cls_val)
3968c: e1560002 cmp r6, r2 <== NOT EXECUTED
39690: 23a06002 movcs r6, #2 <== NOT EXECUTED
*last_cl = save_cln;
fat_buf_release(fs_info);
return rc;
}
}
i++;
39694: e28bb001 add fp, fp, #1 <== 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)
39698: e59d3000 ldr r3, [sp] <== NOT EXECUTED
3969c: e15b0003 cmp fp, r3 <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cl4find, &next_cln);
396a0: e1a01006 mov r1, r6 <== NOT EXECUTED
396a4: e28d200c add r2, sp, #12 <== NOT EXECUTED
396a8: e1a00005 mov r0, r5 <== 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)
396ac: 3affffb6 bcc 3958c <fat_scan_fat_for_free_clusters+0x50> <== NOT EXECUTED
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
396b0: e5943040 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED
cl4find++;
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
396b4: e5849044 str r9, [r4, #68] ; 0x44 <== NOT EXECUTED
if (fs_info->vol.free_cls != 0xFFFFFFFF)
396b8: e3730001 cmn r3, #1 <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
396bc: 15982000 ldrne r2, [r8] <== NOT EXECUTED
396c0: 10623003 rsbne r3, r2, r3 <== NOT EXECUTED
*last_cl = save_cln;
396c4: 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);
396c8: 15843040 strne r3, [r4, #64] ; 0x40 <== NOT EXECUTED
*last_cl = save_cln;
396cc: e5829000 str r9, [r2] <== NOT EXECUTED
fat_buf_release(fs_info);
396d0: e1a00004 mov r0, r4 <== NOT EXECUTED
396d4: ebffa3f2 bl 226a4 <fat_buf_release> <== NOT EXECUTED
396d8: e3a07000 mov r7, #0 <== NOT EXECUTED
return RC_OK;
}
396dc: e1a00007 mov r0, r7 <== NOT EXECUTED
396e0: e28dd010 add sp, sp, #16 <== NOT EXECUTED
396e4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
000390b8 <fat_set_fat_cluster>:
fat_set_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t in_val
)
{
390b8: e92d4ff1 push {r0, 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;
390bc: e3a03000 mov r3, #0 <== NOT EXECUTED
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
390c0: 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
)
{
390c4: 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;
390c8: 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
)
{
390cc: e1a07002 mov r7, r2 <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
390d0: 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)) )
390d4: 9a00008a bls 39304 <fat_set_fat_cluster+0x24c> <== NOT EXECUTED
390d8: e5943034 ldr r3, [r4, #52] ; 0x34 <== NOT EXECUTED
390dc: e2833001 add r3, r3, #1 <== NOT EXECUTED
390e0: e1510003 cmp r1, r3 <== NOT EXECUTED
390e4: 8a000086 bhi 39304 <fat_set_fat_cluster+0x24c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
390e8: e5d4300a ldrb r3, [r4, #10] <== NOT EXECUTED
390ec: e2130001 ands r0, r3, #1 <== NOT EXECUTED
390f0: 108120a1 addne r2, r1, r1, lsr #1 <== NOT EXECUTED
390f4: 1a000002 bne 39104 <fat_set_fat_cluster+0x4c> <== NOT EXECUTED
390f8: e3130002 tst r3, #2 <== NOT EXECUTED
390fc: 11a02081 lslne r2, r1, #1 <== NOT EXECUTED
39100: 01a02101 lsleq r2, r1, #2 <== NOT EXECUTED
39104: e5d4a002 ldrb sl, [r4, #2] <== NOT EXECUTED
39108: e594104c ldr r1, [r4, #76] ; 0x4c <== NOT EXECUTED
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
3910c: e3500000 cmp r0, #0 <== 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) +
39110: e081aa32 add sl, r1, r2, lsr sl <== NOT EXECUTED
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
39114: 108580a5 addne r8, r5, r5, lsr #1 <== NOT EXECUTED
39118: 1a000002 bne 39128 <fat_set_fat_cluster+0x70> <== NOT EXECUTED
3911c: e3130002 tst r3, #2 <== NOT EXECUTED
39120: 11a08085 lslne r8, r5, #1 <== NOT EXECUTED
39124: 01a08105 lsleq r8, r5, #2 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
39128: e1a00004 mov r0, r4 <== NOT EXECUTED
3912c: e1a0100a mov r1, sl <== NOT EXECUTED
39130: e3a02001 mov r2, #1 <== NOT EXECUTED
39134: 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);
39138: e1d4b0b0 ldrh fp, [r4] <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
3913c: ebffa5a8 bl 227e4 <fat_buf_access> <== NOT EXECUTED
if (rc != RC_OK)
39140: 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);
39144: e1a0900d mov r9, sp <== NOT EXECUTED
if (rc != RC_OK)
39148: 1a000071 bne 39314 <fat_set_fat_cluster+0x25c> <== NOT EXECUTED
return rc;
switch ( fs_info->vol.type )
3914c: e5d4600a ldrb r6, [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);
39150: e24bb001 sub fp, fp, #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 )
39154: e3560002 cmp r6, #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);
39158: e008800b and r8, r8, fp <== 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 )
3915c: 0a00005a beq 392cc <fat_set_fat_cluster+0x214> <== NOT EXECUTED
39160: e3560004 cmp r6, #4 <== NOT EXECUTED
39164: 0a00005c beq 392dc <fat_set_fat_cluster+0x224> <== NOT EXECUTED
39168: e3560001 cmp r6, #1 <== NOT EXECUTED
3916c: 1a000064 bne 39304 <fat_set_fat_cluster+0x24c> <== NOT EXECUTED
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
39170: e3150001 tst r5, #1 <== NOT EXECUTED
39174: e59d3000 ldr r3, [sp] <== NOT EXECUTED
39178: 0a000026 beq 39218 <fat_set_fat_cluster+0x160> <== NOT EXECUTED
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
3917c: 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)) =
39180: e7d32008 ldrb r2, [r3, r8] <== NOT EXECUTED
39184: e202200f and r2, r2, #15 <== NOT EXECUTED
39188: e7c32008 strb r2, [r3, r8] <== NOT EXECUTED
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
3918c: e59d3000 ldr r3, [sp] <== NOT EXECUTED
39190: 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)) =
39194: e7d32008 ldrb r2, [r3, r8] <== 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;
39198: e1a07a07 lsl r7, r7, #20 <== NOT EXECUTED
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
*((uint8_t *)(block0->buffer + ofs)) =
3919c: e1822827 orr r2, r2, r7, lsr #16 <== NOT EXECUTED
391a0: e7c32008 strb r2, [r3, r8] <== 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) )
391a4: e1d430b0 ldrh r3, [r4] <== NOT EXECUTED
391a8: e2433001 sub r3, r3, #1 <== NOT EXECUTED
391ac: e1580003 cmp r8, r3 <== NOT EXECUTED
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
391b0: e5c46080 strb r6, [r4, #128] ; 0x80 <== NOT EXECUTED
391b4: 1a00000e bne 391f4 <fat_set_fat_cluster+0x13c> <== NOT EXECUTED
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
391b8: e28a1001 add r1, sl, #1 <== NOT EXECUTED
391bc: e1a0300d mov r3, sp <== NOT EXECUTED
391c0: e1a00004 mov r0, r4 <== NOT EXECUTED
391c4: e1a02006 mov r2, r6 <== NOT EXECUTED
391c8: ebffa585 bl 227e4 <fat_buf_access> <== NOT EXECUTED
&block0);
if (rc != RC_OK)
391cc: e3500000 cmp r0, #0 <== NOT EXECUTED
391d0: 1a00004f bne 39314 <fat_set_fat_cluster+0x25c> <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) &= 0x00;
391d4: e59d3000 ldr r3, [sp] <== NOT EXECUTED
391d8: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
391dc: e5c30000 strb r0, [r3] <== NOT EXECUTED
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
391e0: e59d3000 ldr r3, [sp] <== NOT EXECUTED
391e4: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) &= 0x00;
*((uint8_t *)(block0->buffer)) =
391e8: e5d32000 ldrb r2, [r3] <== NOT EXECUTED
391ec: e1827c27 orr r7, r2, r7, lsr #24 <== NOT EXECUTED
391f0: ea000026 b 39290 <fat_set_fat_cluster+0x1d8> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) &= 0x00;
391f4: e59d3000 ldr r3, [sp] <== NOT EXECUTED
391f8: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
391fc: e2888001 add r8, r8, #1 <== NOT EXECUTED
39200: e7c30008 strb r0, [r3, r8] <== NOT EXECUTED
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) |
39204: e59d3000 ldr r3, [sp] <== NOT EXECUTED
39208: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) &= 0x00;
*((uint8_t *)(block0->buffer + ofs + 1)) =
3920c: e7d32008 ldrb r2, [r3, r8] <== NOT EXECUTED
39210: e1827c27 orr r7, r2, r7, lsr #24 <== NOT EXECUTED
39214: ea00002a b 392c4 <fat_set_fat_cluster+0x20c> <== NOT EXECUTED
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
39218: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
3921c: e7c30008 strb r0, [r3, r8] <== NOT EXECUTED
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
39220: e59d3000 ldr r3, [sp] <== NOT EXECUTED
39224: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
(uint8_t )((fat16_clv & 0xFF00)>>8);
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
39228: e1a07a07 lsl r7, r7, #20 <== NOT EXECUTED
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
*((uint8_t *)(block0->buffer + ofs)) =
3922c: e7d32008 ldrb r2, [r3, r8] <== NOT EXECUTED
(uint8_t )((fat16_clv & 0xFF00)>>8);
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
39230: e1a07a27 lsr r7, r7, #20 <== NOT EXECUTED
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
*((uint8_t *)(block0->buffer + ofs)) =
39234: e1822007 orr r2, r2, r7 <== NOT EXECUTED
39238: e7c32008 strb r2, [r3, r8] <== 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) )
3923c: e1d430b0 ldrh r3, [r4] <== NOT EXECUTED
39240: e2433001 sub r3, r3, #1 <== NOT EXECUTED
39244: e1580003 cmp r8, r3 <== NOT EXECUTED
39248: e5c46080 strb r6, [r4, #128] ; 0x80 <== NOT EXECUTED
3924c: 1a000012 bne 3929c <fat_set_fat_cluster+0x1e4> <== NOT EXECUTED
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
39250: e28a1001 add r1, sl, #1 <== NOT EXECUTED
39254: e1a0300d mov r3, sp <== NOT EXECUTED
39258: e1a00004 mov r0, r4 <== NOT EXECUTED
3925c: e1a02006 mov r2, r6 <== NOT EXECUTED
39260: ebffa55f bl 227e4 <fat_buf_access> <== NOT EXECUTED
&block0);
if (rc != RC_OK)
39264: e3500000 cmp r0, #0 <== NOT EXECUTED
39268: 1a000029 bne 39314 <fat_set_fat_cluster+0x25c> <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) & 0xF0;
3926c: e59d3000 ldr r3, [sp] <== NOT EXECUTED
39270: 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)) =
39274: e5d32000 ldrb r2, [r3] <== NOT EXECUTED
39278: e3c2200f bic r2, r2, #15 <== NOT EXECUTED
3927c: e5c32000 strb r2, [r3] <== NOT EXECUTED
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
39280: e59d3000 ldr r3, [sp] <== NOT EXECUTED
39284: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
39288: e5d32000 ldrb r2, [r3] <== NOT EXECUTED
3928c: e1827427 orr r7, r2, r7, lsr #8 <== NOT EXECUTED
39290: e5c37000 strb r7, [r3] <== NOT EXECUTED
39294: e5c46080 strb r6, [r4, #128] ; 0x80 <== NOT EXECUTED
39298: ea00001d b 39314 <fat_set_fat_cluster+0x25c> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
3929c: e59d3000 ldr r3, [sp] <== NOT EXECUTED
392a0: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
392a4: e2888001 add r8, r8, #1 <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
392a8: e7d32008 ldrb r2, [r3, r8] <== NOT EXECUTED
392ac: e3c2200f bic r2, r2, #15 <== NOT EXECUTED
392b0: e7c32008 strb r2, [r3, r8] <== NOT EXECUTED
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
*((uint8_t *)(block0->buffer + ofs+1)) =
(*((uint8_t *)(block0->buffer + ofs+1))) |
392b4: e59d3000 ldr r3, [sp] <== NOT EXECUTED
392b8: 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)) =
392bc: e7d32008 ldrb r2, [r3, r8] <== NOT EXECUTED
392c0: e1827427 orr r7, r2, r7, lsr #8 <== NOT EXECUTED
392c4: e7c37008 strb r7, [r3, r8] <== NOT EXECUTED
392c8: ea000011 b 39314 <fat_set_fat_cluster+0x25c> <== NOT EXECUTED
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
392cc: e59d3000 ldr r3, [sp] <== NOT EXECUTED
392d0: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
392d4: e18370b8 strh r7, [r3, r8] <== NOT EXECUTED
392d8: ea000006 b 392f8 <fat_set_fat_cluster+0x240> <== 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));
392dc: e59d3000 ldr r3, [sp] <== NOT EXECUTED
392e0: 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)) =
392e4: e7932008 ldr r2, [r3, r8] <== NOT EXECUTED
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
*((uint32_t *)(block0->buffer + ofs)) =
392e8: e3c7720f bic r7, r7, #-268435456 ; 0xf0000000 <== NOT EXECUTED
break;
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
*((uint32_t *)(block0->buffer + ofs)) =
392ec: e202220f and r2, r2, #-268435456 ; 0xf0000000 <== NOT EXECUTED
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
*((uint32_t *)(block0->buffer + ofs)) =
392f0: e1827007 orr r7, r2, r7 <== NOT EXECUTED
392f4: e7837008 str r7, [r3, r8] <== NOT EXECUTED
392f8: e3a03001 mov r3, #1 <== NOT EXECUTED
392fc: e5c43080 strb r3, [r4, #128] ; 0x80 <== NOT EXECUTED
39300: ea000003 b 39314 <fat_set_fat_cluster+0x25c> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
39304: eb000efd bl 3cf00 <__errno> <== NOT EXECUTED
39308: e3a03005 mov r3, #5 <== NOT EXECUTED
3930c: e5803000 str r3, [r0] <== NOT EXECUTED
39310: e3e00000 mvn r0, #0 <== NOT EXECUTED
break;
}
return RC_OK;
}
39314: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00022acc <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)
{
22acc: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
22ad0: e5904034 ldr r4, [r0, #52] ; 0x34 <== NOT EXECUTED
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
22ad4: e5d4500a ldrb r5, [r4, #10] <== NOT EXECUTED
22ad8: e2155004 ands r5, r5, #4 <== NOT EXECUTED
22adc: 0a000004 beq 22af4 <fat_shutdown_drive+0x28> <== NOT EXECUTED
{
rc = fat_fat32_update_fsinfo_sector(mt_entry, fs_info->vol.free_cls,
22ae0: e2841040 add r1, r4, #64 ; 0x40 <== NOT EXECUTED
22ae4: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
22ae8: ebffffdf bl 22a6c <fat_fat32_update_fsinfo_sector> <== NOT EXECUTED
fs_info->vol.next_cl);
if ( rc != RC_OK )
22aec: e2505000 subs r5, r0, #0 <== NOT EXECUTED
22af0: 13e05000 mvnne r5, #0 <== NOT EXECUTED
rc = -1;
}
fat_buf_release(fs_info);
22af4: e1a00004 mov r0, r4 <== NOT EXECUTED
22af8: ebfffee9 bl 226a4 <fat_buf_release> <== NOT EXECUTED
if (rtems_bdbuf_syncdev(fs_info->vol.dev) != RTEMS_SUCCESSFUL)
22afc: e2841054 add r1, r4, #84 ; 0x54 <== NOT EXECUTED
22b00: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
22b04: ebff8315 bl 3760 <rtems_bdbuf_syncdev> <== NOT EXECUTED
22b08: e3500000 cmp r0, #0 <== NOT EXECUTED
22b0c: 13e05000 mvnne r5, #0 <== NOT EXECUTED
22b10: e3a07000 mov r7, #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;
22b14: e5948064 ldr r8, [r4, #100] ; 0x64 <== NOT EXECUTED
22b18: e0888007 add r8, r8, r7 <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
22b1c: ea000000 b 22b24 <fat_shutdown_drive+0x58> <== NOT EXECUTED
free(node);
22b20: ebff92e3 bl 76b4 <free> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
22b24: e1a00008 mov r0, r8 <== NOT EXECUTED
22b28: ebffa64d bl c464 <_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 )
22b2c: e2506000 subs r6, r0, #0 <== NOT EXECUTED
22b30: 1afffffa bne 22b20 <fat_shutdown_drive+0x54> <== NOT EXECUTED
22b34: e287700c add r7, r7, #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++)
22b38: e3570018 cmp r7, #24 <== NOT EXECUTED
22b3c: 1afffff4 bne 22b14 <fat_shutdown_drive+0x48> <== NOT EXECUTED
}
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
22b40: e5947068 ldr r7, [r4, #104] ; 0x68 <== NOT EXECUTED
22b44: e0877006 add r7, r7, r6 <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
22b48: ea000000 b 22b50 <fat_shutdown_drive+0x84> <== NOT EXECUTED
free(node);
22b4c: ebff92d8 bl 76b4 <free> <== NOT EXECUTED
22b50: e1a00007 mov r0, r7 <== NOT EXECUTED
22b54: ebffa642 bl c464 <_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 )
22b58: e3500000 cmp r0, #0 <== NOT EXECUTED
22b5c: 1afffffa bne 22b4c <fat_shutdown_drive+0x80> <== NOT EXECUTED
22b60: e286600c add r6, r6, #12 <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
for (i = 0; i < FAT_HASH_SIZE; i++)
22b64: e3560018 cmp r6, #24 <== NOT EXECUTED
22b68: 1afffff4 bne 22b40 <fat_shutdown_drive+0x74> <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
22b6c: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED
22b70: ebff92cf bl 76b4 <free> <== NOT EXECUTED
free(fs_info->rhash);
22b74: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED
22b78: ebff92cd bl 76b4 <free> <== NOT EXECUTED
free(fs_info->uino);
22b7c: e594006c ldr r0, [r4, #108] ; 0x6c <== NOT EXECUTED
22b80: ebff92cb bl 76b4 <free> <== NOT EXECUTED
free(fs_info->sec_buf);
22b84: e5940088 ldr r0, [r4, #136] ; 0x88 <== NOT EXECUTED
22b88: ebff92c9 bl 76b4 <free> <== NOT EXECUTED
rtems_disk_release(fs_info->vol.dd);
22b8c: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED
22b90: ebff8e3d bl 648c <rtems_disk_release> <== NOT EXECUTED
if (rc)
22b94: e3550000 cmp r5, #0 <== NOT EXECUTED
22b98: 0a000002 beq 22ba8 <fat_shutdown_drive+0xdc> <== NOT EXECUTED
errno = EIO;
22b9c: eb0068d7 bl 3cf00 <__errno> <== NOT EXECUTED
22ba0: e3a03005 mov r3, #5 <== NOT EXECUTED
22ba4: e5803000 str r3, [r0] <== NOT EXECUTED
return rc;
}
22ba8: e1a00005 mov r0, r5 <== NOT EXECUTED
22bac: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00039a80 <fchdir>:
#include <rtems/seterr.h>
int fchdir(
int fd
)
{
39a80: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc, saved;
rtems_libio_check_fd( fd );
39a84: e59f3148 ldr r3, [pc, #328] ; 39bd4 <fchdir+0x154> <== NOT EXECUTED
39a88: e5933000 ldr r3, [r3] <== NOT EXECUTED
39a8c: e1500003 cmp r0, r3 <== NOT EXECUTED
#include <rtems/seterr.h>
int fchdir(
int fd
)
{
39a90: e24dd02c sub sp, sp, #44 ; 0x2c <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc, saved;
rtems_libio_check_fd( fd );
39a94: 2a000005 bcs 39ab0 <fchdir+0x30> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
39a98: e59f3138 ldr r3, [pc, #312] ; 39bd8 <fchdir+0x158> <== NOT EXECUTED
39a9c: e5934000 ldr r4, [r3] <== NOT EXECUTED
39aa0: e0844300 add r4, r4, r0, lsl #6 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
39aa4: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
39aa8: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED
39aac: 1a000002 bne 39abc <fchdir+0x3c> <== NOT EXECUTED
39ab0: eb000d12 bl 3cf00 <__errno> <== NOT EXECUTED
39ab4: e3a03009 mov r3, #9 <== NOT EXECUTED
39ab8: ea000011 b 39b04 <fchdir+0x84> <== NOT EXECUTED
/*
* Verify you can change directory into this node.
*/
if ( !iop->pathinfo.ops ) {
39abc: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED
39ac0: e3530000 cmp r3, #0 <== NOT EXECUTED
39ac4: 0a000002 beq 39ad4 <fchdir+0x54> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
if ( !iop->pathinfo.ops->node_type_h ) {
39ac8: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED
39acc: e3530000 cmp r3, #0 <== NOT EXECUTED
39ad0: 1a000002 bne 39ae0 <fchdir+0x60> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
39ad4: eb000d09 bl 3cf00 <__errno> <== NOT EXECUTED
39ad8: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
39adc: ea000008 b 39b04 <fchdir+0x84> <== NOT EXECUTED
}
if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) !=
39ae0: e2844018 add r4, r4, #24 <== NOT EXECUTED
39ae4: e1a00004 mov r0, r4 <== NOT EXECUTED
39ae8: e1a0e00f mov lr, pc <== NOT EXECUTED
39aec: e12fff13 bx r3 <== NOT EXECUTED
39af0: e3500001 cmp r0, #1 <== NOT EXECUTED
39af4: e1a06000 mov r6, r0 <== NOT EXECUTED
39af8: 0a000003 beq 39b0c <fchdir+0x8c> <== NOT EXECUTED
RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_set_errno_and_return_minus_one( ENOTDIR );
39afc: eb000cff bl 3cf00 <__errno> <== NOT EXECUTED
39b00: e3a03014 mov r3, #20 <== NOT EXECUTED
39b04: e5803000 str r3, [r0] <== NOT EXECUTED
39b08: ea00001c b 39b80 <fchdir+0x100> <== NOT EXECUTED
* but note the race condition. Threads who
* share their rtems_filesystem_current better
* be synchronized!
*/
saved = rtems_filesystem_current;
39b0c: e59f50c8 ldr r5, [pc, #200] ; 39bdc <fchdir+0x15c> <== NOT EXECUTED
39b10: e5957000 ldr r7, [r5] <== NOT EXECUTED
39b14: e287c004 add ip, r7, #4 <== NOT EXECUTED
39b18: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
39b1c: e28de004 add lr, sp, #4 <== NOT EXECUTED
39b20: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
39b24: e59c3000 ldr r3, [ip] <== NOT EXECUTED
39b28: e58e3000 str r3, [lr] <== NOT EXECUTED
rtems_filesystem_current = iop->pathinfo;
39b2c: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
39b30: e287e004 add lr, r7, #4 <== NOT EXECUTED
39b34: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
39b38: e5943000 ldr r3, [r4] <== NOT EXECUTED
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
39b3c: e3a0e000 mov lr, #0 <== NOT EXECUTED
* share their rtems_filesystem_current better
* be synchronized!
*/
saved = rtems_filesystem_current;
rtems_filesystem_current = iop->pathinfo;
39b40: e58c3000 str r3, [ip] <== NOT EXECUTED
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
39b44: e1a01006 mov r1, r6 <== NOT EXECUTED
39b48: e1a0200e mov r2, lr <== NOT EXECUTED
39b4c: e59f008c ldr r0, [pc, #140] ; 39be0 <fchdir+0x160> <== NOT EXECUTED
39b50: e28d3018 add r3, sp, #24 <== NOT EXECUTED
39b54: e58de000 str lr, [sp] <== NOT EXECUTED
39b58: ebff36b7 bl 763c <rtems_filesystem_evaluate_path> <== NOT EXECUTED
39b5c: e3500000 cmp r0, #0 <== NOT EXECUTED
39b60: 0a000008 beq 39b88 <fchdir+0x108> <== NOT EXECUTED
/* cloning failed; restore original and bail out */
rtems_filesystem_current = saved;
39b64: e595c000 ldr ip, [r5] <== NOT EXECUTED
39b68: e28d4004 add r4, sp, #4 <== NOT EXECUTED
39b6c: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
39b70: e28cc004 add ip, ip, #4 <== NOT EXECUTED
39b74: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
39b78: e5943000 ldr r3, [r4] <== NOT EXECUTED
39b7c: e58c3000 str r3, [ip] <== NOT EXECUTED
39b80: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
39b84: ea000010 b 39bcc <fchdir+0x14c> <== NOT EXECUTED
}
/* release the old one */
rtems_filesystem_freenode( &saved );
39b88: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
39b8c: e3530000 cmp r3, #0 <== NOT EXECUTED
39b90: 0a000004 beq 39ba8 <fchdir+0x128> <== NOT EXECUTED
39b94: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
39b98: e3530000 cmp r3, #0 <== NOT EXECUTED
39b9c: 128d0004 addne r0, sp, #4 <== NOT EXECUTED
39ba0: 11a0e00f movne lr, pc <== NOT EXECUTED
39ba4: 112fff13 bxne r3 <== NOT EXECUTED
rtems_filesystem_current = loc;
39ba8: e59f302c ldr r3, [pc, #44] ; 39bdc <fchdir+0x15c> <== NOT EXECUTED
39bac: e28d4018 add r4, sp, #24 <== NOT EXECUTED
39bb0: e593c000 ldr ip, [r3] <== NOT EXECUTED
39bb4: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
39bb8: e28cc004 add ip, ip, #4 <== NOT EXECUTED
39bbc: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
39bc0: e5943000 ldr r3, [r4] <== NOT EXECUTED
39bc4: e58c3000 str r3, [ip] <== NOT EXECUTED
39bc8: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
}
39bcc: e28dd02c add sp, sp, #44 ; 0x2c <== NOT EXECUTED
39bd0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00025084 <fchmod>:
mode_t mode
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
25084: e59f3068 ldr r3, [pc, #104] ; 250f4 <fchmod+0x70> <== NOT EXECUTED
25088: e5932000 ldr r2, [r3] <== NOT EXECUTED
2508c: e1500002 cmp r0, r2 <== NOT EXECUTED
int fchmod(
int fd,
mode_t mode
)
{
25090: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
25094: 2a000005 bcs 250b0 <fchmod+0x2c> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
25098: e59f3058 ldr r3, [pc, #88] ; 250f8 <fchmod+0x74> <== NOT EXECUTED
2509c: e5933000 ldr r3, [r3] <== NOT EXECUTED
250a0: e0833300 add r3, r3, r0, lsl #6 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
250a4: e5932014 ldr r2, [r3, #20] <== NOT EXECUTED
250a8: e3120c01 tst r2, #256 ; 0x100 <== NOT EXECUTED
250ac: 1a000002 bne 250bc <fchmod+0x38> <== NOT EXECUTED
250b0: eb005f92 bl 3cf00 <__errno> <== NOT EXECUTED
250b4: e3a03009 mov r3, #9 <== NOT EXECUTED
250b8: ea000005 b 250d4 <fchmod+0x50> <== NOT EXECUTED
/*
* Now process the fchmod().
*/
if ( !iop->handlers->fchmod_h )
250bc: e593203c ldr r2, [r3, #60] ; 0x3c <== NOT EXECUTED
250c0: e592201c ldr r2, [r2, #28] <== NOT EXECUTED
250c4: e3520000 cmp r2, #0 <== NOT EXECUTED
250c8: 1a000004 bne 250e0 <fchmod+0x5c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
250cc: eb005f8b bl 3cf00 <__errno> <== NOT EXECUTED
250d0: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
250d4: e5803000 str r3, [r0] <== NOT EXECUTED
250d8: e3e00000 mvn r0, #0 <== NOT EXECUTED
250dc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode );
250e0: e2830018 add r0, r3, #24 <== NOT EXECUTED
250e4: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
250e8: e1a0e00f mov lr, pc <== NOT EXECUTED
250ec: e593f01c ldr pc, [r3, #28] <== NOT EXECUTED
}
250f0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
000250fc <fchown>:
gid_t group
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
250fc: e59f3088 ldr r3, [pc, #136] ; 2518c <fchown+0x90> <== NOT EXECUTED
25100: e5933000 ldr r3, [r3] <== NOT EXECUTED
int fchown(
int fd,
uid_t owner,
gid_t group
)
{
25104: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED
25108: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2510c: e1500003 cmp r0, r3 <== NOT EXECUTED
int fchown(
int fd,
uid_t owner,
gid_t group
)
{
25110: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
25114: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED
25118: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2511c: 2a000005 bcs 25138 <fchown+0x3c> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
25120: e59f3068 ldr r3, [pc, #104] ; 25190 <fchown+0x94> <== NOT EXECUTED
25124: e5933000 ldr r3, [r3] <== NOT EXECUTED
25128: e0830300 add r0, r3, r0, lsl #6 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
2512c: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED
25130: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED
25134: 1a000002 bne 25144 <fchown+0x48> <== NOT EXECUTED
25138: eb005f70 bl 3cf00 <__errno> <== NOT EXECUTED
2513c: e3a03009 mov r3, #9 <== NOT EXECUTED
25140: ea00000a b 25170 <fchown+0x74> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
25144: e3130004 tst r3, #4 <== NOT EXECUTED
25148: 1a000002 bne 25158 <fchown+0x5c> <== NOT EXECUTED
2514c: eb005f6b bl 3cf00 <__errno> <== NOT EXECUTED
25150: e3a03016 mov r3, #22 <== NOT EXECUTED
25154: ea000005 b 25170 <fchown+0x74> <== NOT EXECUTED
if ( !iop->pathinfo.ops->chown_h )
25158: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED
2515c: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED
25160: e3530000 cmp r3, #0 <== NOT EXECUTED
25164: 1a000004 bne 2517c <fchown+0x80> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
25168: eb005f64 bl 3cf00 <__errno> <== NOT EXECUTED
2516c: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
25170: e5803000 str r3, [r0] <== NOT EXECUTED
25174: e3e00000 mvn r0, #0 <== NOT EXECUTED
25178: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
return (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group );
2517c: e2800018 add r0, r0, #24 <== NOT EXECUTED
25180: e1a0e00f mov lr, pc <== NOT EXECUTED
25184: e12fff13 bx r3 <== NOT EXECUTED
}
25188: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00039be4 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
39be4: e92d000e push {r1, r2, r3}
39be8: e92d40f1 push {r0, r4, r5, r6, r7, lr}
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
39bec: e59f31a4 ldr r3, [pc, #420] ; 39d98 <fcntl+0x1b4>
39bf0: e5933000 ldr r3, [r3]
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
39bf4: e28d201c add r2, sp, #28
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
39bf8: e1500003 cmp r0, r3
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
39bfc: e58d2000 str r2, [sp]
int fcntl(
int fd,
int cmd,
...
)
{
39c00: e59d7018 ldr r7, [sp, #24]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
39c04: 2a000005 bcs 39c20 <fcntl+0x3c>
iop = rtems_libio_iop( fd );
39c08: e59f118c ldr r1, [pc, #396] ; 39d9c <fcntl+0x1b8>
39c0c: e591c000 ldr ip, [r1]
39c10: e08c4300 add r4, ip, r0, lsl #6
rtems_libio_check_is_open(iop);
39c14: e5940014 ldr r0, [r4, #20]
39c18: e3100c01 tst r0, #256 ; 0x100
39c1c: 1a000002 bne 39c2c <fcntl+0x48>
39c20: eb000cb6 bl 3cf00 <__errno> <== NOT EXECUTED
39c24: e3a03009 mov r3, #9 <== NOT EXECUTED
39c28: ea000045 b 39d44 <fcntl+0x160> <== NOT EXECUTED
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
39c2c: e3570009 cmp r7, #9
39c30: 979ff107 ldrls pc, [pc, r7, lsl #2]
39c34: ea000040 b 39d3c <fcntl+0x158>
39c38: 00039c60 .word 0x00039c60
39c3c: 00039ccc .word 0x00039ccc
39c40: 00039cd8 .word 0x00039cd8
39c44: 00039cf8 .word 0x00039cf8
39c48: 00039d04 .word 0x00039d04
39c4c: 00039d30 .word 0x00039d30
39c50: 00039d30 .word 0x00039d30
39c54: 00039d30 .word 0x00039d30
39c58: 00039d30 .word 0x00039d30
39c5c: 00039d30 .word 0x00039d30
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
39c60: e5922000 ldr r2, [r2]
if ( fd2 )
39c64: e3520000 cmp r2, #0
39c68: 0a000003 beq 39c7c <fcntl+0x98>
diop = rtems_libio_iop( fd2 );
39c6c: e1520003 cmp r2, r3 <== NOT EXECUTED
39c70: 23a0c000 movcs ip, #0 <== NOT EXECUTED
39c74: 308cc302 addcc ip, ip, r2, lsl #6 <== NOT EXECUTED
39c78: ea000002 b 39c88 <fcntl+0xa4> <== NOT EXECUTED
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
39c7c: ebff3797 bl 7ae0 <rtems_libio_allocate>
if ( diop == 0 ) {
39c80: e250c000 subs ip, r0, #0
39c84: 0a00003e beq 39d84 <fcntl+0x1a0>
}
diop->handlers = iop->handlers;
diop->file_info = iop->file_info;
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
39c88: e2846018 add r6, r4, #24
39c8c: e8b6000f ldm r6!, {r0, r1, r2, r3}
39c90: e28c5018 add r5, ip, #24
39c94: e8a5000f stmia r5!, {r0, r1, r2, r3}
ret = (int) (diop - rtems_libio_iops);
39c98: e59f30fc ldr r3, [pc, #252] ; 39d9c <fcntl+0x1b8>
39c9c: e5933000 ldr r3, [r3]
}
diop->handlers = iop->handlers;
diop->file_info = iop->file_info;
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
39ca0: e5966000 ldr r6, [r6]
ret = -1;
break;
}
}
diop->handlers = iop->handlers;
39ca4: e594003c ldr r0, [r4, #60] ; 0x3c
diop->file_info = iop->file_info;
39ca8: e5941038 ldr r1, [r4, #56] ; 0x38
diop->flags = iop->flags;
39cac: e5942014 ldr r2, [r4, #20]
diop->pathinfo = iop->pathinfo;
ret = (int) (diop - rtems_libio_iops);
39cb0: e063300c rsb r3, r3, ip
}
diop->handlers = iop->handlers;
diop->file_info = iop->file_info;
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
39cb4: e5856000 str r6, [r5]
ret = -1;
break;
}
}
diop->handlers = iop->handlers;
39cb8: e58c003c str r0, [ip, #60] ; 0x3c
diop->file_info = iop->file_info;
39cbc: e58c1038 str r1, [ip, #56] ; 0x38
diop->flags = iop->flags;
39cc0: e58c2014 str r2, [ip, #20]
diop->pathinfo = iop->pathinfo;
ret = (int) (diop - rtems_libio_iops);
39cc4: e1a05343 asr r5, r3, #6
39cc8: ea00001f b 39d4c <fcntl+0x168>
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
39ccc: e1a055a0 lsr r5, r0, #11
39cd0: e2055001 and r5, r5, #1
39cd4: ea00001e b 39d54 <fcntl+0x170>
* 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 ) )
39cd8: e5925000 ldr r5, [r2]
39cdc: e3550000 cmp r5, #0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
39ce0: 13800b02 orrne r0, r0, #2048 ; 0x800
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
39ce4: 03c00b02 biceq r0, r0, #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;
39ce8: 15840014 strne r0, [r4, #20]
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
39cec: 05840014 streq r0, [r4, #20]
* 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 ) )
39cf0: 0a000017 beq 39d54 <fcntl+0x170>
39cf4: ea00000b b 39d28 <fcntl+0x144>
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
39cf8: ebff370f bl 793c <rtems_libio_to_fcntl_flags>
39cfc: e1a05000 mov r5, r0
39d00: ea000011 b 39d4c <fcntl+0x168>
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
39d04: e5920000 ldr r0, [r2]
39d08: ebff37a1 bl 7b94 <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
39d0c: e5943014 ldr r3, [r4, #20]
39d10: e59f2088 ldr r2, [pc, #136] ; 39da0 <fcntl+0x1bc>
39d14: e3c33c02 bic r3, r3, #512 ; 0x200
39d18: e0002002 and r2, r0, r2
39d1c: e3c33001 bic r3, r3, #1
39d20: e1823003 orr r3, r2, r3
39d24: e5843014 str r3, [r4, #20]
39d28: e3a05000 mov r5, #0
39d2c: ea000008 b 39d54 <fcntl+0x170>
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
39d30: eb000c72 bl 3cf00 <__errno>
39d34: e3a03086 mov r3, #134 ; 0x86
39d38: ea000001 b 39d44 <fcntl+0x160>
ret = -1;
break;
default:
errno = EINVAL;
39d3c: eb000c6f bl 3cf00 <__errno>
39d40: e3a03016 mov r3, #22
39d44: e5803000 str r3, [r0]
39d48: ea00000d b 39d84 <fcntl+0x1a0>
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
39d4c: e3550000 cmp r5, #0
39d50: ba00000c blt 39d88 <fcntl+0x1a4>
if (iop->handlers->fcntl_h) {
39d54: e594303c ldr r3, [r4, #60] ; 0x3c
39d58: e5933030 ldr r3, [r3, #48] ; 0x30
39d5c: e3530000 cmp r3, #0
39d60: 0a000008 beq 39d88 <fcntl+0x1a4>
int err = (*iop->handlers->fcntl_h)( cmd, iop );
39d64: e1a01004 mov r1, r4
39d68: e1a00007 mov r0, r7
39d6c: e1a0e00f mov lr, pc
39d70: e12fff13 bx r3
if (err) {
39d74: e2504000 subs r4, r0, #0
39d78: 0a000002 beq 39d88 <fcntl+0x1a4>
errno = err;
39d7c: eb000c5f bl 3cf00 <__errno> <== NOT EXECUTED
39d80: e5804000 str r4, [r0] <== NOT EXECUTED
39d84: e3e05000 mvn r5, #0
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
39d88: e1a00005 mov r0, r5
39d8c: e8bd40f8 pop {r3, r4, r5, r6, r7, lr}
39d90: e28dd00c add sp, sp, #12
39d94: e12fff1e bx lr
00002970 <fdatasync>:
int fd
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2970: e59f3068 ldr r3, [pc, #104] ; 29e0 <fdatasync+0x70>
2974: e5933000 ldr r3, [r3]
2978: e1500003 cmp r0, r3
#include <rtems/seterr.h>
int fdatasync(
int fd
)
{
297c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2980: 2a000007 bcs 29a4 <fdatasync+0x34>
iop = rtems_libio_iop( fd );
2984: e59f3058 ldr r3, [pc, #88] ; 29e4 <fdatasync+0x74>
2988: e5933000 ldr r3, [r3]
298c: e0830300 add r0, r3, r0, lsl #6
rtems_libio_check_is_open(iop);
2990: e5903014 ldr r3, [r0, #20]
2994: e3130c01 tst r3, #256 ; 0x100
2998: 0a000001 beq 29a4 <fdatasync+0x34>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
299c: e3130004 tst r3, #4
29a0: 1a000002 bne 29b0 <fdatasync+0x40>
29a4: eb002f08 bl e5cc <__errno>
29a8: e3a03009 mov r3, #9
29ac: ea000005 b 29c8 <fdatasync+0x58>
/*
* Now process the fdatasync().
*/
if ( !iop->handlers->fdatasync_h )
29b0: e590303c ldr r3, [r0, #60] ; 0x3c
29b4: e593302c ldr r3, [r3, #44] ; 0x2c
29b8: e3530000 cmp r3, #0
29bc: 1a000004 bne 29d4 <fdatasync+0x64>
rtems_set_errno_and_return_minus_one( ENOTSUP );
29c0: eb002f01 bl e5cc <__errno>
29c4: e3a03086 mov r3, #134 ; 0x86
29c8: e5803000 str r3, [r0]
29cc: e3e00000 mvn r0, #0
29d0: e49df004 pop {pc} ; (ldr pc, [sp], #4)
return (*iop->handlers->fdatasync_h)( iop );
29d4: e1a0e00f mov lr, pc <== NOT EXECUTED
29d8: e12fff13 bx r3 <== NOT EXECUTED
}
29dc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00008cb4 <fifo_open>:
)
{
pipe_control_t *pipe;
int err = 0;
if (rtems_semaphore_obtain(rtems_pipe_semaphore,
8cb4: e59f331c ldr r3, [pc, #796] ; 8fd8 <fifo_open+0x324>
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
8cb8: e92d45f3 push {r0, r1, r4, r5, r6, r7, r8, sl, lr}
8cbc: e1a07001 mov r7, r1
)
{
pipe_control_t *pipe;
int err = 0;
if (rtems_semaphore_obtain(rtems_pipe_semaphore,
8cc0: e3a01000 mov r1, #0
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
8cc4: e1a06000 mov r6, r0
)
{
pipe_control_t *pipe;
int err = 0;
if (rtems_semaphore_obtain(rtems_pipe_semaphore,
8cc8: e1a02001 mov r2, r1
8ccc: e5930000 ldr r0, [r3]
8cd0: ebfff131 bl 519c <rtems_semaphore_obtain>
8cd4: e250a000 subs sl, r0, #0
8cd8: 13e05003 mvnne r5, #3
8cdc: 1a0000bb bne 8fd0 <fifo_open+0x31c>
RTEMS_WAIT, RTEMS_NO_TIMEOUT) != RTEMS_SUCCESSFUL)
return -EINTR;
pipe = *pipep;
8ce0: e5964000 ldr r4, [r6] <== NOT EXECUTED
if (pipe == NULL) {
8ce4: e3540000 cmp r4, #0 <== NOT EXECUTED
8ce8: 1a00003b bne 8ddc <fifo_open+0x128> <== NOT EXECUTED
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
8cec: e3a00034 mov r0, #52 ; 0x34 <== NOT EXECUTED
8cf0: ebffe542 bl 2200 <malloc> <== NOT EXECUTED
if (pipe == NULL)
8cf4: e3500000 cmp r0, #0 <== NOT EXECUTED
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
8cf8: e1a04000 mov r4, r0 <== NOT EXECUTED
8cfc: e1a08000 mov r8, r0 <== NOT EXECUTED
if (pipe == NULL)
8d00: 0a000033 beq 8dd4 <fifo_open+0x120> <== NOT EXECUTED
return err;
memset(pipe, 0, sizeof(pipe_control_t));
8d04: e1a0100a mov r1, sl <== NOT EXECUTED
8d08: e3a02034 mov r2, #52 ; 0x34 <== NOT EXECUTED
8d0c: eb0013f6 bl dcec <memset> <== NOT EXECUTED
pipe->Size = PIPE_BUF;
8d10: e3a00c02 mov r0, #512 ; 0x200 <== NOT EXECUTED
8d14: e5840004 str r0, [r4, #4] <== NOT EXECUTED
pipe->Buffer = malloc(pipe->Size);
8d18: ebffe538 bl 2200 <malloc> <== NOT EXECUTED
if (! pipe->Buffer)
8d1c: 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);
8d20: e5840000 str r0, [r4] <== NOT EXECUTED
if (! pipe->Buffer)
8d24: 0a000028 beq 8dcc <fifo_open+0x118> <== NOT EXECUTED
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
8d28: e59f52ac ldr r5, [pc, #684] ; 8fdc <fifo_open+0x328> <== NOT EXECUTED
8d2c: e59f02ac ldr r0, [pc, #684] ; 8fe0 <fifo_open+0x32c> <== NOT EXECUTED
8d30: e5d53000 ldrb r3, [r5] <== NOT EXECUTED
8d34: e1a0100a mov r1, sl <== NOT EXECUTED
8d38: e1830000 orr r0, r3, r0 <== NOT EXECUTED
8d3c: e1a0200a mov r2, sl <== NOT EXECUTED
8d40: e284302c add r3, r4, #44 ; 0x2c <== NOT EXECUTED
8d44: eb000678 bl a72c <rtems_barrier_create> <== NOT EXECUTED
8d48: e2501000 subs r1, r0, #0 <== NOT EXECUTED
8d4c: 1a00001c bne 8dc4 <fifo_open+0x110> <== 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(
8d50: e5d53000 ldrb r3, [r5] <== NOT EXECUTED
8d54: e59f0288 ldr r0, [pc, #648] ; 8fe4 <fifo_open+0x330> <== NOT EXECUTED
8d58: e1a02001 mov r2, r1 <== NOT EXECUTED
8d5c: e1830000 orr r0, r3, r0 <== NOT EXECUTED
8d60: e2843030 add r3, r4, #48 ; 0x30 <== NOT EXECUTED
8d64: eb000670 bl a72c <rtems_barrier_create> <== NOT EXECUTED
8d68: e2503000 subs r3, r0, #0 <== NOT EXECUTED
8d6c: 1a000012 bne 8dbc <fifo_open+0x108> <== 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(
8d70: e5d52000 ldrb r2, [r5] <== NOT EXECUTED
8d74: e59f026c ldr r0, [pc, #620] ; 8fe8 <fifo_open+0x334> <== NOT EXECUTED
8d78: e284c028 add ip, r4, #40 ; 0x28 <== NOT EXECUTED
8d7c: e1820000 orr r0, r2, r0 <== NOT EXECUTED
8d80: e3a01001 mov r1, #1 <== NOT EXECUTED
8d84: e3a02010 mov r2, #16 <== NOT EXECUTED
8d88: e58dc000 str ip, [sp] <== NOT EXECUTED
8d8c: ebfff070 bl 4f54 <rtems_semaphore_create> <== NOT EXECUTED
8d90: e3500000 cmp r0, #0 <== NOT EXECUTED
8d94: 1a000006 bne 8db4 <fifo_open+0x100> <== NOT EXECUTED
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
8d98: e5d53000 ldrb r3, [r5] <== NOT EXECUTED
8d9c: e353007a cmp r3, #122 ; 0x7a <== NOT EXECUTED
8da0: e2833001 add r3, r3, #1 <== NOT EXECUTED
8da4: e5c53000 strb r3, [r5] <== NOT EXECUTED
c = 'a';
8da8: 03a03061 moveq r3, #97 ; 0x61 <== NOT EXECUTED
8dac: 05c53000 strbeq r3, [r5] <== NOT EXECUTED
8db0: ea000009 b 8ddc <fifo_open+0x128> <== NOT EXECUTED
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
8db4: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED
8db8: eb000689 bl a7e4 <rtems_barrier_delete> <== NOT EXECUTED
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
8dbc: e598002c ldr r0, [r8, #44] ; 0x2c <== NOT EXECUTED
8dc0: eb000687 bl a7e4 <rtems_barrier_delete> <== NOT EXECUTED
err_rbar:
free(pipe->Buffer);
8dc4: e5980000 ldr r0, [r8] <== NOT EXECUTED
8dc8: ebffe440 bl 1ed0 <free> <== NOT EXECUTED
err_buf:
free(pipe);
8dcc: e1a00008 mov r0, r8 <== NOT EXECUTED
8dd0: ebffe43e bl 1ed0 <free> <== NOT EXECUTED
8dd4: e3e0500b mvn r5, #11 <== NOT EXECUTED
8dd8: ea00000d b 8e14 <fifo_open+0x160> <== NOT EXECUTED
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
8ddc: e3a01000 mov r1, #0 <== NOT EXECUTED
8de0: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
8de4: e1a02001 mov r2, r1 <== NOT EXECUTED
8de8: ebfff0eb bl 519c <rtems_semaphore_obtain> <== NOT EXECUTED
err = -EINTR;
if (*pipep == NULL) {
8dec: e5963000 ldr r3, [r6] <== NOT EXECUTED
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
8df0: e3500000 cmp r0, #0 <== NOT EXECUTED
8df4: 01a05000 moveq r5, r0 <== NOT EXECUTED
8df8: 13e05003 mvnne r5, #3 <== NOT EXECUTED
err = -EINTR;
if (*pipep == NULL) {
8dfc: e3530000 cmp r3, #0 <== NOT EXECUTED
8e00: 1a000003 bne 8e14 <fifo_open+0x160> <== NOT EXECUTED
if (err)
8e04: e3550000 cmp r5, #0 <== NOT EXECUTED
pipe_free(pipe);
else
*pipep = pipe;
8e08: 05864000 streq r4, [r6] <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
err = -EINTR;
if (*pipep == NULL) {
if (err)
pipe_free(pipe);
8e0c: 11a00004 movne r0, r4 <== NOT EXECUTED
8e10: 1bffff5b blne 8b84 <pipe_free> <== NOT EXECUTED
else
*pipep = pipe;
}
out:
rtems_semaphore_release(rtems_pipe_semaphore);
8e14: e59f31bc ldr r3, [pc, #444] ; 8fd8 <fifo_open+0x324> <== NOT EXECUTED
8e18: e5930000 ldr r0, [r3] <== NOT EXECUTED
8e1c: ebfff124 bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
8e20: e3550000 cmp r5, #0 <== NOT EXECUTED
8e24: 1a000069 bne 8fd0 <fifo_open+0x31c> <== NOT EXECUTED
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
8e28: e5973014 ldr r3, [r7, #20] <== NOT EXECUTED
8e2c: e2033006 and r3, r3, #6 <== NOT EXECUTED
8e30: e3530004 cmp r3, #4 <== NOT EXECUTED
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
8e34: e5964000 ldr r4, [r6] <== NOT EXECUTED
switch (LIBIO_ACCMODE(iop)) {
8e38: 0a000024 beq 8ed0 <fifo_open+0x21c> <== NOT EXECUTED
8e3c: e3530006 cmp r3, #6 <== NOT EXECUTED
8e40: 0a000047 beq 8f64 <fifo_open+0x2b0> <== NOT EXECUTED
8e44: e3530002 cmp r3, #2 <== NOT EXECUTED
8e48: 1a000059 bne 8fb4 <fifo_open+0x300> <== NOT EXECUTED
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
8e4c: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
8e50: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
8e54: e3530000 cmp r3, #0 <== NOT EXECUTED
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
8e58: e2822001 add r2, r2, #1 <== NOT EXECUTED
if (pipe->Readers ++ == 0)
8e5c: e2833001 add r3, r3, #1 <== NOT EXECUTED
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
8e60: e5842020 str r2, [r4, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
8e64: e5843010 str r3, [r4, #16] <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
8e68: 05940030 ldreq r0, [r4, #48] ; 0x30 <== NOT EXECUTED
8e6c: 028d1004 addeq r1, sp, #4 <== NOT EXECUTED
8e70: 0b000673 bleq a844 <rtems_barrier_release> <== NOT EXECUTED
if (pipe->Writers == 0) {
8e74: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
8e78: e3530000 cmp r3, #0 <== NOT EXECUTED
8e7c: 1a00004c bne 8fb4 <fifo_open+0x300> <== NOT EXECUTED
/* Not an error */
if (LIBIO_NODELAY(iop))
8e80: e5973014 ldr r3, [r7, #20] <== NOT EXECUTED
8e84: e3130001 tst r3, #1 <== NOT EXECUTED
8e88: 1a000049 bne 8fb4 <fifo_open+0x300> <== NOT EXECUTED
break;
prevCounter = pipe->writerCounter;
8e8c: e5948024 ldr r8, [r4, #36] ; 0x24 <== NOT EXECUTED
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
8e90: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
8e94: ebfff106 bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_READWAIT(pipe))
8e98: e3a01000 mov r1, #0 <== NOT EXECUTED
8e9c: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED
8ea0: eb00067d bl a89c <rtems_barrier_wait> <== NOT EXECUTED
8ea4: e2501000 subs r1, r0, #0 <== NOT EXECUTED
goto out_error;
if (! PIPE_LOCK(pipe))
8ea8: 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))
8eac: 1a000043 bne 8fc0 <fifo_open+0x30c> <== NOT EXECUTED
goto out_error;
if (! PIPE_LOCK(pipe))
8eb0: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
8eb4: ebfff0b8 bl 519c <rtems_semaphore_obtain> <== NOT EXECUTED
8eb8: e3500000 cmp r0, #0 <== NOT EXECUTED
8ebc: 1a00003f bne 8fc0 <fifo_open+0x30c> <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->writerCounter);
8ec0: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED
8ec4: e1580003 cmp r8, r3 <== NOT EXECUTED
8ec8: 0afffff0 beq 8e90 <fifo_open+0x1dc> <== NOT EXECUTED
8ecc: ea000038 b 8fb4 <fifo_open+0x300> <== NOT EXECUTED
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
8ed0: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
8ed4: e5942024 ldr r2, [r4, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
8ed8: e3530000 cmp r3, #0 <== NOT EXECUTED
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
8edc: e2822001 add r2, r2, #1 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
8ee0: e2833001 add r3, r3, #1 <== NOT EXECUTED
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
8ee4: e5842024 str r2, [r4, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
8ee8: e5843014 str r3, [r4, #20] <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
8eec: 0594002c ldreq r0, [r4, #44] ; 0x2c <== NOT EXECUTED
8ef0: 028d1004 addeq r1, sp, #4 <== NOT EXECUTED
8ef4: 0b000652 bleq a844 <rtems_barrier_release> <== NOT EXECUTED
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
8ef8: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
8efc: e3530000 cmp r3, #0 <== NOT EXECUTED
8f00: 1a00002b bne 8fb4 <fifo_open+0x300> <== NOT EXECUTED
8f04: e5973014 ldr r3, [r7, #20] <== NOT EXECUTED
8f08: e3130001 tst r3, #1 <== NOT EXECUTED
err = -ENXIO;
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
8f0c: 05948020 ldreq r8, [r4, #32] <== NOT EXECUTED
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
8f10: 0a000003 beq 8f24 <fifo_open+0x270> <== NOT EXECUTED
PIPE_UNLOCK(pipe);
8f14: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
8f18: ebfff0e5 bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
8f1c: e3e05005 mvn r5, #5 <== NOT EXECUTED
err = -ENXIO;
goto out_error;
8f20: ea000027 b 8fc4 <fifo_open+0x310> <== NOT EXECUTED
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
8f24: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
8f28: ebfff0e1 bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_WRITEWAIT(pipe))
8f2c: e3a01000 mov r1, #0 <== NOT EXECUTED
8f30: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED
8f34: eb000658 bl a89c <rtems_barrier_wait> <== NOT EXECUTED
8f38: e2501000 subs r1, r0, #0 <== NOT EXECUTED
goto out_error;
if (! PIPE_LOCK(pipe))
8f3c: e1a02001 mov r2, r1 <== NOT EXECUTED
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
8f40: 1a00001e bne 8fc0 <fifo_open+0x30c> <== NOT EXECUTED
goto out_error;
if (! PIPE_LOCK(pipe))
8f44: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
8f48: ebfff093 bl 519c <rtems_semaphore_obtain> <== NOT EXECUTED
8f4c: e3500000 cmp r0, #0 <== NOT EXECUTED
8f50: 1a00001a bne 8fc0 <fifo_open+0x30c> <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->readerCounter);
8f54: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED
8f58: e1580003 cmp r8, r3 <== NOT EXECUTED
8f5c: 0afffff0 beq 8f24 <fifo_open+0x270> <== NOT EXECUTED
8f60: ea000013 b 8fb4 <fifo_open+0x300> <== NOT EXECUTED
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
8f64: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
8f68: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
8f6c: e3530000 cmp r3, #0 <== NOT EXECUTED
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
8f70: e2822001 add r2, r2, #1 <== NOT EXECUTED
if (pipe->Readers ++ == 0)
8f74: e2833001 add r3, r3, #1 <== NOT EXECUTED
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
8f78: e5842020 str r2, [r4, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
8f7c: e5843010 str r3, [r4, #16] <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
8f80: 05940030 ldreq r0, [r4, #48] ; 0x30 <== NOT EXECUTED
8f84: 028d1004 addeq r1, sp, #4 <== NOT EXECUTED
8f88: 0b00062d bleq a844 <rtems_barrier_release> <== NOT EXECUTED
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
8f8c: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
8f90: e5942024 ldr r2, [r4, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
8f94: e3530000 cmp r3, #0 <== NOT EXECUTED
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
8f98: e2822001 add r2, r2, #1 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
8f9c: e2833001 add r3, r3, #1 <== NOT EXECUTED
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
8fa0: e5842024 str r2, [r4, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
8fa4: e5843014 str r3, [r4, #20] <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
8fa8: 0594002c ldreq r0, [r4, #44] ; 0x2c <== NOT EXECUTED
8fac: 028d1004 addeq r1, sp, #4 <== NOT EXECUTED
8fb0: 0b000623 bleq a844 <rtems_barrier_release> <== NOT EXECUTED
break;
}
PIPE_UNLOCK(pipe);
8fb4: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
8fb8: ebfff0bd bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
return 0;
8fbc: ea000003 b 8fd0 <fifo_open+0x31c> <== NOT EXECUTED
8fc0: e3e05003 mvn r5, #3 <== NOT EXECUTED
out_error:
pipe_release(pipep, iop);
8fc4: e1a00006 mov r0, r6 <== NOT EXECUTED
8fc8: e1a01007 mov r1, r7 <== NOT EXECUTED
8fcc: ebfffef9 bl 8bb8 <pipe_release> <== NOT EXECUTED
return err;
}
8fd0: e1a00005 mov r0, r5
8fd4: e8bd85fc pop {r2, r3, r4, r5, r6, r7, r8, sl, pc}
000029e8 <fpathconf>:
{
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
29e8: e59f30ec ldr r3, [pc, #236] ; 2adc <fpathconf+0xf4>
29ec: e5933000 ldr r3, [r3]
29f0: e1500003 cmp r0, r3
long fpathconf(
int fd,
int name
)
{
29f4: 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);
29f8: 2a000005 bcs 2a14 <fpathconf+0x2c>
iop = rtems_libio_iop(fd);
29fc: e59f30dc ldr r3, [pc, #220] ; 2ae0 <fpathconf+0xf8>
2a00: e5933000 ldr r3, [r3]
2a04: e0830300 add r0, r3, r0, lsl #6
rtems_libio_check_is_open(iop);
2a08: e5903014 ldr r3, [r0, #20]
2a0c: e3130c01 tst r3, #256 ; 0x100
2a10: 1a000004 bne 2a28 <fpathconf+0x40>
2a14: eb002eec bl e5cc <__errno>
2a18: e3a03009 mov r3, #9
2a1c: e5803000 str r3, [r0]
2a20: e3e00000 mvn r0, #0
2a24: e49df004 pop {pc} ; (ldr pc, [sp], #4)
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
2a28: e5903028 ldr r3, [r0, #40] ; 0x28
switch ( name ) {
2a2c: e351000b cmp r1, #11
2a30: 979ff101 ldrls pc, [pc, r1, lsl #2]
2a34: ea000023 b 2ac8 <fpathconf+0xe0>
2a38: 00002a68 .word 0x00002a68
2a3c: 00002a70 .word 0x00002a70
2a40: 00002a78 .word 0x00002a78
2a44: 00002a80 .word 0x00002a80
2a48: 00002a88 .word 0x00002a88
2a4c: 00002a90 .word 0x00002a90
2a50: 00002a98 .word 0x00002a98
2a54: 00002aa0 .word 0x00002aa0
2a58: 00002aa8 .word 0x00002aa8
2a5c: 00002ab0 .word 0x00002ab0
2a60: 00002ab8 .word 0x00002ab8
2a64: 00002ac0 .word 0x00002ac0
case _PC_LINK_MAX:
return_value = the_limits->link_max;
2a68: e5930038 ldr r0, [r3, #56] ; 0x38
break;
2a6c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
2a70: e593003c ldr r0, [r3, #60] ; 0x3c
break;
2a74: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
2a78: e5930040 ldr r0, [r3, #64] ; 0x40
break;
2a7c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_NAME_MAX:
return_value = the_limits->name_max;
2a80: e5930044 ldr r0, [r3, #68] ; 0x44
break;
2a84: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PATH_MAX:
return_value = the_limits->path_max;
2a88: e5930048 ldr r0, [r3, #72] ; 0x48
break;
2a8c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
2a90: e593004c ldr r0, [r3, #76] ; 0x4c
break;
2a94: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
2a98: e5930054 ldr r0, [r3, #84] ; 0x54
break;
2a9c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
2aa0: e5930058 ldr r0, [r3, #88] ; 0x58
break;
2aa4: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
2aa8: e5930064 ldr r0, [r3, #100] ; 0x64
break;
2aac: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
2ab0: e5930050 ldr r0, [r3, #80] ; 0x50
break;
2ab4: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
2ab8: e593005c ldr r0, [r3, #92] ; 0x5c
break;
2abc: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
2ac0: e5930060 ldr r0, [r3, #96] ; 0x60
break;
2ac4: e49df004 pop {pc} ; (ldr pc, [sp], #4)
default:
rtems_set_errno_and_return_minus_one( EINVAL );
2ac8: eb002ebf bl e5cc <__errno>
2acc: e3a03016 mov r3, #22
2ad0: e5803000 str r3, [r0]
2ad4: e3e00000 mvn r0, #0
break;
}
return return_value;
}
2ad8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
00001ed0 <free>:
void free(
void *ptr
)
{
MSBUMP(free_calls, 1);
1ed0: e59f3088 ldr r3, [pc, #136] ; 1f60 <free+0x90>
1ed4: e593200c ldr r2, [r3, #12]
1ed8: e92d4030 push {r4, r5, lr}
1edc: e2822001 add r2, r2, #1
if ( !ptr )
1ee0: e2504000 subs r4, r0, #0
void free(
void *ptr
)
{
MSBUMP(free_calls, 1);
1ee4: e583200c str r2, [r3, #12]
if ( !ptr )
1ee8: 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()) &&
1eec: e59f3070 ldr r3, [pc, #112] ; 1f64 <free+0x94>
1ef0: e5933000 ldr r3, [r3]
1ef4: e3530003 cmp r3, #3
1ef8: 1a000005 bne 1f14 <free+0x44>
1efc: eb000065 bl 2098 <malloc_is_system_state_OK>
1f00: e3500000 cmp r0, #0
1f04: 1a000002 bne 1f14 <free+0x44>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
1f08: e1a00004 mov r0, r4 <== NOT EXECUTED
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
1f0c: 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);
1f10: ea000073 b 20e4 <malloc_deferred_free> <== NOT EXECUTED
#endif
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
1f14: e59f304c ldr r3, [pc, #76] ; 1f68 <free+0x98>
1f18: e5933000 ldr r3, [r3]
1f1c: e3530000 cmp r3, #0
(*rtems_malloc_statistics_helpers->at_free)(ptr);
1f20: 11a00004 movne r0, r4
1f24: 11a0e00f movne lr, pc
1f28: 1593f008 ldrne pc, [r3, #8]
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
1f2c: e59f5038 ldr r5, [pc, #56] ; 1f6c <free+0x9c>
1f30: e1a01004 mov r1, r4
1f34: e5950000 ldr r0, [r5]
1f38: eb0012d9 bl 6aa4 <_Protected_heap_Free>
1f3c: e3500000 cmp r0, #0
1f40: 18bd8030 popne {r4, r5, pc}
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
ptr,
RTEMS_Malloc_Heap->area_begin,
1f44: 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",
1f48: e59f0020 ldr r0, [pc, #32] ; 1f70 <free+0xa0> <== NOT EXECUTED
1f4c: e2822018 add r2, r2, #24 <== NOT EXECUTED
1f50: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
1f54: e1a01004 mov r1, r4 <== NOT EXECUTED
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
1f58: 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",
1f5c: ea00036f b 2d20 <printk> <== NOT EXECUTED
000264e8 <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
264e8: e59f3058 ldr r3, [pc, #88] ; 26548 <free_user_env+0x60> <== NOT EXECUTED
264ec: e1500003 cmp r0, r3 <== NOT EXECUTED
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
264f0: e92d4010 push {r4, lr} <== NOT EXECUTED
264f4: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
264f8: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
264fc: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
26500: e3530000 cmp r3, #0 <== NOT EXECUTED
26504: 0a000004 beq 2651c <free_user_env+0x34> <== NOT EXECUTED
26508: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
2650c: e3530000 cmp r3, #0 <== NOT EXECUTED
26510: 12800004 addne r0, r0, #4 <== NOT EXECUTED
26514: 11a0e00f movne lr, pc <== NOT EXECUTED
26518: 112fff13 bxne r3 <== NOT EXECUTED
rtems_filesystem_freenode( &env->root_directory);
2651c: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED
26520: e3530000 cmp r3, #0 <== NOT EXECUTED
26524: 0a000004 beq 2653c <free_user_env+0x54> <== NOT EXECUTED
26528: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
2652c: e3530000 cmp r3, #0 <== NOT EXECUTED
26530: 12840018 addne r0, r4, #24 <== NOT EXECUTED
26534: 11a0e00f movne lr, pc <== NOT EXECUTED
26538: 112fff13 bxne r3 <== NOT EXECUTED
free(env);
2653c: e1a00004 mov r0, r4 <== NOT EXECUTED
}
}
26540: e8bd4010 pop {r4, lr} <== NOT EXECUTED
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
26544: eaff845a b 76b4 <free> <== NOT EXECUTED
00018cdc <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
18cdc: e92d4030 push {r4, r5, lr}
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
18ce0: e2515000 subs r5, r1, #0
18ce4: 1a000002 bne 18cf4 <fstat+0x18>
rtems_set_errno_and_return_minus_one( EFAULT );
18ce8: ebffd1b5 bl d3c4 <__errno>
18cec: e3a0300e mov r3, #14
18cf0: ea000014 b 18d48 <fstat+0x6c>
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
18cf4: e59f3080 ldr r3, [pc, #128] ; 18d7c <fstat+0xa0>
18cf8: e5933000 ldr r3, [r3]
18cfc: e1500003 cmp r0, r3
18d00: 2a000008 bcs 18d28 <fstat+0x4c>
18d04: e59f3074 ldr r3, [pc, #116] ; 18d80 <fstat+0xa4>
18d08: e5934000 ldr r4, [r3]
18d0c: e0844300 add r4, r4, r0, lsl #6
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
18d10: e5943014 ldr r3, [r4, #20]
18d14: e3130c01 tst r3, #256 ; 0x100
18d18: 0a000002 beq 18d28 <fstat+0x4c>
if ( !iop->handlers )
18d1c: e594303c ldr r3, [r4, #60] ; 0x3c
18d20: e3530000 cmp r3, #0
18d24: 1a000002 bne 18d34 <fstat+0x58>
rtems_set_errno_and_return_minus_one( EBADF );
18d28: ebffd1a5 bl d3c4 <__errno>
18d2c: e3a03009 mov r3, #9
18d30: ea000004 b 18d48 <fstat+0x6c>
if ( !iop->handlers->fstat_h )
18d34: e5933018 ldr r3, [r3, #24]
18d38: e3530000 cmp r3, #0
18d3c: 1a000004 bne 18d54 <fstat+0x78>
rtems_set_errno_and_return_minus_one( ENOTSUP );
18d40: ebffd19f bl d3c4 <__errno> <== NOT EXECUTED
18d44: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
18d48: e5803000 str r3, [r0]
18d4c: e3e00000 mvn r0, #0
18d50: e8bd8030 pop {r4, r5, pc}
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
18d54: e3a01000 mov r1, #0
18d58: e3a02048 mov r2, #72 ; 0x48
18d5c: e1a00005 mov r0, r5
18d60: ebffd3e1 bl dcec <memset>
return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf );
18d64: e2840018 add r0, r4, #24
18d68: e1a01005 mov r1, r5
18d6c: e594303c ldr r3, [r4, #60] ; 0x3c
18d70: e1a0e00f mov lr, pc
18d74: e593f018 ldr pc, [r3, #24]
}
18d78: e8bd8030 pop {r4, r5, pc}
00025248 <fsync>:
int fd
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
25248: e59f3068 ldr r3, [pc, #104] ; 252b8 <fsync+0x70>
2524c: e5933000 ldr r3, [r3]
25250: e1500003 cmp r0, r3
#include <rtems/seterr.h>
int fsync(
int fd
)
{
25254: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
25258: 2a000008 bcs 25280 <fsync+0x38>
iop = rtems_libio_iop( fd );
2525c: e59f3058 ldr r3, [pc, #88] ; 252bc <fsync+0x74>
25260: e5933000 ldr r3, [r3]
25264: e0830300 add r0, r3, r0, lsl #6
rtems_libio_check_is_open(iop);
25268: e5903014 ldr r3, [r0, #20]
2526c: e3130c01 tst r3, #256 ; 0x100
25270: 0a000002 beq 25280 <fsync+0x38>
/*
* Now process the fsync().
*/
if ( !iop->handlers )
25274: e590303c ldr r3, [r0, #60] ; 0x3c
25278: e3530000 cmp r3, #0
2527c: 1a000002 bne 2528c <fsync+0x44>
rtems_set_errno_and_return_minus_one( EBADF );
25280: eb005f1e bl 3cf00 <__errno> <== NOT EXECUTED
25284: e3a03009 mov r3, #9 <== NOT EXECUTED
25288: ea000004 b 252a0 <fsync+0x58> <== NOT EXECUTED
if ( !iop->handlers->fsync_h )
2528c: e5933028 ldr r3, [r3, #40] ; 0x28
25290: e3530000 cmp r3, #0
25294: 1a000004 bne 252ac <fsync+0x64>
rtems_set_errno_and_return_minus_one( ENOTSUP );
25298: eb005f18 bl 3cf00 <__errno>
2529c: e3a03086 mov r3, #134 ; 0x86
252a0: e5803000 str r3, [r0]
252a4: e3e00000 mvn r0, #0
252a8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
return (*iop->handlers->fsync_h)( iop );
252ac: e1a0e00f mov lr, pc
252b0: e12fff13 bx r3
}
252b4: e49df004 pop {pc} ; (ldr pc, [sp], #4)
0000a0f4 <ftruncate>:
int ftruncate(
int fd,
off_t length
)
{
a0f4: e92d4070 push {r4, r5, r6, lr}
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
a0f8: e59f30dc ldr r3, [pc, #220] ; a1dc <ftruncate+0xe8>
a0fc: e5933000 ldr r3, [r3]
a100: e1500003 cmp r0, r3
int ftruncate(
int fd,
off_t length
)
{
a104: e24dd014 sub sp, sp, #20
a108: e1a05001 mov r5, r1
a10c: e1a06002 mov r6, r2
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
a110: 2a000005 bcs a12c <ftruncate+0x38>
iop = rtems_libio_iop( fd );
a114: e59f30c4 ldr r3, [pc, #196] ; a1e0 <ftruncate+0xec>
a118: e5934000 ldr r4, [r3]
a11c: e0844300 add r4, r4, r0, lsl #6
rtems_libio_check_is_open(iop);
a120: e5943014 ldr r3, [r4, #20]
a124: e3130c01 tst r3, #256 ; 0x100
a128: 1a000002 bne a138 <ftruncate+0x44>
a12c: eb000ca4 bl d3c4 <__errno> <== NOT EXECUTED
a130: e3a03009 mov r3, #9 <== NOT EXECUTED
a134: ea00001e b a1b4 <ftruncate+0xc0> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
a138: e3130004 tst r3, #4
a13c: 0a000013 beq a190 <ftruncate+0x9c>
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
a140: e284e018 add lr, r4, #24
a144: e8be000f ldm lr!, {r0, r1, r2, r3}
a148: e1a0c00d mov ip, sp
a14c: e8ac000f stmia ip!, {r0, r1, r2, r3}
if ( !loc.ops->node_type_h )
a150: e5933010 ldr r3, [r3, #16]
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
a154: e59e2000 ldr r2, [lr]
if ( !loc.ops->node_type_h )
a158: e3530000 cmp r3, #0
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
a15c: e58c2000 str r2, [ip]
if ( !loc.ops->node_type_h )
a160: 0a000011 beq a1ac <ftruncate+0xb8>
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
a164: e1a0000d mov r0, sp
a168: e1a0e00f mov lr, pc
a16c: e12fff13 bx r3
a170: e3500001 cmp r0, #1
a174: 1a000002 bne a184 <ftruncate+0x90>
rtems_set_errno_and_return_minus_one( EISDIR );
a178: eb000c91 bl d3c4 <__errno>
a17c: e3a03015 mov r3, #21
a180: ea00000b b a1b4 <ftruncate+0xc0>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
a184: e5943014 ldr r3, [r4, #20]
a188: e3130004 tst r3, #4
a18c: 1a000002 bne a19c <ftruncate+0xa8>
a190: eb000c8b bl d3c4 <__errno> <== NOT EXECUTED
a194: e3a03016 mov r3, #22 <== NOT EXECUTED
a198: ea000005 b a1b4 <ftruncate+0xc0> <== NOT EXECUTED
if ( !iop->handlers->ftruncate_h )
a19c: e594303c ldr r3, [r4, #60] ; 0x3c
a1a0: e5933020 ldr r3, [r3, #32]
a1a4: e3530000 cmp r3, #0
a1a8: 1a000004 bne a1c0 <ftruncate+0xcc>
rtems_set_errno_and_return_minus_one( ENOTSUP );
a1ac: eb000c84 bl d3c4 <__errno> <== NOT EXECUTED
a1b0: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
a1b4: e5803000 str r3, [r0]
a1b8: e3e00000 mvn r0, #0
a1bc: ea000004 b a1d4 <ftruncate+0xe0>
return (*iop->handlers->ftruncate_h)( iop, length );
a1c0: e1a00004 mov r0, r4
a1c4: e1a01005 mov r1, r5
a1c8: e1a02006 mov r2, r6
a1cc: e1a0e00f mov lr, pc
a1d0: e12fff13 bx r3
}
a1d4: e28dd014 add sp, sp, #20
a1d8: e8bd8070 pop {r4, r5, r6, pc}
00056a9c <getdents>:
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
56a9c: e59f30a8 ldr r3, [pc, #168] ; 56b4c <getdents+0xb0>
56aa0: e5933000 ldr r3, [r3]
56aa4: e1500003 cmp r0, r3
56aa8: 359f30a0 ldrcc r3, [pc, #160] ; 56b50 <getdents+0xb4>
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
56aac: e92d4070 push {r4, r5, r6, lr}
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
56ab0: 35934000 ldrcc r4, [r3]
56ab4: 23a04000 movcs r4, #0
56ab8: 30844300 addcc r4, r4, r0, lsl #6
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
56abc: e284e018 add lr, r4, #24
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
56ac0: e24dd014 sub sp, sp, #20
56ac4: e1a06001 mov r6, r1
56ac8: e1a05002 mov r5, r2
iop = rtems_libio_iop( dd_fd );
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
56acc: e8be000f ldm lr!, {r0, r1, r2, r3}
56ad0: e1a0c00d mov ip, sp
56ad4: e8ac000f stmia ip!, {r0, r1, r2, r3}
if ( !loc.ops->node_type_h )
56ad8: e5933010 ldr r3, [r3, #16]
iop = rtems_libio_iop( dd_fd );
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
56adc: e59e2000 ldr r2, [lr]
if ( !loc.ops->node_type_h )
56ae0: e3530000 cmp r3, #0
iop = rtems_libio_iop( dd_fd );
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
56ae4: e58c2000 str r2, [ip]
if ( !loc.ops->node_type_h )
56ae8: 0a00000d beq 56b24 <getdents+0x88>
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
56aec: e1a0000d mov r0, sp
56af0: e1a0e00f mov lr, pc
56af4: e12fff13 bx r3
56af8: e3500001 cmp r0, #1
56afc: 0a000004 beq 56b14 <getdents+0x78>
rtems_set_errno_and_return_minus_one( ENOTDIR );
56b00: ebff98fe bl 3cf00 <__errno>
56b04: e3a03014 mov r3, #20
56b08: e5803000 str r3, [r0]
56b0c: e3e00000 mvn r0, #0
56b10: ea00000b b 56b44 <getdents+0xa8>
/*
* Return the number of bytes that were actually transfered as a result
* of the read attempt.
*/
if ( !iop->handlers->read_h )
56b14: e594303c ldr r3, [r4, #60] ; 0x3c
56b18: e5933008 ldr r3, [r3, #8]
56b1c: e3530000 cmp r3, #0
56b20: 1a000002 bne 56b30 <getdents+0x94>
rtems_set_errno_and_return_minus_one( ENOTSUP );
56b24: ebff98f5 bl 3cf00 <__errno> <== NOT EXECUTED
56b28: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
56b2c: eafffff5 b 56b08 <getdents+0x6c> <== NOT EXECUTED
return (*iop->handlers->read_h)( iop, dd_buf, dd_len );
56b30: e1a00004 mov r0, r4
56b34: e1a01006 mov r1, r6
56b38: e1a02005 mov r2, r5
56b3c: e1a0e00f mov lr, pc
56b40: e12fff13 bx r3
}
56b44: e28dd014 add sp, sp, #20
56b48: e8bd8070 pop {r4, r5, r6, pc}
000253d8 <getgid>:
* 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs,
* P1003.1b-1993, p. 84
*/
gid_t getgid( void )
{
253d8: e59f3008 ldr r3, [pc, #8] ; 253e8 <getgid+0x10> <== NOT EXECUTED
253dc: e5933000 ldr r3, [r3] <== NOT EXECUTED
return _POSIX_types_Gid;
}
253e0: e1d303b4 ldrh r0, [r3, #52] ; 0x34 <== NOT EXECUTED
253e4: e12fff1e bx lr <== NOT EXECUTED
000259e0 <getgr_r>:
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
259e0: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
259e4: e59da01c ldr sl, [sp, #28]
259e8: e1a06000 mov r6, r0
259ec: e1a07001 mov r7, r1
259f0: e1a04002 mov r4, r2
259f4: e1a08003 mov r8, r3
FILE *fp;
int match;
init_etc_passwd_group();
259f8: ebffffb7 bl 258dc <init_etc_passwd_group>
if ((fp = fopen("/etc/group", "r")) == NULL) {
259fc: e59f00a4 ldr r0, [pc, #164] ; 25aa8 <getgr_r+0xc8>
25a00: e59f10a4 ldr r1, [pc, #164] ; 25aac <getgr_r+0xcc>
25a04: eb005fad bl 3d8c0 <fopen>
25a08: e2505000 subs r5, r0, #0
25a0c: 1a000003 bne 25a20 <getgr_r+0x40>
errno = EINVAL;
25a10: eb005d3a bl 3cf00 <__errno> <== NOT EXECUTED
25a14: e3a03016 mov r3, #22 <== NOT EXECUTED
25a18: e5803000 str r3, [r0] <== NOT EXECUTED
25a1c: ea00000c b 25a54 <getgr_r+0x74> <== NOT EXECUTED
return -1;
}
for(;;) {
if (!scangr(fp, grp, buffer, bufsize)) {
25a20: e1a01004 mov r1, r4
25a24: e1a02008 mov r2, r8
25a28: e1a0300a mov r3, sl
25a2c: e1a00005 mov r0, r5
25a30: ebfffef2 bl 25600 <scangr>
25a34: e3500000 cmp r0, #0
errno = EINVAL;
fclose(fp);
return -1;
}
if (name) {
match = (strcmp(grp->gr_name, name) == 0);
25a38: e1a01006 mov r1, r6
if ((fp = fopen("/etc/group", "r")) == NULL) {
errno = EINVAL;
return -1;
}
for(;;) {
if (!scangr(fp, grp, buffer, bufsize)) {
25a3c: 1a000006 bne 25a5c <getgr_r+0x7c>
errno = EINVAL;
25a40: eb005d2e bl 3cf00 <__errno> <== NOT EXECUTED
25a44: e3a03016 mov r3, #22 <== NOT EXECUTED
25a48: e5803000 str r3, [r0] <== NOT EXECUTED
fclose(fp);
25a4c: e1a00005 mov r0, r5 <== NOT EXECUTED
25a50: eb005d77 bl 3d034 <fclose> <== NOT EXECUTED
25a54: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
25a58: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
}
if (name) {
25a5c: e3560000 cmp r6, #0
25a60: 0a000004 beq 25a78 <getgr_r+0x98>
match = (strcmp(grp->gr_name, name) == 0);
25a64: e5940000 ldr r0, [r4]
25a68: eb0075b9 bl 43154 <strcmp>
25a6c: e2700001 rsbs r0, r0, #1
25a70: 33a00000 movcc r0, #0
25a74: ea000003 b 25a88 <getgr_r+0xa8>
}
else {
match = (grp->gr_gid == gid);
25a78: e1d400b8 ldrh r0, [r4, #8] <== NOT EXECUTED
25a7c: e1500007 cmp r0, r7 <== NOT EXECUTED
25a80: 13a00000 movne r0, #0 <== NOT EXECUTED
25a84: 03a00001 moveq r0, #1 <== NOT EXECUTED
}
if (match) {
25a88: e3500000 cmp r0, #0
25a8c: 0affffe3 beq 25a20 <getgr_r+0x40>
fclose(fp);
25a90: e1a00005 mov r0, r5
25a94: eb005d66 bl 3d034 <fclose>
*result = grp;
25a98: e59d3020 ldr r3, [sp, #32]
25a9c: e3a00000 mov r0, #0
25aa0: e5834000 str r4, [r3]
}
}
fclose(fp);
errno = EINVAL;
return -1;
}
25aa4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
00025738 <getgrent>:
return NULL;
return p;
}
struct group *getgrent(void)
{
25738: e92d4010 push {r4, lr} <== NOT EXECUTED
if (group_fp == NULL)
2573c: e59f402c ldr r4, [pc, #44] ; 25770 <getgrent+0x38> <== NOT EXECUTED
25740: e5940000 ldr r0, [r4] <== NOT EXECUTED
25744: e3500000 cmp r0, #0 <== NOT EXECUTED
25748: 0a000006 beq 25768 <getgrent+0x30> <== NOT EXECUTED
return NULL;
if (!scangr(group_fp, &grent, grbuf, sizeof grbuf))
2574c: e2841008 add r1, r4, #8 <== NOT EXECUTED
25750: e2842018 add r2, r4, #24 <== NOT EXECUTED
25754: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED
25758: ebffffa8 bl 25600 <scangr> <== NOT EXECUTED
2575c: e3500000 cmp r0, #0 <== NOT EXECUTED
25760: 12840008 addne r0, r4, #8 <== NOT EXECUTED
25764: 18bd8010 popne {r4, pc} <== NOT EXECUTED
25768: e3a00000 mov r0, #0 <== NOT EXECUTED
return NULL;
return &grent;
}
2576c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00025ae4 <getgrgid>:
struct group *getgrgid(
gid_t gid
)
{
25ae4: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
struct group *p;
if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))
25ae8: e59f1028 ldr r1, [pc, #40] ; 25b18 <getgrgid+0x34> <== NOT EXECUTED
}
struct group *getgrgid(
gid_t gid
)
{
25aec: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
struct group *p;
if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))
25af0: e28dc004 add ip, sp, #4 <== NOT EXECUTED
25af4: e2812010 add r2, r1, #16 <== NOT EXECUTED
25af8: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED
25afc: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED
25b00: e58dc000 str ip, [sp] <== NOT EXECUTED
25b04: ebffffe9 bl 25ab0 <getgrgid_r> <== NOT EXECUTED
25b08: e3500000 cmp r0, #0 <== NOT EXECUTED
25b0c: 13a00000 movne r0, #0 <== NOT EXECUTED
return NULL;
return p;
25b10: 059d0004 ldreq r0, [sp, #4] <== NOT EXECUTED
}
25b14: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
00025ab0 <getgrgid_r>:
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
25ab0: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
25ab4: e1a0c002 mov ip, r2 <== NOT EXECUTED
25ab8: e1a0e001 mov lr, r1 <== NOT EXECUTED
return getgr_r(NULL, gid, grp, buffer, bufsize, result);
25abc: e58d3000 str r3, [sp] <== NOT EXECUTED
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
25ac0: e1a01800 lsl r1, r0, #16 <== NOT EXECUTED
return getgr_r(NULL, gid, grp, buffer, bufsize, result);
25ac4: e1a0300c mov r3, ip <== NOT EXECUTED
25ac8: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED
25acc: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED
25ad0: e1a0200e mov r2, lr <== NOT EXECUTED
25ad4: e3a00000 mov r0, #0 <== NOT EXECUTED
25ad8: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
25adc: ebffffbf bl 259e0 <getgr_r> <== NOT EXECUTED
}
25ae0: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
00020d24 <getpid>:
*/
pid_t getpid( void )
{
return _Objects_Local_node;
}
20d24: e3a00001 mov r0, #1 <== NOT EXECUTED
20d28: e12fff1e bx lr <== NOT EXECUTED
00025bb0 <getpw_r>:
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
25bb0: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
25bb4: e59da01c ldr sl, [sp, #28]
25bb8: e1a06000 mov r6, r0
25bbc: e1a07001 mov r7, r1
25bc0: e1a04002 mov r4, r2
25bc4: e1a08003 mov r8, r3
FILE *fp;
int match;
init_etc_passwd_group();
25bc8: ebffff43 bl 258dc <init_etc_passwd_group>
if ((fp = fopen("/etc/passwd", "r")) == NULL) {
25bcc: e59f00a4 ldr r0, [pc, #164] ; 25c78 <getpw_r+0xc8>
25bd0: e59f10a4 ldr r1, [pc, #164] ; 25c7c <getpw_r+0xcc>
25bd4: eb005f39 bl 3d8c0 <fopen>
25bd8: e2505000 subs r5, r0, #0
25bdc: 1a000003 bne 25bf0 <getpw_r+0x40>
errno = EINVAL;
25be0: eb005cc6 bl 3cf00 <__errno> <== NOT EXECUTED
25be4: e3a03016 mov r3, #22 <== NOT EXECUTED
25be8: e5803000 str r3, [r0] <== NOT EXECUTED
25bec: ea00000c b 25c24 <getpw_r+0x74> <== NOT EXECUTED
return -1;
}
for(;;) {
if (!scanpw(fp, pwd, buffer, bufsize)) {
25bf0: e1a01004 mov r1, r4
25bf4: e1a02008 mov r2, r8
25bf8: e1a0300a mov r3, sl
25bfc: e1a00005 mov r0, r5
25c00: ebfffedb bl 25774 <scanpw>
25c04: e3500000 cmp r0, #0
errno = EINVAL;
fclose(fp);
return -1;
}
if (name) {
match = (strcmp(pwd->pw_name, name) == 0);
25c08: e1a01006 mov r1, r6
if ((fp = fopen("/etc/passwd", "r")) == NULL) {
errno = EINVAL;
return -1;
}
for(;;) {
if (!scanpw(fp, pwd, buffer, bufsize)) {
25c0c: 1a000006 bne 25c2c <getpw_r+0x7c>
errno = EINVAL;
25c10: eb005cba bl 3cf00 <__errno> <== NOT EXECUTED
25c14: e3a03016 mov r3, #22 <== NOT EXECUTED
25c18: e5803000 str r3, [r0] <== NOT EXECUTED
fclose(fp);
25c1c: e1a00005 mov r0, r5 <== NOT EXECUTED
25c20: eb005d03 bl 3d034 <fclose> <== NOT EXECUTED
25c24: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
25c28: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
}
if (name) {
25c2c: e3560000 cmp r6, #0
25c30: 0a000004 beq 25c48 <getpw_r+0x98>
match = (strcmp(pwd->pw_name, name) == 0);
25c34: e5940000 ldr r0, [r4]
25c38: eb007545 bl 43154 <strcmp>
25c3c: e2700001 rsbs r0, r0, #1
25c40: 33a00000 movcc r0, #0
25c44: ea000003 b 25c58 <getpw_r+0xa8>
}
else {
match = (pwd->pw_uid == uid);
25c48: e1d400b8 ldrh r0, [r4, #8] <== NOT EXECUTED
25c4c: e1500007 cmp r0, r7 <== NOT EXECUTED
25c50: 13a00000 movne r0, #0 <== NOT EXECUTED
25c54: 03a00001 moveq r0, #1 <== NOT EXECUTED
}
if (match) {
25c58: e3500000 cmp r0, #0
25c5c: 0affffe3 beq 25bf0 <getpw_r+0x40>
fclose(fp);
25c60: e1a00005 mov r0, r5
25c64: eb005cf2 bl 3d034 <fclose>
*result = pwd;
25c68: e59d3020 ldr r3, [sp, #32]
25c6c: e3a00000 mov r0, #0
25c70: e5834000 str r4, [r3]
}
}
fclose(fp);
errno = EINVAL;
return -1;
}
25c74: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
000258a0 <getpwent>:
return NULL;
return p;
}
struct passwd *getpwent(void)
{
258a0: e92d4010 push {r4, lr} <== NOT EXECUTED
if (passwd_fp == NULL)
258a4: e59f402c ldr r4, [pc, #44] ; 258d8 <getpwent+0x38> <== NOT EXECUTED
258a8: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED
258ac: e3500000 cmp r0, #0 <== NOT EXECUTED
258b0: 0a000006 beq 258d0 <getpwent+0x30> <== NOT EXECUTED
return NULL;
if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf))
258b4: e28410e0 add r1, r4, #224 ; 0xe0 <== NOT EXECUTED
258b8: e28420fc add r2, r4, #252 ; 0xfc <== NOT EXECUTED
258bc: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED
258c0: ebffffab bl 25774 <scanpw> <== NOT EXECUTED
258c4: e3500000 cmp r0, #0 <== NOT EXECUTED
258c8: 128400e0 addne r0, r4, #224 ; 0xe0 <== NOT EXECUTED
258cc: 18bd8010 popne {r4, pc} <== NOT EXECUTED
258d0: e3a00000 mov r0, #0 <== NOT EXECUTED
return NULL;
return &pwent;
}
258d4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00025cb4 <getpwuid>:
struct passwd *getpwuid(
uid_t uid
)
{
25cb4: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
struct passwd *p;
if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))
25cb8: e59f1028 ldr r1, [pc, #40] ; 25ce8 <getpwuid+0x34> <== NOT EXECUTED
}
struct passwd *getpwuid(
uid_t uid
)
{
25cbc: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
struct passwd *p;
if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))
25cc0: e28dc004 add ip, sp, #4 <== NOT EXECUTED
25cc4: e281201c add r2, r1, #28 <== NOT EXECUTED
25cc8: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED
25ccc: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED
25cd0: e58dc000 str ip, [sp] <== NOT EXECUTED
25cd4: ebffffe9 bl 25c80 <getpwuid_r> <== NOT EXECUTED
25cd8: e3500000 cmp r0, #0 <== NOT EXECUTED
25cdc: 13a00000 movne r0, #0 <== NOT EXECUTED
return NULL;
return p;
25ce0: 059d0004 ldreq r0, [sp, #4] <== NOT EXECUTED
}
25ce4: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
00025c80 <getpwuid_r>:
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
25c80: e92d4003 push {r0, r1, lr} <== NOT EXECUTED
25c84: e1a0c002 mov ip, r2 <== NOT EXECUTED
25c88: e1a0e001 mov lr, r1 <== NOT EXECUTED
return getpw_r(NULL, uid, pwd, buffer, bufsize, result);
25c8c: e58d3000 str r3, [sp] <== NOT EXECUTED
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
25c90: e1a01800 lsl r1, r0, #16 <== NOT EXECUTED
return getpw_r(NULL, uid, pwd, buffer, bufsize, result);
25c94: e1a0300c mov r3, ip <== NOT EXECUTED
25c98: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED
25c9c: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED
25ca0: e1a0200e mov r2, lr <== NOT EXECUTED
25ca4: e3a00000 mov r0, #0 <== NOT EXECUTED
25ca8: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
25cac: ebffffbf bl 25bb0 <getpw_r> <== NOT EXECUTED
}
25cb0: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
00001f74 <gettimeofday>:
*/
int gettimeofday(
struct timeval *tp,
void * __tz __attribute__((unused))
)
{
1f74: e92d4033 push {r0, r1, r4, r5, lr}
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp ) {
1f78: e2504000 subs r4, r0, #0
1f7c: 1a000004 bne 1f94 <gettimeofday+0x20>
errno = EFAULT;
1f80: eb002d0f bl d3c4 <__errno> <== NOT EXECUTED
1f84: e3a0300e mov r3, #14 <== NOT EXECUTED
1f88: e5803000 str r3, [r0] <== NOT EXECUTED
1f8c: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
1f90: ea00000c b 1fc8 <gettimeofday+0x54> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
1f94: e10f5000 mrs r5, CPSR
1f98: e3853080 orr r3, r5, #128 ; 0x80
1f9c: e129f003 msr CPSR_fc, r3
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
_TOD_Get( &now );
1fa0: e1a0000d mov r0, sp
1fa4: eb000fae bl 5e64 <_TOD_Get>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
1fa8: e129f005 msr CPSR_fc, r5
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
1fac: e59d3000 ldr r3, [sp]
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
1fb0: e59d0004 ldr r0, [sp, #4]
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
time->tv_usec = useconds;
1fb4: e3a01ffa mov r1, #1000 ; 0x3e8
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
1fb8: e5843000 str r3, [r4]
time->tv_usec = useconds;
1fbc: eb0052ce bl 16afc <__aeabi_idiv>
1fc0: e5840004 str r0, [r4, #4]
1fc4: 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;
}
1fc8: e8bd803c pop {r2, r3, r4, r5, pc}
000077c0 <getuid>:
* 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs,
* P1003.1b-1993, p. 84
*/
uid_t getuid( void )
{
77c0: e59f3008 ldr r3, [pc, #8] ; 77d0 <getuid+0x10> <== NOT EXECUTED
77c4: e5933000 ldr r3, [r3] <== NOT EXECUTED
return _POSIX_types_Uid;
}
77c8: e1d303b2 ldrh r0, [r3, #50] ; 0x32 <== NOT EXECUTED
77cc: e12fff1e bx lr <== NOT EXECUTED
000052d0 <ioctl>:
int ioctl(
int fd,
ioctl_command_t command,
...
)
{
52d0: e92d000e push {r1, r2, r3}
va_list ap;
rtems_status_code rc;
rtems_libio_t *iop;
void *buffer;
rtems_libio_check_fd( fd );
52d4: e59f3080 ldr r3, [pc, #128] ; 535c <ioctl+0x8c>
52d8: e5933000 ldr r3, [r3]
52dc: e1500003 cmp r0, r3
int ioctl(
int fd,
ioctl_command_t command,
...
)
{
52e0: e92d4001 push {r0, lr}
va_list ap;
rtems_status_code rc;
rtems_libio_t *iop;
void *buffer;
rtems_libio_check_fd( fd );
52e4: 2a00000b bcs 5318 <ioctl+0x48>
iop = rtems_libio_iop( fd );
52e8: e59f3070 ldr r3, [pc, #112] ; 5360 <ioctl+0x90>
52ec: e5933000 ldr r3, [r3]
52f0: e0830300 add r0, r3, r0, lsl #6
rtems_libio_check_is_open(iop);
52f4: e5903014 ldr r3, [r0, #20]
52f8: e3130c01 tst r3, #256 ; 0x100
52fc: 0a000005 beq 5318 <ioctl+0x48>
/*
* Now process the ioctl().
*/
if ( !iop->handlers )
5300: 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 *);
5304: e28d2010 add r2, sp, #16
/*
* Now process the ioctl().
*/
if ( !iop->handlers )
5308: e3530000 cmp r3, #0
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
va_start(ap, command);
buffer = va_arg(ap, void *);
530c: e58d2000 str r2, [sp]
5310: e59d200c ldr r2, [sp, #12]
/*
* Now process the ioctl().
*/
if ( !iop->handlers )
5314: 1a000002 bne 5324 <ioctl+0x54>
rtems_set_errno_and_return_minus_one( EBADF );
5318: eb003004 bl 11330 <__errno>
531c: e3a03009 mov r3, #9
5320: ea000004 b 5338 <ioctl+0x68>
if ( !iop->handlers->ioctl_h )
5324: e5933010 ldr r3, [r3, #16]
5328: e3530000 cmp r3, #0
532c: 1a000004 bne 5344 <ioctl+0x74>
rtems_set_errno_and_return_minus_one( ENOTSUP );
5330: eb002ffe bl 11330 <__errno> <== NOT EXECUTED
5334: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
5338: e5803000 str r3, [r0]
533c: e3e00000 mvn r0, #0
5340: ea000002 b 5350 <ioctl+0x80>
rc = (*iop->handlers->ioctl_h)( iop, command, buffer );
5344: e59d1008 ldr r1, [sp, #8]
5348: e1a0e00f mov lr, pc
534c: e12fff13 bx r3
return rc;
}
5350: e8bd4008 pop {r3, lr}
5354: e28dd00c add sp, sp, #12
5358: e12fff1e bx lr
000037ec <iproc>:
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
if (tty->termios.c_iflag & ISTRIP)
37ec: e5913030 ldr r3, [r1, #48] ; 0x30 <== NOT EXECUTED
37f0: e3130020 tst r3, #32 <== NOT EXECUTED
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
37f4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
37f8: e20050ff and r5, r0, #255 ; 0xff <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
37fc: 1200507f andne r5, r0, #127 ; 0x7f <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
3800: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
3804: e1a04001 mov r4, r1 <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
3808: 0a000007 beq 382c <iproc+0x40> <== NOT EXECUTED
c = tolower (c);
380c: e59f2164 ldr r2, [pc, #356] ; 3978 <iproc+0x18c> <== NOT EXECUTED
3810: e5922000 ldr r2, [r2] <== NOT EXECUTED
3814: e0822005 add r2, r2, r5 <== NOT EXECUTED
3818: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED
381c: e2022003 and r2, r2, #3 <== NOT EXECUTED
3820: e3520001 cmp r2, #1 <== NOT EXECUTED
3824: 02855020 addeq r5, r5, #32 <== NOT EXECUTED
3828: e20550ff and r5, r5, #255 ; 0xff <== NOT EXECUTED
if (c == '\r') {
382c: e355000d cmp r5, #13 <== NOT EXECUTED
3830: 1a000005 bne 384c <iproc+0x60> <== NOT EXECUTED
if (tty->termios.c_iflag & IGNCR)
3834: e3130080 tst r3, #128 ; 0x80 <== NOT EXECUTED
3838: 1a00004c bne 3970 <iproc+0x184> <== NOT EXECUTED
return 0;
if (tty->termios.c_iflag & ICRNL)
383c: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED
3840: 03a0500d moveq r5, #13 <== NOT EXECUTED
3844: 13a0500a movne r5, #10 <== NOT EXECUTED
3848: ea000007 b 386c <iproc+0x80> <== NOT EXECUTED
c = '\n';
}
else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
384c: e355000a cmp r5, #10 <== NOT EXECUTED
3850: 1a000003 bne 3864 <iproc+0x78> <== NOT EXECUTED
3854: e3130040 tst r3, #64 ; 0x40 <== NOT EXECUTED
3858: 03a0500a moveq r5, #10 <== NOT EXECUTED
385c: 13a0500d movne r5, #13 <== NOT EXECUTED
3860: ea000001 b 386c <iproc+0x80> <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
3864: e3550000 cmp r5, #0 <== NOT EXECUTED
3868: 0a00002e beq 3928 <iproc+0x13c> <== NOT EXECUTED
386c: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
3870: e3130002 tst r3, #2 <== NOT EXECUTED
3874: 0a00002b beq 3928 <iproc+0x13c> <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
3878: e5d42043 ldrb r2, [r4, #67] ; 0x43 <== NOT EXECUTED
387c: e1520005 cmp r2, r5 <== NOT EXECUTED
erase (tty, 0);
3880: 01a00004 moveq r0, r4 <== NOT EXECUTED
3884: 03a01000 moveq r1, #0 <== 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]) {
3888: 0a000004 beq 38a0 <iproc+0xb4> <== NOT EXECUTED
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
388c: e5d42044 ldrb r2, [r4, #68] ; 0x44 <== NOT EXECUTED
3890: e1520005 cmp r2, r5 <== NOT EXECUTED
3894: 1a000003 bne 38a8 <iproc+0xbc> <== NOT EXECUTED
erase (tty, 1);
3898: e1a00004 mov r0, r4 <== NOT EXECUTED
389c: e3a01001 mov r1, #1 <== NOT EXECUTED
38a0: ebffff5e bl 3620 <erase> <== NOT EXECUTED
38a4: ea00002f b 3968 <iproc+0x17c> <== NOT EXECUTED
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
38a8: e5d42045 ldrb r2, [r4, #69] ; 0x45 <== NOT EXECUTED
38ac: e1520005 cmp r2, r5 <== NOT EXECUTED
38b0: 0a00001a beq 3920 <iproc+0x134> <== NOT EXECUTED
return 1;
}
else if (c == '\n') {
38b4: e355000a cmp r5, #10 <== NOT EXECUTED
38b8: 1a000009 bne 38e4 <iproc+0xf8> <== NOT EXECUTED
if (tty->termios.c_lflag & (ECHO | ECHONL))
38bc: e3130048 tst r3, #72 ; 0x48 <== NOT EXECUTED
echo (c, tty);
38c0: 11a00005 movne r0, r5 <== NOT EXECUTED
38c4: 11a01004 movne r1, r4 <== NOT EXECUTED
38c8: 1bffff34 blne 35a0 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
38cc: e284101c add r1, r4, #28 <== NOT EXECUTED
38d0: e891000a ldm r1, {r1, r3} <== NOT EXECUTED
38d4: e3a0000a mov r0, #10 <== NOT EXECUTED
38d8: e2832001 add r2, r3, #1 <== NOT EXECUTED
38dc: e7c10003 strb r0, [r1, r3] <== NOT EXECUTED
38e0: ea00000d b 391c <iproc+0x130> <== NOT EXECUTED
return 1;
}
else if ((c == tty->termios.c_cc[VEOL])
38e4: e5d4204c ldrb r2, [r4, #76] ; 0x4c <== NOT EXECUTED
38e8: e1520005 cmp r2, r5 <== NOT EXECUTED
38ec: 0a000002 beq 38fc <iproc+0x110> <== NOT EXECUTED
|| (c == tty->termios.c_cc[VEOL2])) {
38f0: e5d42051 ldrb r2, [r4, #81] ; 0x51 <== NOT EXECUTED
38f4: e1520005 cmp r2, r5 <== NOT EXECUTED
38f8: 1a00000a bne 3928 <iproc+0x13c> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO)
38fc: e3130008 tst r3, #8 <== NOT EXECUTED
echo (c, tty);
3900: 11a00005 movne r0, r5 <== NOT EXECUTED
3904: 11a01004 movne r1, r4 <== NOT EXECUTED
3908: 1bffff24 blne 35a0 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
390c: e284101c add r1, r4, #28 <== NOT EXECUTED
3910: e891000a ldm r1, {r1, r3} <== NOT EXECUTED
3914: e7c15003 strb r5, [r1, r3] <== NOT EXECUTED
3918: e2832001 add r2, r3, #1 <== NOT EXECUTED
391c: e5842020 str r2, [r4, #32] <== NOT EXECUTED
3920: e3a00001 mov r0, #1 <== NOT EXECUTED
return 1;
3924: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
3928: e59f304c ldr r3, [pc, #76] ; 397c <iproc+0x190> <== NOT EXECUTED
392c: e5933000 ldr r3, [r3] <== NOT EXECUTED
3930: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
3934: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3938: e1520003 cmp r2, r3 <== NOT EXECUTED
393c: aa00000b bge 3970 <iproc+0x184> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO)
3940: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
3944: e3130008 tst r3, #8 <== NOT EXECUTED
echo (c, tty);
3948: 11a00005 movne r0, r5 <== NOT EXECUTED
394c: 11a01004 movne r1, r4 <== NOT EXECUTED
3950: 1bffff12 blne 35a0 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
3954: e284101c add r1, r4, #28 <== NOT EXECUTED
3958: e891000a ldm r1, {r1, r3} <== NOT EXECUTED
395c: e2832001 add r2, r3, #1 <== NOT EXECUTED
3960: e7c15003 strb r5, [r1, r3] <== NOT EXECUTED
3964: e5842020 str r2, [r4, #32] <== NOT EXECUTED
3968: e3a00000 mov r0, #0 <== NOT EXECUTED
396c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3970: e3a00000 mov r0, #0 <== NOT EXECUTED
}
return 0;
}
3974: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00020d3c <kill>:
#if !defined(RTEMS_POSIX_API)
int kill( pid_t pid, int sig )
{
return 0;
}
20d3c: e3a00000 mov r0, #0 <== NOT EXECUTED
20d40: e12fff1e bx lr <== NOT EXECUTED
00025d44 <link>:
int link(
const char *existing,
const char *new
)
{
25d44: e92d4070 push {r4, r5, r6, lr}
25d48: e24dd034 sub sp, sp, #52 ; 0x34
25d4c: e1a05001 mov r5, r1
25d50: e1a06000 mov r6, r0
/*
* Get the node we are linking to.
*/
result = rtems_filesystem_evaluate_path( existing, strlen( existing ),
25d54: eb007766 bl 43af4 <strlen>
25d58: e28d4018 add r4, sp, #24
25d5c: e1a01000 mov r1, r0
25d60: e3a0c001 mov ip, #1
25d64: e1a00006 mov r0, r6
25d68: e3a02000 mov r2, #0
25d6c: e1a03004 mov r3, r4
25d70: e58dc000 str ip, [sp]
25d74: ebff8630 bl 763c <rtems_filesystem_evaluate_path>
0, &existing_loc, true );
if ( result != 0 )
25d78: e3500000 cmp r0, #0
25d7c: 1a000014 bne 25dd4 <link+0x90>
/*
* Get the parent of the node we are creating.
*/
rtems_filesystem_get_start_loc( new, &i, &parent_loc );
25d80: e28d6004 add r6, sp, #4
25d84: e1a00005 mov r0, r5
25d88: e28d1030 add r1, sp, #48 ; 0x30
25d8c: e1a02006 mov r2, r6
25d90: ebff8c62 bl 8f20 <rtems_filesystem_get_start_loc>
if ( !parent_loc.ops->evalformake_h ) {
25d94: e59d3010 ldr r3, [sp, #16]
25d98: e5933004 ldr r3, [r3, #4]
25d9c: e3530000 cmp r3, #0
25da0: 1a00000d bne 25ddc <link+0x98>
rtems_filesystem_freenode( &existing_loc );
25da4: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
25da8: e3530000 cmp r3, #0 <== NOT EXECUTED
25dac: 0a000005 beq 25dc8 <link+0x84> <== NOT EXECUTED
25db0: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
25db4: e3530000 cmp r3, #0 <== NOT EXECUTED
25db8: 0a000002 beq 25dc8 <link+0x84> <== NOT EXECUTED
25dbc: e1a00004 mov r0, r4 <== NOT EXECUTED
25dc0: e1a0e00f mov lr, pc <== NOT EXECUTED
25dc4: e12fff13 bx r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
25dc8: eb005c4c bl 3cf00 <__errno> <== NOT EXECUTED
25dcc: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
25dd0: e5803000 str r3, [r0]
25dd4: e3e05000 mvn r5, #0
25dd8: ea000053 b 25f2c <link+0x1e8>
}
result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start );
25ddc: e59d0030 ldr r0, [sp, #48] ; 0x30
25de0: e1a01006 mov r1, r6
25de4: e0850000 add r0, r5, r0
25de8: e28d202c add r2, sp, #44 ; 0x2c
25dec: e1a0e00f mov lr, pc
25df0: e12fff13 bx r3
if ( result != 0 ) {
25df4: e2505000 subs r5, r0, #0
25df8: 0a00000a beq 25e28 <link+0xe4>
rtems_filesystem_freenode( &existing_loc );
25dfc: e59d3024 ldr r3, [sp, #36] ; 0x24
25e00: e3530000 cmp r3, #0
25e04: 0a000004 beq 25e1c <link+0xd8>
25e08: e593301c ldr r3, [r3, #28]
25e0c: e3530000 cmp r3, #0
25e10: 11a00004 movne r0, r4
25e14: 11a0e00f movne lr, pc
25e18: 112fff13 bxne r3
rtems_set_errno_and_return_minus_one( result );
25e1c: eb005c37 bl 3cf00 <__errno>
25e20: e5805000 str r5, [r0]
25e24: eaffffea b 25dd4 <link+0x90>
/*
* Check to see if the caller is trying to link across file system
* boundaries.
*/
if ( parent_loc.mt_entry != existing_loc.mt_entry ) {
25e28: e59d3028 ldr r3, [sp, #40] ; 0x28
25e2c: e59d2014 ldr r2, [sp, #20]
25e30: e1520003 cmp r2, r3
25e34: 0a000012 beq 25e84 <link+0x140>
rtems_filesystem_freenode( &existing_loc );
25e38: e59d3024 ldr r3, [sp, #36] ; 0x24
25e3c: e3530000 cmp r3, #0
25e40: 0a000004 beq 25e58 <link+0x114>
25e44: e593301c ldr r3, [r3, #28]
25e48: e3530000 cmp r3, #0
25e4c: 11a00004 movne r0, r4
25e50: 11a0e00f movne lr, pc
25e54: 112fff13 bxne r3
rtems_filesystem_freenode( &parent_loc );
25e58: e59d3010 ldr r3, [sp, #16]
25e5c: e3530000 cmp r3, #0
25e60: 0a000004 beq 25e78 <link+0x134>
25e64: e593301c ldr r3, [r3, #28]
25e68: e3530000 cmp r3, #0
25e6c: 128d0004 addne r0, sp, #4
25e70: 11a0e00f movne lr, pc
25e74: 112fff13 bxne r3
rtems_set_errno_and_return_minus_one( EXDEV );
25e78: eb005c20 bl 3cf00 <__errno>
25e7c: e3a03012 mov r3, #18
25e80: eaffffd2 b 25dd0 <link+0x8c>
}
if ( !parent_loc.ops->link_h ) {
25e84: e59d3010 ldr r3, [sp, #16]
25e88: e5933008 ldr r3, [r3, #8]
25e8c: e3530000 cmp r3, #0
25e90: 1a00000f bne 25ed4 <link+0x190>
rtems_filesystem_freenode( &existing_loc );
25e94: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
25e98: e3530000 cmp r3, #0 <== NOT EXECUTED
25e9c: 0a000004 beq 25eb4 <link+0x170> <== NOT EXECUTED
25ea0: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
25ea4: e3530000 cmp r3, #0 <== NOT EXECUTED
25ea8: 11a00004 movne r0, r4 <== NOT EXECUTED
25eac: 11a0e00f movne lr, pc <== NOT EXECUTED
25eb0: 112fff13 bxne r3 <== NOT EXECUTED
rtems_filesystem_freenode( &parent_loc );
25eb4: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
25eb8: e3530000 cmp r3, #0 <== NOT EXECUTED
25ebc: 0affffc1 beq 25dc8 <link+0x84> <== NOT EXECUTED
25ec0: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
25ec4: e3530000 cmp r3, #0 <== NOT EXECUTED
25ec8: 128d0004 addne r0, sp, #4 <== NOT EXECUTED
25ecc: 1affffbb bne 25dc0 <link+0x7c> <== NOT EXECUTED
25ed0: eaffffbc b 25dc8 <link+0x84> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start );
25ed4: e1a01006 mov r1, r6
25ed8: e1a00004 mov r0, r4
25edc: e59d202c ldr r2, [sp, #44] ; 0x2c
25ee0: e1a0e00f mov lr, pc
25ee4: e12fff13 bx r3
rtems_filesystem_freenode( &existing_loc );
25ee8: e59d3024 ldr r3, [sp, #36] ; 0x24
25eec: 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 );
25ef0: e1a05000 mov r5, r0
rtems_filesystem_freenode( &existing_loc );
25ef4: 0a000004 beq 25f0c <link+0x1c8>
25ef8: e593301c ldr r3, [r3, #28]
25efc: e3530000 cmp r3, #0
25f00: 11a00004 movne r0, r4
25f04: 11a0e00f movne lr, pc
25f08: 112fff13 bxne r3
rtems_filesystem_freenode( &parent_loc );
25f0c: e59d3010 ldr r3, [sp, #16]
25f10: e3530000 cmp r3, #0
25f14: 0a000004 beq 25f2c <link+0x1e8>
25f18: e593301c ldr r3, [r3, #28]
25f1c: e3530000 cmp r3, #0
25f20: 128d0004 addne r0, sp, #4
25f24: 11a0e00f movne lr, pc
25f28: 112fff13 bxne r3
return result;
}
25f2c: e1a00005 mov r0, r5
25f30: e28dd034 add sp, sp, #52 ; 0x34
25f34: e8bd8070 pop {r4, r5, r6, pc}
00018d98 <lseek>:
{
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
18d98: e59fc0ec ldr ip, [pc, #236] ; 18e8c <lseek+0xf4>
18d9c: e59cc000 ldr ip, [ip]
18da0: e150000c cmp r0, ip
off_t lseek(
int fd,
off_t offset,
int whence
)
{
18da4: e92d4870 push {r4, r5, r6, fp, lr}
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
18da8: 2a000005 bcs 18dc4 <lseek+0x2c>
iop = rtems_libio_iop( fd );
18dac: e59fc0dc ldr ip, [pc, #220] ; 18e90 <lseek+0xf8>
18db0: e59c4000 ldr r4, [ip]
18db4: e0844300 add r4, r4, r0, lsl #6
rtems_libio_check_is_open(iop);
18db8: e5940014 ldr r0, [r4, #20]
18dbc: e3100c01 tst r0, #256 ; 0x100
18dc0: 1a000002 bne 18dd0 <lseek+0x38>
18dc4: ebffd17e bl d3c4 <__errno> <== NOT EXECUTED
18dc8: e3a03009 mov r3, #9 <== NOT EXECUTED
18dcc: ea00001c b 18e44 <lseek+0xac> <== NOT EXECUTED
/*
* Check as many errors as possible before touching iop->offset.
*/
if ( !iop->handlers->lseek_h )
18dd0: e594003c ldr r0, [r4, #60] ; 0x3c
18dd4: e5900014 ldr r0, [r0, #20]
18dd8: e3500000 cmp r0, #0
18ddc: 1a000002 bne 18dec <lseek+0x54>
rtems_set_errno_and_return_minus_one( ENOTSUP );
18de0: ebffd177 bl d3c4 <__errno> <== NOT EXECUTED
18de4: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
18de8: ea000015 b 18e44 <lseek+0xac> <== NOT EXECUTED
/*
* Now process the lseek().
*/
old_offset = iop->offset;
switch ( whence ) {
18dec: e3530001 cmp r3, #1
/*
* Now process the lseek().
*/
old_offset = iop->offset;
18df0: e284600c add r6, r4, #12
18df4: e8960060 ldm r6, {r5, r6}
switch ( whence ) {
18df8: 0a000006 beq 18e18 <lseek+0x80>
18dfc: e3530002 cmp r3, #2
18e00: 0a000007 beq 18e24 <lseek+0x8c>
18e04: e3530000 cmp r3, #0
18e08: 1a00000b bne 18e3c <lseek+0xa4>
case SEEK_SET:
iop->offset = offset;
18e0c: e584100c str r1, [r4, #12]
18e10: e5842010 str r2, [r4, #16]
break;
18e14: ea00000e b 18e54 <lseek+0xbc>
case SEEK_CUR:
iop->offset += offset;
18e18: e091b005 adds fp, r1, r5
18e1c: e0a2c006 adc ip, r2, r6
18e20: ea000002 b 18e30 <lseek+0x98>
break;
case SEEK_END:
iop->offset = iop->size + offset;
18e24: e9941800 ldmib r4, {fp, ip}
18e28: e09bb001 adds fp, fp, r1
18e2c: e0acc002 adc ip, ip, r2
18e30: e584b00c str fp, [r4, #12]
18e34: e584c010 str ip, [r4, #16]
break;
18e38: ea000005 b 18e54 <lseek+0xbc>
default:
rtems_set_errno_and_return_minus_one( EINVAL );
18e3c: ebffd160 bl d3c4 <__errno>
18e40: e3a03016 mov r3, #22
18e44: e5803000 str r3, [r0]
18e48: e3e02000 mvn r2, #0
18e4c: e3e03000 mvn r3, #0
18e50: ea00000a b 18e80 <lseek+0xe8>
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->handlers->lseek_h)( iop, offset, whence );
18e54: e594c03c ldr ip, [r4, #60] ; 0x3c
18e58: e1a00004 mov r0, r4
18e5c: e1a0e00f mov lr, pc
18e60: e59cf014 ldr pc, [ip, #20]
if ( status == (off_t) -1 )
18e64: e3700001 cmn r0, #1
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->handlers->lseek_h)( iop, offset, whence );
18e68: e1a02000 mov r2, r0
18e6c: e1a03001 mov r3, r1
if ( status == (off_t) -1 )
18e70: 1a000002 bne 18e80 <lseek+0xe8>
18e74: e3710001 cmn r1, #1
iop->offset = old_offset;
18e78: 0584500c streq r5, [r4, #12]
18e7c: 05846010 streq r6, [r4, #16]
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
18e80: e1a01003 mov r1, r3
18e84: e1a00002 mov r0, r2
18e88: e8bd8870 pop {r4, r5, r6, fp, pc}
00026054 <lstat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
26054: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
26058: e2515000 subs r5, r1, #0 <== NOT EXECUTED
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
2605c: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
26060: e1a06000 mov r6, r0 <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
26064: 1a000002 bne 26074 <lstat+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
26068: eb005ba4 bl 3cf00 <__errno> <== NOT EXECUTED
2606c: e3a0300e mov r3, #14 <== NOT EXECUTED
26070: ea000018 b 260d8 <lstat+0x84> <== NOT EXECUTED
status = rtems_filesystem_evaluate_path( path, strlen( path ),
26074: eb00769e bl 43af4 <strlen> <== NOT EXECUTED
26078: e28d4004 add r4, sp, #4 <== NOT EXECUTED
2607c: e3a0c000 mov ip, #0 <== NOT EXECUTED
26080: e1a01000 mov r1, r0 <== NOT EXECUTED
26084: e1a0200c mov r2, ip <== NOT EXECUTED
26088: e1a00006 mov r0, r6 <== NOT EXECUTED
2608c: e1a03004 mov r3, r4 <== NOT EXECUTED
26090: e58dc000 str ip, [sp] <== NOT EXECUTED
26094: ebff8568 bl 763c <rtems_filesystem_evaluate_path> <== NOT EXECUTED
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
26098: e2501000 subs r1, r0, #0 <== NOT EXECUTED
2609c: 1a00000e bne 260dc <lstat+0x88> <== NOT EXECUTED
return -1;
if ( !loc.handlers->fstat_h ){
260a0: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
260a4: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED
260a8: e3530000 cmp r3, #0 <== NOT EXECUTED
260ac: 1a00000c bne 260e4 <lstat+0x90> <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
260b0: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
260b4: e3530000 cmp r3, #0 <== NOT EXECUTED
260b8: 0a000004 beq 260d0 <lstat+0x7c> <== NOT EXECUTED
260bc: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
260c0: e3530000 cmp r3, #0 <== NOT EXECUTED
260c4: 11a00004 movne r0, r4 <== NOT EXECUTED
260c8: 11a0e00f movne lr, pc <== NOT EXECUTED
260cc: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
260d0: eb005b8a bl 3cf00 <__errno> <== NOT EXECUTED
260d4: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
260d8: e5803000 str r3, [r0] <== NOT EXECUTED
260dc: e3e05000 mvn r5, #0 <== NOT EXECUTED
260e0: ea000010 b 26128 <lstat+0xd4> <== NOT EXECUTED
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
260e4: e3a02048 mov r2, #72 ; 0x48 <== NOT EXECUTED
260e8: e1a00005 mov r0, r5 <== NOT EXECUTED
260ec: eb0068ba bl 403dc <memset> <== NOT EXECUTED
status = (*loc.handlers->fstat_h)( &loc, buf );
260f0: e1a01005 mov r1, r5 <== NOT EXECUTED
260f4: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
260f8: e1a00004 mov r0, r4 <== NOT EXECUTED
260fc: e1a0e00f mov lr, pc <== NOT EXECUTED
26100: e593f018 ldr pc, [r3, #24] <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
26104: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
26108: 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 );
2610c: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
26110: 0a000004 beq 26128 <lstat+0xd4> <== NOT EXECUTED
26114: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
26118: e3530000 cmp r3, #0 <== NOT EXECUTED
2611c: 11a00004 movne r0, r4 <== NOT EXECUTED
26120: 11a0e00f movne lr, pc <== NOT EXECUTED
26124: 112fff13 bxne r3 <== NOT EXECUTED
return status;
}
26128: e1a00005 mov r0, r5 <== NOT EXECUTED
2612c: e28dd018 add sp, sp, #24 <== NOT EXECUTED
26130: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00002200 <malloc>:
size_t size
)
{
void *return_this;
MSBUMP(malloc_calls, 1);
2200: e59f30d8 ldr r3, [pc, #216] ; 22e0 <malloc+0xe0>
2204: e5932004 ldr r2, [r3, #4]
2208: e2822001 add r2, r2, #1
220c: e92d4070 push {r4, r5, r6, lr}
2210: e5832004 str r2, [r3, #4]
2214: e1a04000 mov r4, r0
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
2218: ebffffb5 bl 20f4 <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
221c: e3540000 cmp r4, #0
2220: 0a00002b beq 22d4 <malloc+0xd4>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
2224: e59f30b8 ldr r3, [pc, #184] ; 22e4 <malloc+0xe4>
2228: e5933000 ldr r3, [r3]
222c: e3530003 cmp r3, #3
2230: 1a000002 bne 2240 <malloc+0x40>
2234: ebffff97 bl 2098 <malloc_is_system_state_OK>
2238: e3500000 cmp r0, #0
223c: 0a000024 beq 22d4 <malloc+0xd4>
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
2240: e59f30a0 ldr r3, [pc, #160] ; 22e8 <malloc+0xe8>
2244: e3a02000 mov r2, #0
2248: e5930000 ldr r0, [r3]
224c: e1a01004 mov r1, r4
2250: e1a03002 mov r3, r2
2254: eb0011ff bl 6a58 <_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 ) {
2258: 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;
225c: 11a05006 movne r5, r6
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
2260: 1a00000c bne 2298 <malloc+0x98>
if (rtems_malloc_sbrk_helpers)
2264: e59f3080 ldr r3, [pc, #128] ; 22ec <malloc+0xec>
2268: e5933000 ldr r3, [r3]
226c: e3530000 cmp r3, #0
2270: 0a000004 beq 2288 <malloc+0x88>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
2274: e1a00004 mov r0, r4 <== NOT EXECUTED
2278: e1a0e00f mov lr, pc <== NOT EXECUTED
227c: e593f004 ldr pc, [r3, #4] <== NOT EXECUTED
if ( !return_this ) {
2280: e2505000 subs r5, r0, #0 <== NOT EXECUTED
2284: 1a000003 bne 2298 <malloc+0x98> <== NOT EXECUTED
errno = ENOMEM;
2288: eb002c4d bl d3c4 <__errno>
228c: e3a0300c mov r3, #12
2290: e5803000 str r3, [r0]
return (void *) 0;
2294: ea00000f b 22d8 <malloc+0xd8>
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
2298: e59f3050 ldr r3, [pc, #80] ; 22f0 <malloc+0xf0>
229c: e5933000 ldr r3, [r3]
22a0: e3530000 cmp r3, #0
(*rtems_malloc_dirty_helper)( return_this, size );
22a4: 11a01004 movne r1, r4
22a8: 11a00005 movne r0, r5
22ac: 11a0e00f movne lr, pc
22b0: 112fff13 bxne r3
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
22b4: e59f3038 ldr r3, [pc, #56] ; 22f4 <malloc+0xf4>
22b8: e5933000 ldr r3, [r3]
22bc: e3530000 cmp r3, #0
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
22c0: 11a00005 movne r0, r5
22c4: 11a0e00f movne lr, pc
22c8: 1593f004 ldrne pc, [r3, #4]
22cc: e1a06005 mov r6, r5
22d0: ea000000 b 22d8 <malloc+0xd8>
22d4: e3a06000 mov r6, #0 <== NOT EXECUTED
if (rtems_malloc_boundary_helpers)
(*rtems_malloc_boundary_helpers->at_malloc)(return_this, size);
#endif
return return_this;
}
22d8: e1a00006 mov r0, r6
22dc: e8bd8070 pop {r4, r5, r6, pc}
000020e4 <malloc_deferred_free>:
}
void malloc_deferred_free(
void *pointer
)
{
20e4: 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 );
20e8: e59f0000 ldr r0, [pc, #0] ; 20f0 <malloc_deferred_free+0xc><== NOT EXECUTED
20ec: ea000e55 b 5a48 <_Chain_Append> <== NOT EXECUTED
000020f4 <malloc_deferred_frees_process>:
{
rtems_chain_initialize_empty(&RTEMS_Malloc_GC_list);
}
void malloc_deferred_frees_process(void)
{
20f4: 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)
20f8: ea000000 b 2100 <malloc_deferred_frees_process+0xc>
free(to_be_freed);
20fc: ebffff73 bl 1ed0 <free> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
2100: e59f000c ldr r0, [pc, #12] ; 2114 <malloc_deferred_frees_process+0x20>
2104: eb000e63 bl 5a98 <_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)
2108: e3500000 cmp r0, #0
210c: 1afffffa bne 20fc <malloc_deferred_frees_process+0x8>
free(to_be_freed);
}
2110: e49df004 pop {pc} ; (ldr pc, [sp], #4)
0000beac <memfile_ftruncate>:
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
beac: e92d4013 push {r0, r1, r4, lr}
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
beb0: 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 )
beb4: e5943054 ldr r3, [r4, #84] ; 0x54
beb8: e1530002 cmp r3, r2
bebc: ba000003 blt bed0 <memfile_ftruncate+0x24>
bec0: 1a000005 bne bedc <memfile_ftruncate+0x30>
bec4: e5943050 ldr r3, [r4, #80] ; 0x50
bec8: e1530001 cmp r3, r1
becc: 2a000002 bcs bedc <memfile_ftruncate+0x30>
return IMFS_memfile_extend( the_jnode, length );
bed0: e1a00004 mov r0, r4 <== NOT EXECUTED
bed4: ebffff9a bl bd44 <IMFS_memfile_extend> <== NOT EXECUTED
bed8: ea000008 b bf00 <memfile_ftruncate+0x54> <== NOT EXECUTED
* 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;
bedc: e5841050 str r1, [r4, #80] ; 0x50
bee0: e5842054 str r2, [r4, #84] ; 0x54
iop->size = the_jnode->info.file.size;
bee4: e9800006 stmib r0, {r1, r2}
IMFS_update_atime( the_jnode );
bee8: e3a01000 mov r1, #0
beec: e1a0000d mov r0, sp
bef0: ebffd81f bl 1f74 <gettimeofday>
bef4: e59d3000 ldr r3, [sp]
bef8: e5843040 str r3, [r4, #64] ; 0x40
befc: e3a00000 mov r0, #0
return 0;
}
bf00: e8bd801c pop {r2, r3, r4, pc}
0000bf04 <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
bf04: e92d4030 push {r4, r5, lr}
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
bf08: e5905038 ldr r5, [r0, #56] ; 0x38
if (the_jnode->type == IMFS_LINEAR_FILE) {
bf0c: e595304c ldr r3, [r5, #76] ; 0x4c
bf10: e3530006 cmp r3, #6
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
bf14: e1a04000 mov r4, r0
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
if (the_jnode->type == IMFS_LINEAR_FILE) {
bf18: 1a00000b bne bf4c <memfile_lseek+0x48>
if (iop->offset > the_jnode->info.linearfile.size)
bf1c: e5902010 ldr r2, [r0, #16] <== NOT EXECUTED
bf20: e5953054 ldr r3, [r5, #84] ; 0x54 <== NOT EXECUTED
bf24: e1520003 cmp r2, r3 <== NOT EXECUTED
bf28: e5952050 ldr r2, [r5, #80] ; 0x50 <== NOT EXECUTED
bf2c: ca000003 bgt bf40 <memfile_lseek+0x3c> <== NOT EXECUTED
bf30: 1a000014 bne bf88 <memfile_lseek+0x84> <== NOT EXECUTED
bf34: e590100c ldr r1, [r0, #12] <== NOT EXECUTED
bf38: e1510002 cmp r1, r2 <== NOT EXECUTED
bf3c: 9a000011 bls bf88 <memfile_lseek+0x84> <== NOT EXECUTED
iop->offset = the_jnode->info.linearfile.size;
bf40: e584200c str r2, [r4, #12] <== NOT EXECUTED
bf44: e5843010 str r3, [r4, #16] <== NOT EXECUTED
bf48: ea00000e b bf88 <memfile_lseek+0x84> <== NOT EXECUTED
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
bf4c: e1a00005 mov r0, r5
bf50: e284200c add r2, r4, #12
bf54: e8920006 ldm r2, {r1, r2}
bf58: ebffff79 bl bd44 <IMFS_memfile_extend>
bf5c: e3500000 cmp r0, #0
bf60: 0a000005 beq bf7c <memfile_lseek+0x78>
rtems_set_errno_and_return_minus_one( ENOSPC );
bf64: eb000516 bl d3c4 <__errno> <== NOT EXECUTED
bf68: e3a0301c mov r3, #28 <== NOT EXECUTED
bf6c: e5803000 str r3, [r0] <== NOT EXECUTED
bf70: e3e04000 mvn r4, #0 <== NOT EXECUTED
bf74: e3e03000 mvn r3, #0 <== NOT EXECUTED
bf78: ea000004 b bf90 <memfile_lseek+0x8c> <== NOT EXECUTED
iop->size = the_jnode->info.file.size;
bf7c: e2853050 add r3, r5, #80 ; 0x50
bf80: e893000c ldm r3, {r2, r3}
bf84: e984000c stmib r4, {r2, r3}
}
return iop->offset;
bf88: e284400c add r4, r4, #12
bf8c: e8940018 ldm r4, {r3, r4}
}
bf90: e1a01004 mov r1, r4
bf94: e1a00003 mov r0, r3
bf98: e8bd8030 pop {r4, r5, pc}
0000c228 <memfile_open>:
the_jnode = iop->file_info;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
c228: e5903014 ldr r3, [r0, #20]
c22c: e3130f81 tst r3, #516 ; 0x204
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
c230: e92d4031 push {r0, r4, r5, lr}
c234: e1a05000 mov r5, r0
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
c238: e5904038 ldr r4, [r0, #56] ; 0x38
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
c23c: 0a000017 beq c2a0 <memfile_open+0x78>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
c240: e594304c ldr r3, [r4, #76] ; 0x4c
c244: e3530006 cmp r3, #6
c248: 1a000014 bne c2a0 <memfile_open+0x78>
uint32_t count = the_jnode->info.linearfile.size;
c24c: e594c050 ldr ip, [r4, #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;
c250: e3a02000 mov r2, #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;
c254: e3a03005 mov r3, #5 <== NOT EXECUTED
the_jnode->info.file.size = 0;
c258: e3a00000 mov r0, #0 <== NOT EXECUTED
c25c: e3a01000 mov r1, #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)
c260: 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;
c264: e584304c str r3, [r4, #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;
c268: e5842060 str r2, [r4, #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;
c26c: e5943058 ldr r3, [r4, #88] ; 0x58 <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
c270: e5840050 str r0, [r4, #80] ; 0x50 <== NOT EXECUTED
c274: e5841054 str r1, [r4, #84] ; 0x54 <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
c278: e584205c str r2, [r4, #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;
c27c: e5842058 str r2, [r4, #88] ; 0x58 <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
c280: 0a000006 beq c2a0 <memfile_open+0x78> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
c284: e1a02001 mov r2, r1 <== NOT EXECUTED
c288: e1a01000 mov r1, r0 <== NOT EXECUTED
c28c: e1a00004 mov r0, r4 <== NOT EXECUTED
c290: e58dc000 str ip, [sp] <== NOT EXECUTED
c294: ebffff40 bl bf9c <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)
c298: e3700001 cmn r0, #1 <== NOT EXECUTED
c29c: 0a000009 beq c2c8 <memfile_open+0xa0> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
c2a0: e5953014 ldr r3, [r5, #20]
c2a4: e3130c02 tst r3, #512 ; 0x200
iop->offset = the_jnode->info.file.size;
c2a8: 12843050 addne r3, r4, #80 ; 0x50
c2ac: 1893000c ldmne r3, {r2, r3}
c2b0: 1585200c strne r2, [r5, #12]
c2b4: 15853010 strne r3, [r5, #16]
iop->size = the_jnode->info.file.size;
c2b8: e2844050 add r4, r4, #80 ; 0x50
c2bc: e8940018 ldm r4, {r3, r4}
c2c0: e9850018 stmib r5, {r3, r4}
c2c4: e3a00000 mov r0, #0
return 0;
}
c2c8: e8bd8038 pop {r3, r4, r5, pc}
00002308 <mknod>:
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
2308: e92d41f0 push {r4, r5, r6, r7, r8, lr}
230c: e1a05001 mov r5, r1
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
2310: e2011a0f and r1, r1, #61440 ; 0xf000
2314: e3510901 cmp r1, #16384 ; 0x4000
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
2318: e24dd020 sub sp, sp, #32
231c: e1a06000 mov r6, r0
2320: e1a07002 mov r7, r2
2324: 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)
2328: 0a00000b beq 235c <mknod+0x54>
232c: 8a000003 bhi 2340 <mknod+0x38>
2330: e3510a01 cmp r1, #4096 ; 0x1000
2334: 0a000008 beq 235c <mknod+0x54>
2338: e3510a02 cmp r1, #8192 ; 0x2000
233c: ea000002 b 234c <mknod+0x44>
2340: e3510a06 cmp r1, #24576 ; 0x6000
2344: 0a000004 beq 235c <mknod+0x54>
2348: e3510902 cmp r1, #32768 ; 0x8000
234c: 0a000002 beq 235c <mknod+0x54>
case S_IFBLK:
case S_IFREG:
case S_IFIFO:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
2350: eb002c1b bl d3c4 <__errno> <== NOT EXECUTED
2354: e3a03016 mov r3, #22 <== NOT EXECUTED
2358: ea00000a b 2388 <mknod+0x80> <== NOT EXECUTED
}
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
235c: e28d4004 add r4, sp, #4
2360: e1a00006 mov r0, r6
2364: e28d101c add r1, sp, #28
2368: e1a02004 mov r2, r4
236c: eb000275 bl 2d48 <rtems_filesystem_get_start_loc>
if ( !temp_loc.ops->evalformake_h ) {
2370: e59d3010 ldr r3, [sp, #16]
2374: e5933004 ldr r3, [r3, #4]
2378: e3530000 cmp r3, #0
237c: 1a000004 bne 2394 <mknod+0x8c>
rtems_set_errno_and_return_minus_one( ENOTSUP );
2380: eb002c0f bl d3c4 <__errno> <== NOT EXECUTED
2384: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
2388: e5803000 str r3, [r0] <== NOT EXECUTED
238c: e3e05000 mvn r5, #0
2390: ea000022 b 2420 <mknod+0x118>
}
result = (*temp_loc.ops->evalformake_h)(
2394: e59d001c ldr r0, [sp, #28]
2398: e1a01004 mov r1, r4
239c: e0860000 add r0, r6, r0
23a0: e28d2018 add r2, sp, #24
23a4: e1a0e00f mov lr, pc
23a8: e12fff13 bx r3
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
23ac: e3500000 cmp r0, #0
23b0: 1afffff5 bne 238c <mknod+0x84>
return -1;
if ( !temp_loc.ops->mknod_h ) {
23b4: e59d3010 ldr r3, [sp, #16]
23b8: e593c014 ldr ip, [r3, #20]
23bc: e35c0000 cmp ip, #0
23c0: 1a000006 bne 23e0 <mknod+0xd8>
rtems_filesystem_freenode( &temp_loc );
23c4: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
23c8: e3530000 cmp r3, #0 <== NOT EXECUTED
23cc: 0affffeb beq 2380 <mknod+0x78> <== NOT EXECUTED
23d0: e1a00004 mov r0, r4 <== NOT EXECUTED
23d4: e1a0e00f mov lr, pc <== NOT EXECUTED
23d8: e12fff13 bx r3 <== NOT EXECUTED
23dc: eaffffe7 b 2380 <mknod+0x78> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
23e0: e1a01005 mov r1, r5
23e4: e1a03008 mov r3, r8
23e8: e58d4000 str r4, [sp]
23ec: e1a02007 mov r2, r7
23f0: e59d0018 ldr r0, [sp, #24]
23f4: e1a0e00f mov lr, pc
23f8: e12fff1c bx ip
rtems_filesystem_freenode( &temp_loc );
23fc: e59d3010 ldr r3, [sp, #16]
2400: 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 );
2404: e1a05000 mov r5, r0
rtems_filesystem_freenode( &temp_loc );
2408: 0a000004 beq 2420 <mknod+0x118>
240c: e593301c ldr r3, [r3, #28]
2410: e3530000 cmp r3, #0
2414: 11a00004 movne r0, r4
2418: 11a0e00f movne lr, pc
241c: 112fff13 bxne r3
return result;
}
2420: e1a00005 mov r0, r5
2424: e28dd020 add sp, sp, #32
2428: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
000024b4 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
24b4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
24b8: e3530001 cmp r3, #1
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
24bc: e24dd028 sub sp, sp, #40 ; 0x28
24c0: e58d300c str r3, [sp, #12]
24c4: e1a08000 mov r8, r0
24c8: e1a07001 mov r7, r1
24cc: e1a0b002 mov fp, r2
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
24d0: 8a000004 bhi 24e8 <mount+0x34>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
24d4: e1a00002 mov r0, r2
24d8: eb002048 bl a600 <rtems_filesystem_get_mount_handler>
if ( !mount_h )
24dc: e3500000 cmp r0, #0
24e0: e58d0010 str r0, [sp, #16]
24e4: 1a000002 bne 24f4 <mount+0x40>
rtems_set_errno_and_return_minus_one( EINVAL );
24e8: eb002bb5 bl d3c4 <__errno>
24ec: e3a03016 mov r3, #22
24f0: ea000039 b 25dc <mount+0x128>
{
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;
24f4: e2575000 subs r5, r7, #0
24f8: 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 : "/";
24fc: e59f32ac ldr r3, [pc, #684] ; 27b0 <mount+0x2fc>
2500: e3550000 cmp r5, #0
2504: 11a03007 movne r3, r7
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
2508: e1a0000b mov r0, fp
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
250c: e58d3004 str r3, [sp, #4]
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
2510: eb002fb0 bl e3d8 <strlen>
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
2514: 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;
2518: e2806001 add r6, r0, #1
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
251c: 01a0a008 moveq sl, r8
2520: 0a000002 beq 2530 <mount+0x7c>
2524: e1a00008 mov r0, r8
2528: eb002faa bl e3d8 <strlen>
252c: e280a001 add sl, r0, #1
size_t target_length = strlen( target );
2530: e59d0004 ldr r0, [sp, #4]
2534: eb002fa7 bl e3d8 <strlen>
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 );
2538: e2861075 add r1, r6, #117 ; 0x75
253c: e0811000 add r1, r1, r0
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_length = strlen( target );
2540: e58d0008 str r0, [sp, #8]
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 );
2544: e081100a add r1, r1, sl
2548: e3a00001 mov r0, #1
254c: ebfffdd7 bl 1cb0 <calloc>
if ( mt_entry != NULL ) {
2550: e2504000 subs r4, r0, #0
2554: 0a00001e beq 25d4 <mount+0x120>
char *str = (char *) mt_entry + sizeof( *mt_entry );
2558: e2849074 add r9, r4, #116 ; 0x74
strcpy( str, filesystemtype );
255c: e1a0100b mov r1, fp
2560: e1a00009 mov r0, r9
2564: eb002f4b bl e298 <strcpy>
mt_entry->type = str;
str += filesystemtype_size;
if ( source_or_null != NULL ) {
2568: 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;
256c: e0896006 add r6, r9, r6
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
strcpy( str, filesystemtype );
mt_entry->type = str;
2570: e584906c str r9, [r4, #108] ; 0x6c
str += filesystemtype_size;
if ( source_or_null != NULL ) {
2574: 0a000004 beq 258c <mount+0xd8>
strcpy( str, source_or_null );
2578: e1a00006 mov r0, r6
257c: e1a01008 mov r1, r8
2580: eb002f44 bl e298 <strcpy>
mt_entry->dev = str;
2584: e5846070 str r6, [r4, #112] ; 0x70
str += source_size;
2588: e086600a add r6, r6, sl
}
strcpy( str, target );
258c: e59d1004 ldr r1, [sp, #4]
2590: e1a00006 mov r0, r6
2594: eb002f3f bl e298 <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;
2598: e59fe214 ldr lr, [pc, #532] ; 27b4 <mount+0x300>
259c: e8be000f ldm lr!, {r0, r1, r2, r3}
25a0: e284c038 add ip, r4, #56 ; 0x38
25a4: e8ac000f stmia ip!, {r0, r1, r2, r3}
25a8: e8be000f ldm lr!, {r0, r1, r2, r3}
25ac: e8ac000f stmia ip!, {r0, r1, r2, r3}
25b0: e89e000f ldm lr, {r0, r1, r2, r3}
25b4: 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;
25b8: e59d300c ldr r3, [sp, #12]
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
25bc: e3550000 cmp r5, #0
mt_entry->dev = str;
str += source_size;
}
strcpy( str, target );
mt_entry->target = str;
25c0: 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;
25c4: 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;
25c8: 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 ) {
25cc: 0a000037 beq 26b0 <mount+0x1fc>
25d0: ea000003 b 25e4 <mount+0x130>
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
25d4: eb002b7a bl d3c4 <__errno> <== NOT EXECUTED
25d8: e3a0300c mov r3, #12 <== NOT EXECUTED
25dc: e5803000 str r3, [r0]
25e0: ea00006f b 27a4 <mount+0x2f0>
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
25e4: e28d6014 add r6, sp, #20
25e8: e3a0c001 mov ip, #1
25ec: e1a00007 mov r0, r7
25f0: e59d1008 ldr r1, [sp, #8]
25f4: e3a02007 mov r2, #7
25f8: e1a03006 mov r3, r6
25fc: e58dc000 str ip, [sp]
2600: ebfffe14 bl 1e58 <rtems_filesystem_evaluate_path>
2604: e3700001 cmn r0, #1
2608: 0a000058 beq 2770 <mount+0x2bc>
/*
* Test for node_type_h
*/
if (!loc.ops->node_type_h) {
260c: e59d3020 ldr r3, [sp, #32]
2610: e5933010 ldr r3, [r3, #16]
2614: e3530000 cmp r3, #0
2618: 0a00001b beq 268c <mount+0x1d8>
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
261c: e1a00006 mov r0, r6
2620: e1a0e00f mov lr, pc
2624: e12fff13 bx r3
2628: e3500001 cmp r0, #1
262c: 0a000003 beq 2640 <mount+0x18c>
errno = ENOTDIR;
2630: eb002b63 bl d3c4 <__errno>
2634: e3a03014 mov r3, #20
2638: e5803000 str r3, [r0]
goto cleanup_and_bail;
263c: ea00004c b 2774 <mount+0x2c0>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
2640: e59f0170 ldr r0, [pc, #368] ; 27b8 <mount+0x304>
2644: e59d1014 ldr r1, [sp, #20]
2648: ebffff7c bl 2440 <rtems_filesystem_mount_iterate>
264c: e3500000 cmp r0, #0
2650: 0a000002 beq 2660 <mount+0x1ac>
errno = EBUSY;
2654: eb002b5a bl d3c4 <__errno>
2658: e3a03010 mov r3, #16
265c: eafffff5 b 2638 <mount+0x184>
* 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;
2660: e59d1014 ldr r1, [sp, #20]
mt_entry->mt_point_node.handlers = loc.handlers;
mt_entry->mt_point_node.ops = loc.ops;
2664: 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;
2668: e5841008 str r1, [r4, #8]
mt_entry->mt_point_node.handlers = loc.handlers;
266c: 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 ){
2670: 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;
2674: e5841010 str r1, [r4, #16]
mt_entry->mt_point_node.ops = loc.ops;
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
2678: 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 ){
267c: 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;
2680: 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;
2684: 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 ){
2688: 1a000002 bne 2698 <mount+0x1e4>
errno = ENOTSUP;
268c: eb002b4c bl d3c4 <__errno> <== NOT EXECUTED
2690: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
2694: eaffffe7 b 2638 <mount+0x184> <== NOT EXECUTED
goto cleanup_and_bail;
}
if ( loc.ops->mount_h( mt_entry ) ) {
2698: e1a00004 mov r0, r4
269c: e1a0e00f mov lr, pc
26a0: e12fff13 bx r3
26a4: e3500000 cmp r0, #0
26a8: 0a00000b beq 26dc <mount+0x228>
26ac: ea000030 b 2774 <mount+0x2c0> <== NOT EXECUTED
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
26b0: e59f3104 ldr r3, [pc, #260] ; 27bc <mount+0x308>
26b4: e5932000 ldr r2, [r3]
26b8: e2833004 add r3, r3, #4
26bc: e1520003 cmp r2, r3
26c0: 01a06005 moveq r6, r5
26c4: 0a000004 beq 26dc <mount+0x228>
errno = EINVAL;
26c8: eb002b3d bl d3c4 <__errno> <== NOT EXECUTED
26cc: e3a03016 mov r3, #22 <== NOT EXECUTED
26d0: e5803000 str r3, [r0] <== NOT EXECUTED
26d4: e1a06005 mov r6, r5 <== NOT EXECUTED
goto cleanup_and_bail;
26d8: ea000025 b 2774 <mount+0x2c0> <== NOT EXECUTED
* 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 ) ) {
26dc: e59d104c ldr r1, [sp, #76] ; 0x4c
26e0: e1a00004 mov r0, r4
26e4: e59d3010 ldr r3, [sp, #16]
26e8: e1a0e00f mov lr, pc
26ec: e12fff13 bx r3
26f0: e2507000 subs r7, r0, #0
26f4: 0a000007 beq 2718 <mount+0x264>
/*
* Try to undo the mount operation
*/
if ( loc.ops->unmount_h ) {
26f8: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
26fc: e5933028 ldr r3, [r3, #40] ; 0x28 <== NOT EXECUTED
2700: e3530000 cmp r3, #0 <== NOT EXECUTED
2704: 0a00001a beq 2774 <mount+0x2c0> <== NOT EXECUTED
loc.ops->unmount_h( mt_entry );
2708: e1a00004 mov r0, r4 <== NOT EXECUTED
270c: e1a0e00f mov lr, pc <== NOT EXECUTED
2710: e12fff13 bx r3 <== NOT EXECUTED
2714: ea000016 b 2774 <mount+0x2c0> <== 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 );
2718: e59f60a0 ldr r6, [pc, #160] ; 27c0 <mount+0x30c>
271c: e1a02007 mov r2, r7
2720: e1a01007 mov r1, r7
2724: e5960000 ldr r0, [r6]
2728: eb000a9b bl 519c <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 );
272c: e1a01004 mov r1, r4
2730: e59f0084 ldr r0, [pc, #132] ; 27bc <mount+0x308>
2734: eb000cc3 bl 5a48 <_Chain_Append>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
2738: e5960000 ldr r0, [r6]
273c: eb000adc bl 52b4 <rtems_semaphore_release>
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
2740: e3550000 cmp r5, #0
rtems_filesystem_root = mt_entry->mt_fs_root;
2744: 059f3078 ldreq r3, [pc, #120] ; 27c4 <mount+0x310>
2748: 0284401c addeq r4, r4, #28
274c: 0593c000 ldreq ip, [r3]
2750: 08b4000f ldmeq r4!, {r0, r1, r2, r3}
2754: 028cc018 addeq ip, ip, #24
2758: 08ac000f stmiaeq ip!, {r0, r1, r2, r3}
275c: 05943000 ldreq r3, [r4]
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
2760: 11a00007 movne r0, r7
rtems_filesystem_root = mt_entry->mt_fs_root;
2764: 058c3000 streq r3, [ip]
2768: 01a00005 moveq r0, r5
276c: ea00000d b 27a8 <mount+0x2f4>
2770: e3a06000 mov r6, #0 <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( mt_entry );
2774: e1a00004 mov r0, r4
2778: ebfffdd4 bl 1ed0 <free>
if ( loc_to_free )
277c: e3560000 cmp r6, #0
2780: 0a000007 beq 27a4 <mount+0x2f0>
rtems_filesystem_freenode( loc_to_free );
2784: e596300c ldr r3, [r6, #12]
2788: e3530000 cmp r3, #0
278c: 0a000004 beq 27a4 <mount+0x2f0>
2790: e593301c ldr r3, [r3, #28]
2794: e3530000 cmp r3, #0
2798: 11a00006 movne r0, r6
279c: 11a0e00f movne lr, pc
27a0: 112fff13 bxne r3
27a4: e3e00000 mvn r0, #0
return -1;
}
27a8: e28dd028 add sp, sp, #40 ; 0x28
27ac: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00030f04 <msdos_creat_node>:
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
30f04: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
30f08: e24dd0a8 sub sp, sp, #168 ; 0xa8 <== NOT EXECUTED
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;
fat_file_fd_t *fat_fd = NULL;
30f0c: e3a05000 mov r5, #0 <== 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;
30f10: e590e010 ldr lr, [r0, #16] <== 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);
30f14: e28da070 add sl, sp, #112 ; 0x70 <== 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;
30f18: e3e0c000 mvn ip, #0 <== NOT EXECUTED
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
30f1c: e1a04000 mov r4, r0 <== NOT EXECUTED
30f20: e1a09002 mov r9, r2 <== NOT EXECUTED
30f24: e1a06001 mov r6, r1 <== 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);
30f28: e3a02020 mov r2, #32 <== NOT EXECUTED
30f2c: e1a01005 mov r1, r5 <== NOT EXECUTED
30f30: e1a0000a mov r0, sl <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
30f34: e58dc09c str ip, [sp, #156] ; 0x9c <== NOT EXECUTED
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
30f38: e1a0b003 mov fp, r3 <== NOT EXECUTED
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
30f3c: e59e8034 ldr r8, [lr, #52] ; 0x34 <== 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;
30f40: e58dc098 str ip, [sp, #152] ; 0x98 <== NOT EXECUTED
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
fat_file_fd_t *fat_fd = NULL;
30f44: e58d50a0 str r5, [sp, #160] ; 0xa0 <== NOT EXECUTED
time_t time_ret = 0;
uint16_t time_val = 0;
30f48: e1cd5ab6 strh r5, [sp, #166] ; 0xa6 <== NOT EXECUTED
uint16_t date = 0;
30f4c: e1cd5ab4 strh r5, [sp, #164] ; 0xa4 <== NOT EXECUTED
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
30f50: e58d5090 str r5, [sp, #144] ; 0x90 <== NOT EXECUTED
dir_pos->sname.ofs = 0;
30f54: e58d5094 str r5, [sp, #148] ; 0x94 <== 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;
30f58: e5947000 ldr r7, [r4] <== 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);
30f5c: eb003d1e bl 403dc <memset> <== NOT EXECUTED
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
30f60: e1a01005 mov r1, r5 <== NOT EXECUTED
30f64: e3a02040 mov r2, #64 ; 0x40 <== NOT EXECUTED
30f68: e28d0010 add r0, sp, #16 <== NOT EXECUTED
30f6c: eb003d1a bl 403dc <memset> <== NOT EXECUTED
name_type = msdos_long_to_short (name, name_len,
30f70: e1a0100b mov r1, fp <== NOT EXECUTED
30f74: e1a0200a mov r2, sl <== NOT EXECUTED
30f78: e3a0300b mov r3, #11 <== NOT EXECUTED
30f7c: e1a00009 mov r0, r9 <== NOT EXECUTED
30f80: eb000786 bl 32da0 <msdos_long_to_short> <== NOT EXECUTED
30f84: e58d000c str r0, [sp, #12] <== 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);
30f88: e1a00005 mov r0, r5 <== 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;
30f8c: e5cd507c strb r5, [sp, #124] ; 0x7c <== NOT EXECUTED
/* set up last write date and time */
time_ret = time(NULL);
30f90: eb005f4c bl 48cc8 <time> <== NOT EXECUTED
if ( time_ret == -1 )
30f94: e3700001 cmn r0, #1 <== NOT EXECUTED
30f98: 0a0000a9 beq 31244 <msdos_creat_node+0x340> <== NOT EXECUTED
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
30f9c: e28d10a4 add r1, sp, #164 ; 0xa4 <== NOT EXECUTED
30fa0: e28d20a6 add r2, sp, #166 ; 0xa6 <== NOT EXECUTED
30fa4: eb0029cf bl 3b6e8 <msdos_date_unix2dos> <== NOT EXECUTED
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
30fa8: e1dd3ab6 ldrh r3, [sp, #166] ; 0xa6 <== NOT EXECUTED
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
30fac: e3560001 cmp r6, #1 <== 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);
30fb0: e1cd38b6 strh r3, [sp, #134] ; 0x86 <== NOT EXECUTED
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
30fb4: e1ddcab4 ldrh ip, [sp, #164] ; 0xa4 <== 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;
30fb8: 05dd307b ldrbeq r3, [sp, #123] ; 0x7b <== 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;
30fbc: e58d508c str r5, [sp, #140] ; 0x8c <== NOT EXECUTED
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);
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
30fc0: e1cdc8b8 strh ip, [sp, #136] ; 0x88 <== 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;
30fc4: 03833010 orreq r3, r3, #16 <== NOT EXECUTED
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
30fc8: 0a000032 beq 31098 <msdos_creat_node+0x194> <== NOT EXECUTED
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
}
else if (type == MSDOS_HARD_LINK) {
30fcc: e3560003 cmp r6, #3 <== 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;
30fd0: 15dd307b ldrbne r3, [sp, #123] ; 0x7b <== NOT EXECUTED
30fd4: 13833020 orrne r3, r3, #32 <== NOT EXECUTED
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
}
else if (type == MSDOS_HARD_LINK) {
30fd8: 1a00002e bne 31098 <msdos_creat_node+0x194> <== NOT EXECUTED
* node to the newly created
*/
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
30fdc: e59d30d0 ldr r3, [sp, #208] ; 0xd0 <== NOT EXECUTED
30fe0: e5932020 ldr r2, [r3, #32] <== NOT EXECUTED
30fe4: e5940010 ldr r0, [r4, #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)) )
30fe8: 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;
30fec: e5903034 ldr r3, [r0, #52] ; 0x34 <== NOT EXECUTED
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
30ff0: 1a000003 bne 31004 <msdos_creat_node+0x100> <== NOT EXECUTED
30ff4: e5d3100a ldrb r1, [r3, #10] <== NOT EXECUTED
30ff8: e3110003 tst r1, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
30ffc: 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)) )
31000: 1a000003 bne 31014 <msdos_creat_node+0x110> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
31004: e593c030 ldr ip, [r3, #48] ; 0x30 <== NOT EXECUTED
31008: e5d33005 ldrb r3, [r3, #5] <== NOT EXECUTED
3100c: e2421002 sub r1, r2, #2 <== NOT EXECUTED
31010: e08c1311 add r1, ip, r1, lsl r3 <== NOT EXECUTED
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
31014: e59dc0d0 ldr ip, [sp, #208] ; 0xd0 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ret = _fat_block_read(parent_loc->mt_entry,
31018: e1d820b0 ldrh r2, [r8] <== 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);
3101c: e59c3024 ldr r3, [ip, #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,
31020: e5d8c002 ldrb ip, [r8, #2] <== NOT EXECUTED
31024: e2422001 sub r2, r2, #1 <== NOT EXECUTED
31028: e0811c33 add r1, r1, r3, lsr ip <== NOT EXECUTED
3102c: e0022003 and r2, r2, r3 <== NOT EXECUTED
31030: e28dc050 add ip, sp, #80 ; 0x50 <== NOT EXECUTED
31034: e3a03020 mov r3, #32 <== NOT EXECUTED
31038: e58dc000 str ip, [sp] <== NOT EXECUTED
3103c: ebffc719 bl 22ca8 <_fat_block_read> <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
31040: e3500000 cmp r0, #0 <== NOT EXECUTED
31044: ba00007e blt 31244 <msdos_creat_node+0x340> <== NOT EXECUTED
return -1;
}
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
31048: e5dd305b ldrb r3, [sp, #91] ; 0x5b <== NOT EXECUTED
3104c: e5cd307b strb r3, [sp, #123] ; 0x7b <== 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;
31050: e5dd307b ldrb r3, [sp, #123] ; 0x7b <== 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);
31054: e59d106c ldr r1, [sp, #108] ; 0x6c <== 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;
31058: e3833020 orr r3, r3, #32 <== 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);
3105c: e5dd205d ldrb r2, [sp, #93] ; 0x5d <== 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);
31060: e58a101c str r1, [sl, #28] <== 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;
31064: e5cd307b strb r3, [sp, #123] ; 0x7b <== 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);
31068: e1dd35be ldrh r3, [sp, #94] ; 0x5e <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
3106c: e1ddc6b0 ldrh ip, [sp, #96] ; 0x60 <== 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);
31070: e1cd37be strh r3, [sp, #126] ; 0x7e <== 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) =
31074: e1dd36ba ldrh r3, [sp, #106] ; 0x6a <== 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);
31078: e1cdc8b0 strh ip, [sp, #128] ; 0x80 <== 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) =
3107c: e1cd38ba strh r3, [sp, #138] ; 0x8a <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
31080: e1ddc6b4 ldrh ip, [sp, #100] ; 0x64 <== 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);
31084: e1dd3ab4 ldrh r3, [sp, #164] ; 0xa4 <== 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);
31088: e5cd207d strb r2, [sp, #125] ; 0x7d <== NOT EXECUTED
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
3108c: e1cdc8b4 strh ip, [sp, #132] ; 0x84 <== 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);
31090: e1cd38b2 strh r3, [sp, #130] ; 0x82 <== NOT EXECUTED
31094: ea000000 b 3109c <msdos_creat_node+0x198> <== NOT EXECUTED
}
else { /* regular file... */
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
31098: e5cd307b strb r3, [sp, #123] ; 0x7b <== 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,
3109c: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED
310a0: e1a02009 mov r2, r9 <== NOT EXECUTED
310a4: e1a0300b mov r3, fp <== NOT EXECUTED
310a8: e28d9090 add r9, sp, #144 ; 0x90 <== NOT EXECUTED
310ac: e28da070 add sl, sp, #112 ; 0x70 <== NOT EXECUTED
310b0: e1a00004 mov r0, r4 <== NOT EXECUTED
310b4: e3a01001 mov r1, #1 <== NOT EXECUTED
310b8: e58dc000 str ip, [sp] <== NOT EXECUTED
310bc: e98d0600 stmib sp, {r9, sl} <== NOT EXECUTED
310c0: eb000820 bl 33148 <msdos_get_name_node> <== NOT EXECUTED
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
310c4: e2505000 subs r5, r0, #0 <== NOT EXECUTED
310c8: 1a00005e bne 31248 <msdos_creat_node+0x344> <== NOT EXECUTED
/*
* if we create a new file we are done, if directory there are more steps
* to do
*/
if (type == MSDOS_DIRECTORY)
310cc: e3560001 cmp r6, #1 <== NOT EXECUTED
310d0: 1a00005c bne 31248 <msdos_creat_node+0x344> <== NOT EXECUTED
{
/* open new directory as fat-file */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
310d4: e1a01009 mov r1, r9 <== NOT EXECUTED
310d8: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
310dc: e28d20a0 add r2, sp, #160 ; 0xa0 <== NOT EXECUTED
310e0: ebffc49d bl 2235c <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
310e4: e2505000 subs r5, r0, #0 <== NOT EXECUTED
310e8: 1a000050 bne 31230 <msdos_creat_node+0x32c> <== NOT EXECUTED
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
310ec: e59d30a0 ldr r3, [sp, #160] ; 0xa0 <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
310f0: e3a02602 mov r2, #2097152 ; 0x200000 <== NOT EXECUTED
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
310f4: e5835018 str r5, [r3, #24] <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
310f8: e5836010 str r6, [r3, #16] <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
310fc: e5832014 str r2, [r3, #20] <== NOT EXECUTED
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
31100: e1a0e00a mov lr, sl <== NOT EXECUTED
31104: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
31108: e28d5010 add r5, sp, #16 <== NOT EXECUTED
3110c: e1a0c005 mov ip, r5 <== NOT EXECUTED
31110: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
31114: e89e000f ldm lr, {r0, r1, r2, r3} <== NOT EXECUTED
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
31118: e2856020 add r6, r5, #32 <== NOT EXECUTED
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
3111c: e88c000f stm ip, {r0, r1, r2, r3} <== NOT EXECUTED
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
31120: e8ba000f ldm sl!, {r0, r1, r2, r3} <== NOT EXECUTED
31124: e1a0c006 mov ip, r6 <== NOT EXECUTED
31128: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3112c: e89e000f ldm lr, {r0, r1, r2, r3} <== NOT EXECUTED
31130: 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,
31134: e59f3118 ldr r3, [pc, #280] ; 31254 <msdos_creat_node+0x350><== NOT EXECUTED
31138: e3a0200b mov r2, #11 <== NOT EXECUTED
3113c: e5931000 ldr r1, [r3] <== NOT EXECUTED
31140: e1a00005 mov r0, r5 <== NOT EXECUTED
31144: eb003c1d bl 401c0 <memcpy> <== NOT EXECUTED
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
31148: e59f3108 ldr r3, [pc, #264] ; 31258 <msdos_creat_node+0x354><== NOT EXECUTED
3114c: e1a00006 mov r0, r6 <== NOT EXECUTED
31150: e5931000 ldr r1, [r3] <== NOT EXECUTED
31154: e3a0200b mov r2, #11 <== NOT EXECUTED
31158: eb003c18 bl 401c0 <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)) &&
3115c: e5973020 ldr r3, [r7, #32] <== NOT EXECUTED
31160: e3530001 cmp r3, #1 <== NOT EXECUTED
31164: 1a000007 bne 31188 <msdos_creat_node+0x284> <== NOT EXECUTED
31168: e5973024 ldr r3, [r7, #36] ; 0x24 <== NOT EXECUTED
3116c: e3530000 cmp r3, #0 <== NOT EXECUTED
31170: 1a000004 bne 31188 <msdos_creat_node+0x284> <== NOT EXECUTED
(fs_info->fat.vol.type & FAT_FAT32))
31174: e5d8200a ldrb r2, [r8, #10] <== NOT EXECUTED
31178: 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;
3117c: 11c533b4 strhne r3, [r5, #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;
31180: 11c533ba strhne r3, [r5, #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))
31184: 1a000003 bne 31198 <msdos_creat_node+0x294> <== 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)) =
31188: e597301c ldr r3, [r7, #28] <== NOT EXECUTED
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
3118c: e1a02823 lsr r2, r3, #16 <== NOT EXECUTED
31190: e1cd24b4 strh r2, [sp, #68] ; 0x44 <== 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)) =
31194: e1cd34ba strh r3, [sp, #74] ; 0x4a <== 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,
31198: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
3119c: e28d5010 add r5, sp, #16 <== NOT EXECUTED
311a0: e59d10a0 ldr r1, [sp, #160] ; 0xa0 <== NOT EXECUTED
311a4: e3a02000 mov r2, #0 <== NOT EXECUTED
311a8: e3a03040 mov r3, #64 ; 0x40 <== NOT EXECUTED
311ac: e58d5000 str r5, [sp] <== NOT EXECUTED
311b0: ebffc339 bl 21e9c <fat_file_write> <== NOT EXECUTED
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
311b4: e3500000 cmp r0, #0 <== NOT EXECUTED
311b8: ba000018 blt 31220 <msdos_creat_node+0x31c> <== NOT EXECUTED
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
311bc: e59d10a0 ldr r1, [sp, #160] ; 0xa0 <== NOT EXECUTED
311c0: e1d830b6 ldrh r3, [r8, #6] <== NOT EXECUTED
311c4: e2812018 add r2, r1, #24 <== NOT EXECUTED
311c8: e8921004 ldm r2, {r2, ip} <== NOT EXECUTED
311cc: e0823003 add r3, r2, r3 <== NOT EXECUTED
311d0: e5813018 str r3, [r1, #24] <== NOT EXECUTED
/* 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)) =
311d4: 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,
311d8: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
311dc: e3a02000 mov r2, #0 <== NOT EXECUTED
311e0: 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)) =
311e4: e1cde2b4 strh lr, [sp, #36] ; 0x24 <== 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,
311e8: e58d5000 str r5, [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)) =
311ec: e1cdc2ba strh ip, [sp, #42] ; 0x2a <== 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,
311f0: ebffc329 bl 21e9c <fat_file_write> <== NOT EXECUTED
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
311f4: e3500000 cmp r0, #0 <== NOT EXECUTED
311f8: ba000008 blt 31220 <msdos_creat_node+0x31c> <== 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);
311fc: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
31200: e59d10a0 ldr r1, [sp, #160] ; 0xa0 <== NOT EXECUTED
31204: eb0005e9 bl 329b0 <msdos_set_first_cluster_num> <== NOT EXECUTED
if (rc != RC_OK)
31208: e2505000 subs r5, r0, #0 <== NOT EXECUTED
3120c: 1a000004 bne 31224 <msdos_creat_node+0x320> <== NOT EXECUTED
goto error;
fat_file_close(parent_loc->mt_entry, fat_fd);
31210: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
31214: e59d10a0 ldr r1, [sp, #160] ; 0xa0 <== NOT EXECUTED
31218: ebffc426 bl 222b8 <fat_file_close> <== NOT EXECUTED
3121c: ea000009 b 31248 <msdos_creat_node+0x344> <== NOT EXECUTED
31220: e3e05000 mvn r5, #0 <== NOT EXECUTED
}
return RC_OK;
error:
fat_file_close(parent_loc->mt_entry, fat_fd);
31224: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
31228: e59d10a0 ldr r1, [sp, #160] ; 0xa0 <== NOT EXECUTED
3122c: ebffc421 bl 222b8 <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);
31230: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
31234: e28d1090 add r1, sp, #144 ; 0x90 <== NOT EXECUTED
31238: e3a020e5 mov r2, #229 ; 0xe5 <== NOT EXECUTED
3123c: eb000608 bl 32a64 <msdos_set_first_char4file_name> <== NOT EXECUTED
return rc;
31240: ea000000 b 31248 <msdos_creat_node+0x344> <== NOT EXECUTED
31244: e3e05000 mvn r5, #0 <== NOT EXECUTED
}
31248: e1a00005 mov r0, r5 <== NOT EXECUTED
3124c: e28dd0a8 add sp, sp, #168 ; 0xa8 <== NOT EXECUTED
31250: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0003b830 <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) {
3b830: e59f30e4 ldr r3, [pc, #228] ; 3b91c <msdos_date_dos2unix+0xec><== NOT EXECUTED
3b834: e1d320be ldrh r2, [r3, #14] <== NOT EXECUTED
3b838: 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)
{
3b83c: e92d4070 push {r4, r5, r6, lr} <== 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) {
3b840: 0a000028 beq 3b8e8 <msdos_date_dos2unix+0xb8> <== NOT EXECUTED
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
3b844: e200ccfe and ip, r0, #65024 ; 0xfe00 <== NOT EXECUTED
3b848: e3a02000 mov r2, #0 <== 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;
3b84c: e1c300be strh r0, [r3, #14] <== NOT EXECUTED
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
3b850: e1a0c4ac lsr ip, ip, #9 <== NOT EXECUTED
3b854: e1a03002 mov r3, r2 <== NOT EXECUTED
for (y = 0; y < year; y++)
days += y & 0x03 ? 365 : 366;
3b858: e59f50c0 ldr r5, [pc, #192] ; 3b920 <msdos_date_dos2unix+0xf0><== NOT EXECUTED
3b85c: e59f40c0 ldr r4, [pc, #192] ; 3b924 <msdos_date_dos2unix+0xf4><== 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++)
3b860: ea000004 b 3b878 <msdos_date_dos2unix+0x48> <== NOT EXECUTED
days += y & 0x03 ? 365 : 366;
3b864: e3120003 tst r2, #3 <== NOT EXECUTED
3b868: 11a06005 movne r6, r5 <== NOT EXECUTED
3b86c: 01a06004 moveq r6, r4 <== NOT EXECUTED
3b870: e0833006 add r3, r3, r6 <== 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++)
3b874: e2822001 add r2, r2, #1 <== NOT EXECUTED
3b878: e152000c cmp r2, ip <== NOT EXECUTED
3b87c: 3afffff8 bcc 3b864 <msdos_date_dos2unix+0x34> <== NOT EXECUTED
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
3b880: e31c0003 tst ip, #3 <== NOT EXECUTED
3b884: e59f409c ldr r4, [pc, #156] ; 3b928 <msdos_date_dos2unix+0xf8><== NOT EXECUTED
3b888: e59fc09c ldr ip, [pc, #156] ; 3b92c <msdos_date_dos2unix+0xfc><== NOT EXECUTED
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
3b88c: e2002e1e and r2, r0, #480 ; 0x1e0 <== NOT EXECUTED
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
3b890: 01a0400c moveq r4, ip <== NOT EXECUTED
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
3b894: e3520000 cmp r2, #0 <== NOT EXECUTED
3b898: 11a022a2 lsrne r2, r2, #5 <== NOT EXECUTED
3b89c: 03a02001 moveq r2, #1 <== NOT EXECUTED
month = 1;
}
for (m = 0; m < month - 1; m++)
3b8a0: e242c001 sub ip, r2, #1 <== NOT EXECUTED
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
3b8a4: e3a02000 mov r2, #0 <== NOT EXECUTED
month = 1;
}
for (m = 0; m < month - 1; m++)
3b8a8: ea000003 b 3b8bc <msdos_date_dos2unix+0x8c> <== NOT EXECUTED
days += months[m];
3b8ac: e1a05082 lsl r5, r2, #1 <== NOT EXECUTED
3b8b0: e19450b5 ldrh r5, [r4, r5] <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
3b8b4: e2822001 add r2, r2, #1 <== NOT EXECUTED
days += months[m];
3b8b8: e0833005 add r3, r3, r5 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
3b8bc: e152000c cmp r2, ip <== NOT EXECUTED
3b8c0: 3afffff9 bcc 3b8ac <msdos_date_dos2unix+0x7c> <== NOT EXECUTED
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
3b8c4: e200001f and r0, r0, #31 <== NOT EXECUTED
3b8c8: e2400001 sub r0, r0, #1 <== NOT EXECUTED
3b8cc: e0803003 add r3, r0, r3 <== NOT EXECUTED
3b8d0: e59f0058 ldr r0, [pc, #88] ; 3b930 <msdos_date_dos2unix+0x100><== NOT EXECUTED
3b8d4: e0020390 mul r2, r0, r3 <== NOT EXECUTED
3b8d8: e59f3054 ldr r3, [pc, #84] ; 3b934 <msdos_date_dos2unix+0x104><== NOT EXECUTED
3b8dc: e0823003 add r3, r2, r3 <== NOT EXECUTED
3b8e0: e59f2034 ldr r2, [pc, #52] ; 3b91c <msdos_date_dos2unix+0xec><== NOT EXECUTED
3b8e4: e5823010 str r3, [r2, #16] <== NOT EXECUTED
3b8e8: e59f302c ldr r3, [pc, #44] ; 3b91c <msdos_date_dos2unix+0xec><== NOT EXECUTED
3b8ec: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED
3b8f0: e201201f and r2, r1, #31 <== NOT EXECUTED
3b8f4: e2010b3e and r0, r1, #63488 ; 0xf800 <== NOT EXECUTED
3b8f8: e0822003 add r2, r2, r3 <== NOT EXECUTED
3b8fc: e1a005a0 lsr r0, r0, #11 <== NOT EXECUTED
3b900: e3a0cee1 mov ip, #3600 ; 0xe10 <== NOT EXECUTED
3b904: e023209c mla r3, ip, r0, r2 <== NOT EXECUTED
3b908: e2011e7e and r1, r1, #2016 ; 0x7e0 <== NOT EXECUTED
3b90c: e1a012a1 lsr r1, r1, #5 <== NOT EXECUTED
3b910: e3a0003c mov r0, #60 ; 0x3c <== NOT EXECUTED
}
return seconds + lastseconds;
}
3b914: e0203091 mla r0, r1, r0, r3 <== NOT EXECUTED
3b918: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
0003b6e8 <msdos_date_unix2dos>:
* 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)
{
3b6e8: e92d41f0 push {r4, r5, r6, r7, r8, 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) {
3b6ec: e59f411c ldr r4, [pc, #284] ; 3b810 <msdos_date_unix2dos+0x128><== NOT EXECUTED
3b6f0: e5943000 ldr r3, [r4] <== NOT EXECUTED
3b6f4: e1530000 cmp r3, 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)
{
3b6f8: e1a05000 mov r5, r0 <== NOT EXECUTED
3b6fc: e1a06001 mov r6, r1 <== NOT EXECUTED
3b700: e1a07002 mov r7, r2 <== 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) {
3b704: 0a00003b beq 3b7f8 <msdos_date_unix2dos+0x110> <== NOT EXECUTED
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
3b708: e3a0103c mov r1, #60 ; 0x3c <== 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;
3b70c: e5840000 str r0, [r4] <== NOT EXECUTED
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
3b710: eb0065b8 bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
3b714: e3a0103c mov r1, #60 ; 0x3c <== NOT EXECUTED
3b718: eb00664a bl 55048 <__umodsi3> <== NOT EXECUTED
3b71c: e3a01ee1 mov r1, #3600 ; 0xe10 <== NOT EXECUTED
3b720: e1a08280 lsl r8, r0, #5 <== NOT EXECUTED
3b724: e1a00005 mov r0, r5 <== NOT EXECUTED
3b728: eb0065b2 bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
3b72c: e3a01018 mov r1, #24 <== NOT EXECUTED
3b730: eb006644 bl 55048 <__umodsi3> <== NOT EXECUTED
3b734: e3a0103c mov r1, #60 ; 0x3c <== NOT EXECUTED
3b738: e0888580 add r8, r8, r0, lsl #11 <== NOT EXECUTED
3b73c: e1a00005 mov r0, r5 <== NOT EXECUTED
3b740: eb006640 bl 55048 <__umodsi3> <== NOT EXECUTED
3b744: e08880a0 add r8, r8, r0, 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);
3b748: e59f10c4 ldr r1, [pc, #196] ; 3b814 <msdos_date_unix2dos+0x12c><== NOT EXECUTED
3b74c: e1a00005 mov r0, 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)
3b750: e1c480b4 strh r8, [r4, #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);
3b754: eb0065a7 bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
if (days != lastday) {
3b758: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
3b75c: e1500003 cmp r0, r3 <== NOT EXECUTED
3b760: 0a000024 beq 3b7f8 <msdos_date_unix2dos+0x110> <== NOT EXECUTED
lastday = days;
3b764: e5840008 str r0, [r4, #8] <== NOT EXECUTED
3b768: e59f30a8 ldr r3, [pc, #168] ; 3b818 <msdos_date_unix2dos+0x130><== NOT EXECUTED
for (year = 1970;; year++) {
inc = year & 0x03 ? 365 : 366;
3b76c: e59f40a8 ldr r4, [pc, #168] ; 3b81c <msdos_date_unix2dos+0x134><== NOT EXECUTED
3b770: e59f10a8 ldr r1, [pc, #168] ; 3b820 <msdos_date_unix2dos+0x138><== NOT EXECUTED
3b774: e213c003 ands ip, r3, #3 <== NOT EXECUTED
3b778: 11a02004 movne r2, r4 <== NOT EXECUTED
3b77c: 01a02001 moveq r2, r1 <== NOT EXECUTED
if (days < inc)
3b780: e1500002 cmp r0, r2 <== NOT EXECUTED
break;
days -= inc;
3b784: 20620000 rsbcs r0, r2, r0 <== NOT EXECUTED
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
lastday = days;
for (year = 1970;; year++) {
3b788: 22833001 addcs r3, r3, #1 <== NOT EXECUTED
inc = year & 0x03 ? 365 : 366;
if (days < inc)
break;
days -= inc;
}
3b78c: 2afffff8 bcs 3b774 <msdos_date_unix2dos+0x8c> <== NOT EXECUTED
months = year & 0x03 ? regyear : leapyear;
3b790: e59f208c ldr r2, [pc, #140] ; 3b824 <msdos_date_unix2dos+0x13c><== NOT EXECUTED
3b794: e59f108c ldr r1, [pc, #140] ; 3b828 <msdos_date_unix2dos+0x140><== NOT EXECUTED
3b798: e35c0000 cmp ip, #0 <== NOT EXECUTED
3b79c: 01a0c002 moveq ip, r2 <== NOT EXECUTED
3b7a0: 11a0c001 movne ip, r1 <== NOT EXECUTED
3b7a4: e3a02000 mov r2, #0 <== NOT EXECUTED
for (month = 0; month < 12; month++) {
if (days < months[month])
3b7a8: e1a01082 lsl r1, r2, #1 <== NOT EXECUTED
3b7ac: e19c10b1 ldrh r1, [ip, r1] <== NOT EXECUTED
3b7b0: e1500001 cmp r0, r1 <== NOT EXECUTED
3b7b4: 3a000003 bcc 3b7c8 <msdos_date_unix2dos+0xe0> <== NOT EXECUTED
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
3b7b8: e2822001 add r2, r2, #1 <== NOT EXECUTED
3b7bc: e352000c cmp r2, #12 <== NOT EXECUTED
if (days < months[month])
break;
days -= months[month];
3b7c0: e0610000 rsb r0, r1, r0 <== NOT EXECUTED
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
3b7c4: 1afffff7 bne 3b7a8 <msdos_date_unix2dos+0xc0> <== NOT EXECUTED
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
3b7c8: e0802282 add r2, r0, r2, lsl #5 <== 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)
3b7cc: e59f0058 ldr r0, [pc, #88] ; 3b82c <msdos_date_unix2dos+0x144><== NOT EXECUTED
for (month = 0; month < 12; month++) {
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
3b7d0: e2822021 add r2, r2, #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)
3b7d4: e1530000 cmp r3, r0 <== NOT EXECUTED
lastddate += (year - 1980) <<
3b7d8: 82433e7b subhi r3, r3, #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)
3b7dc: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
3b7e0: e59f1028 ldr r1, [pc, #40] ; 3b810 <msdos_date_unix2dos+0x128><== NOT EXECUTED
3b7e4: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED
* unix's is relative to 1970. If somehow we get a
* time before 1980 then don't give totally crazy
* results.
*/
if (year > 1980)
lastddate += (year - 1980) <<
3b7e8: 8243300c subhi r3, r3, #12 <== NOT EXECUTED
3b7ec: 80823483 addhi r3, r2, r3, lsl #9 <== NOT EXECUTED
for (month = 0; month < 12; month++) {
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
3b7f0: e1c120bc strh r2, [r1, #12] <== NOT EXECUTED
* unix's is relative to 1970. If somehow we get a
* time before 1980 then don't give totally crazy
* results.
*/
if (year > 1980)
lastddate += (year - 1980) <<
3b7f4: 81c130bc strhhi r3, [r1, #12] <== NOT EXECUTED
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
3b7f8: e59f3010 ldr r3, [pc, #16] ; 3b810 <msdos_date_unix2dos+0x128><== NOT EXECUTED
3b7fc: e1d320b4 ldrh r2, [r3, #4] <== NOT EXECUTED
3b800: e1c720b0 strh r2, [r7] <== NOT EXECUTED
*ddp = lastddate;
3b804: e1d330bc ldrh r3, [r3, #12] <== NOT EXECUTED
3b808: e1c630b0 strh r3, [r6] <== NOT EXECUTED
}
3b80c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
0003ba94 <msdos_dir_chmod>:
int
msdos_dir_chmod(rtems_filesystem_location_info_t *pathloc,
mode_t mode)
{
return RC_OK;
}
3ba94: e3a00000 mov r0, #0 <== NOT EXECUTED
3ba98: e12fff1e bx lr <== NOT EXECUTED
0003c1b0 <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;
3c1b0: 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)
{
3c1b4: 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;
3c1b8: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
3c1bc: 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)
{
3c1c0: e1a05000 mov r5, 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,
3c1c4: e1a02001 mov r2, r1 <== NOT EXECUTED
3c1c8: e5940094 ldr r0, [r4, #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;
3c1cc: e5956038 ldr r6, [r5, #56] ; 0x38 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
3c1d0: ebff3dba bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
3c1d4: e3500000 cmp r0, #0 <== NOT EXECUTED
3c1d8: 0a000004 beq 3c1f0 <msdos_dir_close+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
3c1dc: eb000347 bl 3cf00 <__errno> <== NOT EXECUTED
3c1e0: e3a03005 mov r3, #5 <== NOT EXECUTED
3c1e4: e5803000 str r3, [r0] <== NOT EXECUTED
3c1e8: e3e05000 mvn r5, #0 <== NOT EXECUTED
3c1ec: ea000005 b 3c208 <msdos_dir_close+0x58> <== NOT EXECUTED
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
3c1f0: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
3c1f4: e1a01006 mov r1, r6 <== NOT EXECUTED
3c1f8: ebff982e bl 222b8 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
3c1fc: e2505000 subs r5, r0, #0 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rtems_semaphore_release(fs_info->vol_sema);
3c200: e5940094 ldr r0, [r4, #148] ; 0x94 <== NOT EXECUTED
3c204: ebff3df3 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
}
3c208: e1a00005 mov r0, r5 <== NOT EXECUTED
3c20c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00032818 <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
)
{
32818: e92d4ff3 push {r0, r1, 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;
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
3281c: e3a06000 mov r6, #0 <== NOT EXECUTED
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
32820: e1a0b000 mov fp, r0 <== NOT EXECUTED
32824: e1a05002 mov r5, r2 <== NOT EXECUTED
32828: e58d1004 str r1, [sp, #4] <== 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;
3282c: e5c26000 strb r6, [r2] <== NOT EXECUTED
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
32830: e5904034 ldr r4, [r0, #52] ; 0x34 <== 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,
32834: ea00002d b 328f0 <msdos_dir_is_empty+0xd8> <== NOT EXECUTED
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
32838: e350001f cmp r0, #31 <== NOT EXECUTED
3283c: d3e00000 mvnle r0, #0 <== NOT EXECUTED
32840: da000036 ble 32920 <msdos_dir_is_empty+0x108> <== NOT EXECUTED
return -1;
assert(ret == fs_info->fat.vol.bps);
32844: e1d490b0 ldrh r9, [r4] <== NOT EXECUTED
32848: e1500009 cmp r0, r9 <== NOT EXECUTED
3284c: 0a000023 beq 328e0 <msdos_dir_is_empty+0xc8> <== NOT EXECUTED
32850: e59f00cc ldr r0, [pc, #204] ; 32924 <msdos_dir_is_empty+0x10c><== NOT EXECUTED
32854: e59f10cc ldr r1, [pc, #204] ; 32928 <msdos_dir_is_empty+0x110><== NOT EXECUTED
32858: e59f20cc ldr r2, [pc, #204] ; 3292c <msdos_dir_is_empty+0x114><== NOT EXECUTED
3285c: e59f30cc ldr r3, [pc, #204] ; 32930 <msdos_dir_is_empty+0x118><== NOT EXECUTED
32860: ebffc8f3 bl 24c34 <__assert_func> <== NOT EXECUTED
/* 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)
{
char* entry = (char*) fs_info->cl_buf + i;
32864: e594a098 ldr sl, [r4, #152] ; 0x98 <== 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)) ==
32868: e7da8007 ldrb r8, [sl, r7] <== NOT EXECUTED
3286c: e35800e5 cmp r8, #229 ; 0xe5 <== NOT EXECUTED
/* 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)
{
char* entry = (char*) fs_info->cl_buf + i;
32870: e08aa007 add sl, sl, r7 <== 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)) ==
32874: 0a000011 beq 328c0 <msdos_dir_is_empty+0xa8> <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
32878: e5da300b ldrb r3, [sl, #11] <== NOT EXECUTED
3287c: e203303f and r3, r3, #63 ; 0x3f <== NOT EXECUTED
32880: e353000f cmp r3, #15 <== NOT EXECUTED
32884: 0a00000d beq 328c0 <msdos_dir_is_empty+0xa8> <== NOT EXECUTED
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
32888: e59f30a4 ldr r3, [pc, #164] ; 32934 <msdos_dir_is_empty+0x11c><== NOT EXECUTED
3288c: e1a0000a mov r0, sl <== NOT EXECUTED
32890: e5931000 ldr r1, [r3] <== NOT EXECUTED
32894: e3a0200b mov r2, #11 <== NOT EXECUTED
32898: eb0044df bl 43c1c <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)) ==
3289c: e3500000 cmp r0, #0 <== NOT EXECUTED
328a0: 0a000006 beq 328c0 <msdos_dir_is_empty+0xa8> <== 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)),
328a4: e59f3088 ldr r3, [pc, #136] ; 32934 <msdos_dir_is_empty+0x11c><== NOT EXECUTED
328a8: e1a0000a mov r0, sl <== NOT EXECUTED
328ac: e5931004 ldr r1, [r3, #4] <== NOT EXECUTED
328b0: e3a0200b mov r2, #11 <== NOT EXECUTED
328b4: eb0044d8 bl 43c1c <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)) ==
328b8: e3500000 cmp r0, #0 <== NOT EXECUTED
328bc: 1a000001 bne 328c8 <msdos_dir_is_empty+0xb0> <== 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)
328c0: e2877020 add r7, r7, #32 <== NOT EXECUTED
328c4: ea000006 b 328e4 <msdos_dir_is_empty+0xcc> <== NOT EXECUTED
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
328c8: e3580000 cmp r8, #0 <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
328cc: 03a03001 moveq r3, #1 <== NOT EXECUTED
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
328d0: 13a00000 movne r0, #0 <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
328d4: 05c53000 strbeq r3, [r5] <== NOT EXECUTED
328d8: 01a00008 moveq r0, r8 <== NOT EXECUTED
return RC_OK;
328dc: ea00000f b 32920 <msdos_dir_is_empty+0x108> <== NOT EXECUTED
328e0: e3a07000 mov r7, #0 <== 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;
328e4: e1570009 cmp r7, r9 <== NOT EXECUTED
328e8: 3affffdd bcc 32864 <msdos_dir_is_empty+0x4c> <== NOT EXECUTED
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
328ec: e2866001 add r6, r6, #1 <== 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,
328f0: e1d420b0 ldrh r2, [r4] <== NOT EXECUTED
328f4: e594c098 ldr ip, [r4, #152] ; 0x98 <== NOT EXECUTED
328f8: e1a03002 mov r3, r2 <== NOT EXECUTED
328fc: e1a0000b mov r0, fp <== NOT EXECUTED
32900: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
32904: e0020296 mul r2, r6, r2 <== NOT EXECUTED
32908: e58dc000 str ip, [sp] <== NOT EXECUTED
3290c: ebffbdef bl 220d0 <fat_file_read> <== NOT EXECUTED
32910: e3500000 cmp r0, #0 <== NOT EXECUTED
32914: 1affffc7 bne 32838 <msdos_dir_is_empty+0x20> <== NOT EXECUTED
*/
return RC_OK;
}
j++;
}
*ret_val = true;
32918: e3a03001 mov r3, #1 <== NOT EXECUTED
3291c: e5c53000 strb r3, [r5] <== NOT EXECUTED
return RC_OK;
}
32920: e8bd8ffc pop {r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0003ba9c <msdos_dir_lseek>:
* set apropriately).
*/
rtems_off64_t
msdos_dir_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
switch (whence)
3ba9c: 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)
{
3baa0: e92d4010 push {r4, lr} <== NOT EXECUTED
switch (whence)
3baa4: 93a03000 movls r3, #0 <== NOT EXECUTED
3baa8: 93a04000 movls r4, #0 <== NOT EXECUTED
3baac: 9a000004 bls 3bac4 <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 );
3bab0: eb000512 bl 3cf00 <__errno> <== NOT EXECUTED
3bab4: e3a03016 mov r3, #22 <== NOT EXECUTED
3bab8: e5803000 str r3, [r0] <== NOT EXECUTED
3babc: e3e04000 mvn r4, #0 <== NOT EXECUTED
3bac0: e3e03000 mvn r3, #0 <== NOT EXECUTED
break;
}
return RC_OK;
}
3bac4: e1a01004 mov r1, r4 <== NOT EXECUTED
3bac8: e1a00003 mov r0, r3 <== NOT EXECUTED
3bacc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0003c210 <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;
3c210: 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)
{
3c214: 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;
3c218: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
3c21c: 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)
{
3c220: e1a05000 mov r5, 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,
3c224: e1a02001 mov r2, r1 <== NOT EXECUTED
3c228: e5940094 ldr r0, [r4, #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;
3c22c: e5956038 ldr r6, [r5, #56] ; 0x38 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
3c230: ebff3da2 bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
3c234: e3500000 cmp r0, #0 <== NOT EXECUTED
3c238: 0a000004 beq 3c250 <msdos_dir_open+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
3c23c: eb00032f bl 3cf00 <__errno> <== NOT EXECUTED
3c240: e3a03005 mov r3, #5 <== NOT EXECUTED
3c244: e5803000 str r3, [r0] <== NOT EXECUTED
3c248: e3e06000 mvn r6, #0 <== NOT EXECUTED
3c24c: ea000008 b 3c274 <msdos_dir_open+0x64> <== NOT EXECUTED
rc = fat_file_reopen(fat_fd);
3c250: e1a00006 mov r0, r6 <== NOT EXECUTED
3c254: ebff958a bl 21884 <fat_file_reopen> <== NOT EXECUTED
if (rc != RC_OK)
3c258: e2506000 subs r6, r0, #0 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
iop->offset = 0;
3c25c: 03a02000 moveq r2, #0 <== NOT EXECUTED
3c260: 03a03000 moveq r3, #0 <== NOT EXECUTED
3c264: 0585200c streq r2, [r5, #12] <== NOT EXECUTED
3c268: 05853010 streq r3, [r5, #16] <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
3c26c: e5940094 ldr r0, [r4, #148] ; 0x94 <== NOT EXECUTED
3c270: ebff3dd8 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
}
3c274: e1a00006 mov r0, r6 <== NOT EXECUTED
3c278: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
0003bcb8 <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)
{
3bcb8: 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;
3bcbc: e590a038 ldr sl, [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)
{
3bcc0: e1a07000 mov r7, r0 <== 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) &&
3bcc4: e59a0020 ldr r0, [sl, #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;
3bcc8: e5973028 ldr r3, [r7, #40] ; 0x28 <== 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)
{
3bccc: e24dde15 sub sp, sp, #336 ; 0x150 <== 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) &&
3bcd0: 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)
{
3bcd4: e58d1024 str r1, [sp, #36] ; 0x24 <== NOT EXECUTED
3bcd8: 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;
3bcdc: e5935034 ldr r5, [r3, #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);
3bce0: e287900c add r9, r7, #12 <== NOT EXECUTED
3bce4: e8990300 ldm r9, {r8, r9} <== 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) &&
3bce8: 1a000007 bne 3bd0c <msdos_dir_read+0x54> <== NOT EXECUTED
3bcec: e59a3024 ldr r3, [sl, #36] ; 0x24 <== NOT EXECUTED
3bcf0: e3530000 cmp r3, #0 <== NOT EXECUTED
3bcf4: 1a000004 bne 3bd0c <msdos_dir_read+0x54> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
3bcf8: e5d5300a ldrb r3, [r5, #10] <== NOT EXECUTED
3bcfc: e3130003 tst r3, #3 <== 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) &&
3bd00: 159a0018 ldrne r0, [sl, #24] <== NOT EXECUTED
3bd04: 158d001c strne r0, [sp, #28] <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
3bd08: 1a000001 bne 3bd14 <msdos_dir_read+0x5c> <== 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) &&
3bd0c: e1d510b6 ldrh r1, [r5, #6] <== NOT EXECUTED
3bd10: e58d101c str r1, [sp, #28] <== 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;
3bd14: 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,
3bd18: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
3bd1c: e1a01003 mov r1, r3 <== NOT EXECUTED
3bd20: 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;
3bd24: e58d3148 str r3, [sp, #328] ; 0x148 <== 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;
3bd28: e58d314c str r3, [sp, #332] ; 0x14c <== 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,
3bd2c: ebff3ee3 bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
3bd30: e2506000 subs r6, r0, #0 <== NOT EXECUTED
3bd34: 1a000020 bne 3bdbc <msdos_dir_read+0x104> <== 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);
3bd38: e3a02e11 mov r2, #272 ; 0x110 <== NOT EXECUTED
3bd3c: e3a03000 mov r3, #0 <== NOT EXECUTED
3bd40: e1a00008 mov r0, r8 <== NOT EXECUTED
3bd44: e1a01009 mov r1, r9 <== NOT EXECUTED
3bd48: eb0065d8 bl 554b0 <__divdi3> <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
3bd4c: e3a01e11 mov r1, #272 ; 0x110 <== 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);
3bd50: e1a09000 mov r9, r0 <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
3bd54: e1a00004 mov r0, r4 <== NOT EXECUTED
3bd58: eb006426 bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
3bd5c: e3a03e11 mov r3, #272 ; 0x110 <== NOT EXECUTED
3bd60: e0000093 mul r0, r3, r0 <== NOT EXECUTED
3bd64: e3e02000 mvn r2, #0 <== NOT EXECUTED
3bd68: e58d0014 str r0, [sp, #20] <== NOT EXECUTED
3bd6c: e58d6010 str r6, [sp, #16] <== NOT EXECUTED
3bd70: e1a0b006 mov fp, r6 <== NOT EXECUTED
3bd74: e58d6018 str r6, [sp, #24] <== NOT EXECUTED
3bd78: e58d200c str r2, [sp, #12] <== NOT EXECUTED
3bd7c: e1a08005 mov r8, r5 <== NOT EXECUTED
3bd80: ea0000f3 b 3c154 <msdos_dir_read+0x49c> <== 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),
3bd84: e598c098 ldr ip, [r8, #152] ; 0x98 <== NOT EXECUTED
3bd88: e5970028 ldr r0, [r7, #40] ; 0x28 <== NOT EXECUTED
3bd8c: e1a0100a mov r1, sl <== NOT EXECUTED
3bd90: e1a02006 mov r2, r6 <== NOT EXECUTED
3bd94: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED
3bd98: e58dc000 str ip, [sp] <== NOT EXECUTED
3bd9c: ebff98cb bl 220d0 <fat_file_read> <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
3bda0: 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),
3bda4: e58d0020 str r0, [sp, #32] <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
3bda8: c3a05000 movgt r5, #0 <== NOT EXECUTED
3bdac: ca0000e3 bgt 3c140 <msdos_dir_read+0x488> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
3bdb0: e5980094 ldr r0, [r8, #148] ; 0x94 <== NOT EXECUTED
3bdb4: e1a05008 mov r5, r8 <== NOT EXECUTED
3bdb8: ebff3f06 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
3bdbc: eb00044f bl 3cf00 <__errno> <== NOT EXECUTED
3bdc0: e3a03005 mov r3, #5 <== NOT EXECUTED
3bdc4: e5803000 str r3, [r0] <== NOT EXECUTED
3bdc8: e3e03000 mvn r3, #0 <== NOT EXECUTED
3bdcc: ea0000e7 b 3c170 <msdos_dir_read+0x4b8> <== NOT EXECUTED
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
3bdd0: e5984098 ldr r4, [r8, #152] ; 0x98 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
3bdd4: e7d43005 ldrb r3, [r4, r5] <== NOT EXECUTED
3bdd8: 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;
3bddc: e0844005 add r4, r4, r5 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
3bde0: 01a05008 moveq r5, r8 <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
rtems_semaphore_release(fs_info->vol_sema);
3bde4: 05980094 ldreq r0, [r8, #148] ; 0x94 <== NOT EXECUTED
return cmpltd;
3bde8: 059d3010 ldreq r3, [sp, #16] <== NOT EXECUTED
3bdec: 0a0000c4 beq 3c104 <msdos_dir_read+0x44c> <== NOT EXECUTED
}
/* Is the directory entry empty */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
3bdf0: e35300e5 cmp r3, #229 ; 0xe5 <== NOT EXECUTED
3bdf4: 0a0000d0 beq 3c13c <msdos_dir_read+0x484> <== NOT EXECUTED
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
3bdf8: e5d4200b ldrb r2, [r4, #11] <== NOT EXECUTED
3bdfc: e3120008 tst r2, #8 <== NOT EXECUTED
3be00: 0a000002 beq 3be10 <msdos_dir_read+0x158> <== NOT EXECUTED
3be04: e202103f and r1, r2, #63 ; 0x3f <== NOT EXECUTED
3be08: e351000f cmp r1, #15 <== NOT EXECUTED
3be0c: 1a0000ca bne 3c13c <msdos_dir_read+0x484> <== 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) ==
3be10: e202203f and r2, r2, #63 ; 0x3f <== NOT EXECUTED
3be14: e352000f cmp r2, #15 <== NOT EXECUTED
3be18: 1a000031 bne 3bee4 <msdos_dir_read+0x22c> <== NOT EXECUTED
int q;
/*
* Is this is the first entry of a LFN ?
*/
if (lfn_start == FAT_FILE_SHORT_NAME)
3be1c: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED
3be20: e37c0001 cmn ip, #1 <== NOT EXECUTED
3be24: 1a00000b bne 3be58 <msdos_dir_read+0x1a0> <== NOT EXECUTED
{
/*
* The first entry must have the last long entry flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
3be28: e3130040 tst r3, #64 ; 0x40 <== NOT EXECUTED
3be2c: 0a0000c2 beq 3c13c <msdos_dir_read+0x484> <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
3be30: e085c006 add ip, r5, r6 <== NOT EXECUTED
3be34: e1a0c2ac lsr ip, ip, #5 <== NOT EXECUTED
3be38: e58dc00c str ip, [sp, #12] <== 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);
3be3c: e5d4e00d ldrb lr, [r4, #13] <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
3be40: e28d0038 add r0, sp, #56 ; 0x38 <== NOT EXECUTED
3be44: e3a01000 mov r1, #0 <== NOT EXECUTED
3be48: e28220f1 add r2, r2, #241 ; 0xf1 <== 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) &
3be4c: e203b03f and fp, r3, #63 ; 0x3f <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
3be50: e58de018 str lr, [sp, #24] <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
3be54: eb001160 bl 403dc <memset> <== 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) &
3be58: e5d43000 ldrb r3, [r4] <== NOT EXECUTED
3be5c: e203303f and r3, r3, #63 ; 0x3f <== NOT EXECUTED
3be60: e15b0003 cmp fp, r3 <== NOT EXECUTED
3be64: 1a0000b2 bne 3c134 <msdos_dir_read+0x47c> <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
3be68: e5d4300d ldrb r3, [r4, #13] <== NOT EXECUTED
3be6c: e59d0018 ldr r0, [sp, #24] <== NOT EXECUTED
3be70: e1530000 cmp r3, r0 <== NOT EXECUTED
3be74: 1a0000ae bne 3c134 <msdos_dir_read+0x47c> <== NOT EXECUTED
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
3be78: e3a0300d mov r3, #13 <== 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--;
3be7c: e24bb001 sub fp, fp, #1 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
3be80: e0020b93 mul r2, r3, fp <== NOT EXECUTED
3be84: e28d3e15 add r3, sp, #336 ; 0x150 <== NOT EXECUTED
3be88: e0831002 add r1, r3, r2 <== 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;
3be8c: e2844001 add r4, r4, #1 <== NOT EXECUTED
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
3be90: e2411f46 sub r1, r1, #280 ; 0x118 <== NOT EXECUTED
3be94: e3a03000 mov r3, #0 <== NOT EXECUTED
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
3be98: e35200fe cmp r2, #254 ; 0xfe <== NOT EXECUTED
3be9c: 8a0000a6 bhi 3c13c <msdos_dir_read+0x484> <== NOT EXECUTED
break;
tmp_dirent.d_name[o++] = *p;
3bea0: e5d40000 ldrb r0, [r4] <== NOT EXECUTED
3bea4: e5c10000 strb r0, [r1] <== NOT EXECUTED
if (*p == '\0')
3bea8: e5d40000 ldrb r0, [r4] <== NOT EXECUTED
3beac: e3500000 cmp r0, #0 <== NOT EXECUTED
3beb0: 0a0000a1 beq 3c13c <msdos_dir_read+0x484> <== NOT EXECUTED
break;
switch (q)
3beb4: e3530004 cmp r3, #4 <== NOT EXECUTED
{
case 4:
p += 5;
3beb8: 02844005 addeq r4, r4, #5 <== NOT EXECUTED
tmp_dirent.d_name[o++] = *p;
if (*p == '\0')
break;
switch (q)
3bebc: 0a000002 beq 3becc <msdos_dir_read+0x214> <== NOT EXECUTED
3bec0: e353000a cmp r3, #10 <== NOT EXECUTED
break;
case 10:
p += 4;
break;
default:
p += 2;
3bec4: 12844002 addne r4, r4, #2 <== NOT EXECUTED
{
case 4:
p += 5;
break;
case 10:
p += 4;
3bec8: 02844004 addeq r4, r4, #4 <== 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++)
3becc: e2833001 add r3, r3, #1 <== NOT EXECUTED
3bed0: e353000d cmp r3, #13 <== NOT EXECUTED
3bed4: e2811001 add r1, r1, #1 <== NOT EXECUTED
3bed8: 0a000097 beq 3c13c <msdos_dir_read+0x484> <== NOT EXECUTED
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
break;
tmp_dirent.d_name[o++] = *p;
3bedc: e2822001 add r2, r2, #1 <== NOT EXECUTED
3bee0: eaffffec b 3be98 <msdos_dir_read+0x1e0> <== NOT EXECUTED
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
3bee4: e3590000 cmp r9, #0 <== NOT EXECUTED
{
lfn_start = FAT_FILE_SHORT_NAME;
start--;
3bee8: 13e0c000 mvnne ip, #0 <== NOT EXECUTED
3beec: 12499001 subne r9, r9, #1 <== NOT EXECUTED
3bef0: 158dc00c strne ip, [sp, #12] <== NOT EXECUTED
continue;
3bef4: 1a000090 bne 3c13c <msdos_dir_read+0x484> <== 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,
3bef8: e5970028 ldr r0, [r7, #40] ; 0x28 <== NOT EXECUTED
3befc: e1a03006 mov r3, r6 <== NOT EXECUTED
3bf00: e28def52 add lr, sp, #328 ; 0x148 <== NOT EXECUTED
3bf04: e1a0100a mov r1, sl <== NOT EXECUTED
3bf08: e3a02001 mov r2, #1 <== NOT EXECUTED
3bf0c: e58de000 str lr, [sp] <== NOT EXECUTED
3bf10: ebff9701 bl 21b1c <fat_file_ioctl> <== NOT EXECUTED
j * bts2rd, &cur_cln);
if (rc != RC_OK)
3bf14: e2503000 subs r3, r0, #0 <== NOT EXECUTED
3bf18: 1a000077 bne 3c0fc <msdos_dir_read+0x444> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
3bf1c: e59d3148 ldr r3, [sp, #328] ; 0x148 <== NOT EXECUTED
dir_pos.sname.ofs = i;
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
3bf20: e5970028 ldr r0, [r7, #40] ; 0x28 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
3bf24: e58d3138 str r3, [sp, #312] ; 0x138 <== NOT EXECUTED
dir_pos.sname.ofs = i;
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
3bf28: e28d1f4e add r1, sp, #312 ; 0x138 <== 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;
3bf2c: e3e03000 mvn r3, #0 <== NOT EXECUTED
3bf30: e28d2f53 add r2, sp, #332 ; 0x14c <== NOT EXECUTED
3bf34: e58d3140 str r3, [sp, #320] ; 0x140 <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
3bf38: e58d3144 str r3, [sp, #324] ; 0x144 <== NOT EXECUTED
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
dir_pos.sname.ofs = i;
3bf3c: e58d513c str r5, [sp, #316] ; 0x13c <== NOT EXECUTED
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
3bf40: ebff9905 bl 2235c <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
3bf44: e2503000 subs r3, r0, #0 <== NOT EXECUTED
3bf48: 1a00006b bne 3c0fc <msdos_dir_read+0x444> <== 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;
3bf4c: e59d314c ldr r3, [sp, #332] ; 0x14c <== 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)
3bf50: e59dc00c ldr ip, [sp, #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);
tmp_dirent.d_ino = tmp_fat_fd->ino;
3bf54: 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);
3bf58: e59f2248 ldr r2, [pc, #584] ; 3c1a8 <msdos_dir_read+0x4f0> <== 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;
3bf5c: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
3bf60: e3a0ee11 mov lr, #272 ; 0x110 <== NOT EXECUTED
3bf64: e28d0e15 add r0, sp, #336 ; 0x150 <== 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)
3bf68: e37c0001 cmn ip, #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);
3bf6c: e180e0b2 strh lr, [r0, r2] <== NOT EXECUTED
tmp_dirent.d_ino = tmp_fat_fd->ino;
3bf70: e58d3028 str r3, [sp, #40] ; 0x28 <== 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;
3bf74: e58d102c str r1, [sp, #44] ; 0x2c <== NOT EXECUTED
3bf78: e58d9030 str r9, [sp, #48] ; 0x30 <== 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)
3bf7c: 0a000016 beq 3bfdc <msdos_dir_read+0x324> <== NOT EXECUTED
3bf80: e1a02009 mov r2, r9 <== NOT EXECUTED
3bf84: e1a03009 mov r3, r9 <== 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;
3bf88: e7d40002 ldrb r0, [r4, r2] <== NOT EXECUTED
3bf8c: e2131001 ands r1, r3, #1 <== NOT EXECUTED
3bf90: 13a01080 movne r1, #128 ; 0x80 <== NOT EXECUTED
3bf94: e08030a3 add r3, r0, r3, lsr #1 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
3bf98: e2822001 add r2, r2, #1 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
3bf9c: e0833001 add r3, r3, r1 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
3bfa0: e352000b cmp r2, #11 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
3bfa4: e20330ff and r3, r3, #255 ; 0xff <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
3bfa8: 1afffff6 bne 3bf88 <msdos_dir_read+0x2d0> <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
3bfac: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED
3bfb0: e35b0000 cmp fp, #0 <== NOT EXECUTED
3bfb4: 01520003 cmpeq r2, r3 <== NOT EXECUTED
3bfb8: 1a000007 bne 3bfdc <msdos_dir_read+0x324> <== NOT EXECUTED
3bfbc: ea00006e b 3c17c <msdos_dir_read+0x4c4> <== NOT EXECUTED
3bfc0: e1a01003 mov r1, r3 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
3bfc4: e2533001 subs r3, r3, #1 <== NOT EXECUTED
3bfc8: 2a000004 bcs 3bfe0 <msdos_dir_read+0x328> <== NOT EXECUTED
3bfcc: e3a00000 mov r0, #0 <== NOT EXECUTED
3bfd0: e28d3038 add r3, sp, #56 ; 0x38 <== NOT EXECUTED
3bfd4: e58d100c str r1, [sp, #12] <== NOT EXECUTED
3bfd8: ea000010 b 3c020 <msdos_dir_read+0x368> <== NOT EXECUTED
3bfdc: e3a03007 mov r3, #7 <== NOT EXECUTED
3bfe0: e7d42003 ldrb r2, [r4, r3] <== NOT EXECUTED
3bfe4: e3520020 cmp r2, #32 <== NOT EXECUTED
3bfe8: e2831001 add r1, r3, #1 <== NOT EXECUTED
3bfec: 0afffff3 beq 3bfc0 <msdos_dir_read+0x308> <== NOT EXECUTED
3bff0: eafffff5 b 3bfcc <msdos_dir_read+0x314> <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
3bff4: e59fe1b0 ldr lr, [pc, #432] ; 3c1ac <msdos_dir_read+0x4f4> <== NOT EXECUTED
3bff8: e59ee000 ldr lr, [lr] <== NOT EXECUTED
3bffc: e7d4c000 ldrb ip, [r4, r0] <== NOT EXECUTED
3c000: e58de004 str lr, [sp, #4] <== NOT EXECUTED
3c004: e08ee00c add lr, lr, ip <== NOT EXECUTED
3c008: e5dee001 ldrb lr, [lr, #1] <== NOT EXECUTED
3c00c: e20ee003 and lr, lr, #3 <== NOT EXECUTED
3c010: e35e0001 cmp lr, #1 <== NOT EXECUTED
3c014: 028cc020 addeq ip, ip, #32 <== NOT EXECUTED
3c018: e4c3c001 strb ip, [r3], #1 <== NOT EXECUTED
3c01c: e2800001 add r0, r0, #1 <== 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)
3c020: e060c001 rsb ip, r0, r1 <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
3c024: e35c0000 cmp ip, #0 <== NOT EXECUTED
3c028: cafffff1 bgt 3bff4 <msdos_dir_read+0x33c> <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
}
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
3c02c: e5d4000a ldrb r0, [r4, #10] <== NOT EXECUTED
3c030: e3500020 cmp r0, #32 <== NOT EXECUTED
3c034: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
3c038: 13a00003 movne r0, #3 <== NOT EXECUTED
3c03c: 1a000053 bne 3c190 <msdos_dir_read+0x4d8> <== NOT EXECUTED
3c040: e5d40009 ldrb r0, [r4, #9] <== NOT EXECUTED
3c044: e3500020 cmp r0, #32 <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
(*src_tmp == ' '));
i--,src_tmp--)
3c048: e2840009 add r0, r4, #9 <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
}
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
3c04c: 13a00002 movne r0, #2 <== NOT EXECUTED
3c050: 1a00004e bne 3c190 <msdos_dir_read+0x4d8> <== NOT EXECUTED
3c054: e5500001 ldrb r0, [r0, #-1] <== NOT EXECUTED
3c058: e3500020 cmp r0, #32 <== NOT EXECUTED
3c05c: 0a00000e beq 3c09c <msdos_dir_read+0x3e4> <== NOT EXECUTED
3c060: ea000049 b 3c18c <msdos_dir_read+0x4d4> <== 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++));
3c064: e59fe140 ldr lr, [pc, #320] ; 3c1ac <msdos_dir_read+0x4f4> <== NOT EXECUTED
3c068: e5d40008 ldrb r0, [r4, #8] <== NOT EXECUTED
3c06c: e59ec000 ldr ip, [lr] <== NOT EXECUTED
3c070: e08cc000 add ip, ip, r0 <== NOT EXECUTED
3c074: e5dcc001 ldrb ip, [ip, #1] <== NOT EXECUTED
3c078: e20cc003 and ip, ip, #3 <== NOT EXECUTED
3c07c: e35c0001 cmp ip, #1 <== NOT EXECUTED
3c080: 02800020 addeq r0, r0, #32 <== NOT EXECUTED
3c084: e4c30001 strb r0, [r3], #1 <== NOT EXECUTED
len++;
3c088: e2822001 add r2, r2, #1 <== NOT EXECUTED
3c08c: e2411001 sub r1, r1, #1 <== NOT EXECUTED
3c090: e2844001 add r4, r4, #1 <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
3c094: e3510000 cmp r1, #0 <== NOT EXECUTED
3c098: cafffff1 bgt 3c064 <msdos_dir_read+0x3ac> <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
3c09c: e3a00000 mov r0, #0 <== 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(
3c0a0: e3e01000 mvn r1, #0 <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
3c0a4: e5c30000 strb r0, [r3] <== 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(
3c0a8: e1cd23b6 strh r2, [sp, #54] ; 0x36 <== NOT EXECUTED
3c0ac: e58d100c str r1, [sp, #12] <== NOT EXECUTED
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
3c0b0: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
3c0b4: e59dc010 ldr ip, [sp, #16] <== NOT EXECUTED
3c0b8: e28d1028 add r1, sp, #40 ; 0x28 <== NOT EXECUTED
3c0bc: e083000c add r0, r3, ip <== NOT EXECUTED
3c0c0: e3a02e11 mov r2, #272 ; 0x110 <== NOT EXECUTED
3c0c4: eb00103d bl 401c0 <memcpy> <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
3c0c8: e287400c add r4, r7, #12 <== NOT EXECUTED
3c0cc: e8940018 ldm r4, {r3, r4} <== NOT EXECUTED
3c0d0: e3a01e11 mov r1, #272 ; 0x110 <== NOT EXECUTED
3c0d4: e0933001 adds r3, r3, r1 <== NOT EXECUTED
3c0d8: e3a02000 mov r2, #0 <== NOT EXECUTED
3c0dc: e0a44002 adc r4, r4, r2 <== NOT EXECUTED
3c0e0: e587300c str r3, [r7, #12] <== NOT EXECUTED
3c0e4: e5874010 str r4, [r7, #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);
3c0e8: e5970028 ldr r0, [r7, #40] ; 0x28 <== NOT EXECUTED
3c0ec: e59d114c ldr r1, [sp, #332] ; 0x14c <== NOT EXECUTED
3c0f0: ebff9870 bl 222b8 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
3c0f4: e2503000 subs r3, r0, #0 <== NOT EXECUTED
3c0f8: 0a000005 beq 3c114 <msdos_dir_read+0x45c> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
3c0fc: e5980094 ldr r0, [r8, #148] ; 0x94 <== NOT EXECUTED
3c100: e1a05008 mov r5, r8 <== NOT EXECUTED
3c104: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
3c108: ebff3e32 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
3c10c: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
3c110: ea000016 b 3c170 <msdos_dir_read+0x4b8> <== NOT EXECUTED
}
}
if (count <= 0)
3c114: e28d0010 add r0, sp, #16 <== NOT EXECUTED
3c118: e8904001 ldm r0, {r0, lr} <== NOT EXECUTED
3c11c: e25eee11 subs lr, lr, #272 ; 0x110 <== NOT EXECUTED
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
cmpltd += (sizeof(struct dirent));
3c120: e2800e11 add r0, r0, #272 ; 0x110 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
3c124: e58de014 str lr, [sp, #20] <== NOT EXECUTED
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
cmpltd += (sizeof(struct dirent));
3c128: e58d0010 str r0, [sp, #16] <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
3c12c: 1a000002 bne 3c13c <msdos_dir_read+0x484> <== NOT EXECUTED
3c130: ea000005 b 3c14c <msdos_dir_read+0x494> <== NOT EXECUTED
3c134: e3e01000 mvn r1, #0 <== NOT EXECUTED
3c138: e58d100c str 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)
3c13c: e2855020 add r5, r5, #32 <== NOT EXECUTED
3c140: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED
3c144: e1550002 cmp r5, r2 <== NOT EXECUTED
3c148: 3affff20 bcc 3bdd0 <msdos_dir_read+0x118> <== NOT EXECUTED
3c14c: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED
3c150: e0866003 add r6, r6, r3 <== 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)
3c154: e59dc014 ldr ip, [sp, #20] <== NOT EXECUTED
3c158: e35c0000 cmp ip, #0 <== NOT EXECUTED
3c15c: 1affff08 bne 3bd84 <msdos_dir_read+0xcc> <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
3c160: e5980094 ldr r0, [r8, #148] ; 0x94 <== NOT EXECUTED
3c164: ebff3e1b bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return cmpltd;
3c168: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
3c16c: e1a05008 mov r5, r8 <== NOT EXECUTED
}
3c170: e1a00003 mov r0, r3 <== NOT EXECUTED
3c174: e28dde15 add sp, sp, #336 ; 0x150 <== NOT EXECUTED
3c178: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== 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);
3c17c: e28d0038 add r0, sp, #56 ; 0x38 <== NOT EXECUTED
3c180: eb001e5b bl 43af4 <strlen> <== NOT EXECUTED
3c184: e1cd03b6 strh r0, [sp, #54] ; 0x36 <== NOT EXECUTED
3c188: eaffffc8 b 3c0b0 <msdos_dir_read+0x3f8> <== NOT EXECUTED
3c18c: e3a00001 mov r0, #1 <== NOT EXECUTED
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
3c190: e2812001 add r2, r1, #1 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
3c194: e3a0102e mov r1, #46 ; 0x2e <== NOT EXECUTED
3c198: e4c31001 strb r1, [r3], #1 <== NOT EXECUTED
len += i + 1; /* extension + dot */
3c19c: e0822000 add r2, r2, r0 <== NOT EXECUTED
3c1a0: e1a01000 mov r1, r0 <== NOT EXECUTED
3c1a4: eaffffba b 3c094 <msdos_dir_read+0x3dc> <== NOT EXECUTED
0003bb78 <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)
{
3bb78: e92d40f1 push {r0, 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;
3bb7c: e5913010 ldr r3, [r1, #16] <== NOT EXECUTED
3bb80: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
fat_file_fd_t *fat_fd = pathloc->node_access;
bool is_empty = false;
3bb84: 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)
{
3bb88: e1a05001 mov r5, 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,
3bb8c: e5940094 ldr r0, [r4, #148] ; 0x94 <== NOT EXECUTED
3bb90: e1a01003 mov r1, r3 <== NOT EXECUTED
3bb94: 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;
3bb98: 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;
3bb9c: e5956000 ldr r6, [r5] <== NOT EXECUTED
bool is_empty = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
3bba0: ebff3f46 bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
3bba4: e3500000 cmp r0, #0 <== NOT EXECUTED
3bba8: 0a000002 beq 3bbb8 <msdos_dir_rmnod+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
3bbac: eb0004d3 bl 3cf00 <__errno> <== NOT EXECUTED
3bbb0: e3a03005 mov r3, #5 <== NOT EXECUTED
3bbb4: ea000006 b 3bbd4 <msdos_dir_rmnod+0x5c> <== 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)
3bbb8: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED
3bbbc: e3530001 cmp r3, #1 <== NOT EXECUTED
3bbc0: 9a000006 bls 3bbe0 <msdos_dir_rmnod+0x68> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
3bbc4: e5940094 ldr r0, [r4, #148] ; 0x94 <== NOT EXECUTED
3bbc8: ebff3f82 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EBUSY);
3bbcc: eb0004cb bl 3cf00 <__errno> <== NOT EXECUTED
3bbd0: e3a03010 mov r3, #16 <== NOT EXECUTED
3bbd4: e5803000 str r3, [r0] <== NOT EXECUTED
3bbd8: e3e07000 mvn r7, #0 <== NOT EXECUTED
3bbdc: ea00001b b 3bc50 <msdos_dir_rmnod+0xd8> <== NOT EXECUTED
}
/*
* You cannot remove a node that still has children
*/
rc = msdos_dir_is_empty(pathloc->mt_entry, fat_fd, &is_empty);
3bbe0: e5950010 ldr r0, [r5, #16] <== NOT EXECUTED
3bbe4: e1a01006 mov r1, r6 <== NOT EXECUTED
3bbe8: e28d2003 add r2, sp, #3 <== NOT EXECUTED
3bbec: ebffdb09 bl 32818 <msdos_dir_is_empty> <== NOT EXECUTED
if (rc != RC_OK)
3bbf0: e2507000 subs r7, r0, #0 <== NOT EXECUTED
3bbf4: 1a000013 bne 3bc48 <msdos_dir_rmnod+0xd0> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (!is_empty)
3bbf8: e5dd3003 ldrb r3, [sp, #3] <== NOT EXECUTED
3bbfc: e3530000 cmp r3, #0 <== NOT EXECUTED
3bc00: 1a000004 bne 3bc18 <msdos_dir_rmnod+0xa0> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
3bc04: e5940094 ldr r0, [r4, #148] ; 0x94 <== NOT EXECUTED
3bc08: ebff3f72 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
3bc0c: eb0004bb bl 3cf00 <__errno> <== NOT EXECUTED
3bc10: e3a0305a mov r3, #90 ; 0x5a <== NOT EXECUTED
3bc14: eaffffee b 3bbd4 <msdos_dir_rmnod+0x5c> <== NOT EXECUTED
}
/*
* You cannot remove the file system root node.
*/
if (pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access)
3bc18: e5950010 ldr r0, [r5, #16] <== NOT EXECUTED
3bc1c: e5953000 ldr r3, [r5] <== NOT EXECUTED
3bc20: e590201c ldr r2, [r0, #28] <== NOT EXECUTED
3bc24: e1520003 cmp r2, r3 <== NOT EXECUTED
3bc28: 0affffe5 beq 3bbc4 <msdos_dir_rmnod+0x4c> <== 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,
3bc2c: e2861020 add r1, r6, #32 <== NOT EXECUTED
3bc30: e3a020e5 mov r2, #229 ; 0xe5 <== NOT EXECUTED
3bc34: ebffdb8a bl 32a64 <msdos_set_first_char4file_name> <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
3bc38: 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);
3bc3c: 05950010 ldreq r0, [r5, #16] <== NOT EXECUTED
3bc40: 01a01006 moveq r1, r6 <== NOT EXECUTED
3bc44: 0bff97a1 bleq 21ad0 <fat_file_mark_removed> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
3bc48: e5940094 ldr r0, [r4, #148] ; 0x94 <== NOT EXECUTED
3bc4c: ebff3f61 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
3bc50: e1a00007 mov r0, r7 <== NOT EXECUTED
3bc54: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
0003bad0 <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;
3bad0: e5902010 ldr r2, [r0, #16] <== NOT EXECUTED
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
3bad4: 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;
3bad8: e5925034 ldr r5, [r2, #52] ; 0x34 <== NOT EXECUTED
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
3badc: 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,
3bae0: e3a01000 mov r1, #0 <== NOT EXECUTED
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
3bae4: 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,
3bae8: e1a02001 mov r2, r1 <== NOT EXECUTED
3baec: 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;
3baf0: e5936000 ldr r6, [r3] <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
3baf4: ebff3f71 bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
3baf8: e2507000 subs r7, r0, #0 <== NOT EXECUTED
3bafc: 0a000004 beq 3bb14 <msdos_dir_stat+0x44> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
3bb00: eb0004fe bl 3cf00 <__errno> <== NOT EXECUTED
3bb04: e3a03005 mov r3, #5 <== NOT EXECUTED
3bb08: e5803000 str r3, [r0] <== NOT EXECUTED
3bb0c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3bb10: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
3bb14: e596300c ldr r3, [r6, #12] <== NOT EXECUTED
3bb18: e5843008 str r3, [r4, #8] <== NOT EXECUTED
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
3bb1c: e59f3050 ldr r3, [pc, #80] ; 3bb74 <msdos_dir_stat+0xa4> <== NOT EXECUTED
3bb20: e584300c str r3, [r4, #12] <== NOT EXECUTED
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
3bb24: 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;
3bb28: 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;
3bb2c: e1a014a3 lsr r1, r3, #9 <== NOT EXECUTED
3bb30: e5841044 str r1, [r4, #68] ; 0x44 <== NOT EXECUTED
buf->st_blksize = fs_info->fat.vol.bps;
3bb34: e5842040 str r2, [r4, #64] ; 0x40 <== NOT EXECUTED
buf->st_mtime = fat_fd->mtime;
3bb38: e5962040 ldr r2, [r6, #64] ; 0x40 <== NOT EXECUTED
3bb3c: 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;
3bb40: e2852054 add r2, r5, #84 ; 0x54 <== NOT EXECUTED
3bb44: e8920006 ldm r2, {r1, r2} <== NOT EXECUTED
3bb48: 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;
3bb4c: e3a01000 mov r1, #0 <== NOT EXECUTED
3bb50: e3a02000 mov r2, #0 <== NOT EXECUTED
3bb54: e5841018 str r1, [r4, #24] <== NOT EXECUTED
3bb58: e584201c str r2, [r4, #28] <== NOT EXECUTED
buf->st_size = fat_fd->fat_file_size;
3bb5c: e5843020 str r3, [r4, #32] <== NOT EXECUTED
3bb60: 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);
3bb64: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
3bb68: ebff3f9a bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
3bb6c: e1a00007 mov r0, r7 <== NOT EXECUTED
return RC_OK;
}
3bb70: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
0003bc58 <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;
3bc58: 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)
{
3bc5c: 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;
3bc60: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
3bc64: 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)
{
3bc68: 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,
3bc6c: e1a02001 mov r2, r1 <== NOT EXECUTED
3bc70: 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;
3bc74: 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,
3bc78: ebff3f10 bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
3bc7c: e3500000 cmp r0, #0 <== NOT EXECUTED
3bc80: 0a000004 beq 3bc98 <msdos_dir_sync+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
3bc84: eb00049d bl 3cf00 <__errno> <== NOT EXECUTED
3bc88: e3a03005 mov r3, #5 <== NOT EXECUTED
3bc8c: e5803000 str r3, [r0] <== NOT EXECUTED
3bc90: e3e04000 mvn r4, #0 <== NOT EXECUTED
3bc94: ea000005 b 3bcb0 <msdos_dir_sync+0x58> <== NOT EXECUTED
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
3bc98: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
3bc9c: e1a01006 mov r1, r6 <== NOT EXECUTED
3bca0: ebff974a bl 219d0 <fat_file_datasync> <== NOT EXECUTED
3bca4: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
3bca8: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
3bcac: ebff3f49 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
3bcb0: e1a00004 mov r0, r4 <== NOT EXECUTED
3bcb4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
000314b0 <msdos_eval4make>:
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
314b0: 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;
314b4: e5913010 ldr r3, [r1, #16] <== NOT EXECUTED
314b8: e593a034 ldr sl, [r3, #52] ; 0x34 <== NOT EXECUTED
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
314bc: e24dd020 sub sp, sp, #32 <== NOT EXECUTED
314c0: 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,
314c4: e3a01000 mov r1, #0 <== NOT EXECUTED
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
314c8: e58d2000 str r2, [sp] <== NOT EXECUTED
314cc: e1a07000 mov r7, 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,
314d0: e1a02001 mov r2, r1 <== NOT EXECUTED
314d4: e59a0094 ldr r0, [sl, #148] ; 0x94 <== NOT EXECUTED
314d8: ebff68f8 bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
314dc: e3500000 cmp r0, #0 <== NOT EXECUTED
314e0: 0a000004 beq 314f8 <msdos_eval4make+0x48> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
314e4: eb002e85 bl 3cf00 <__errno> <== NOT EXECUTED
314e8: e3a03005 mov r3, #5 <== NOT EXECUTED
314ec: e5803000 str r3, [r0] <== NOT EXECUTED
314f0: e3e05000 mvn r5, #0 <== NOT EXECUTED
314f4: ea000086 b 31714 <msdos_eval4make+0x264> <== NOT EXECUTED
if (!pathloc->node_access)
314f8: e5940000 ldr r0, [r4] <== NOT EXECUTED
314fc: e3500000 cmp r0, #0 <== NOT EXECUTED
31500: 1a000004 bne 31518 <msdos_eval4make+0x68> <== NOT EXECUTED
{
errno = ENOENT;
31504: eb002e7d bl 3cf00 <__errno> <== NOT EXECUTED
31508: e3a03002 mov r3, #2 <== NOT EXECUTED
3150c: e5803000 str r3, [r0] <== NOT EXECUTED
31510: e3e05000 mvn r5, #0 <== NOT EXECUTED
rc = -1;
goto err;
31514: ea00007c b 3170c <msdos_eval4make+0x25c> <== NOT EXECUTED
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
31518: ebffc0d9 bl 21884 <fat_file_reopen> <== NOT EXECUTED
if (rc != RC_OK)
3151c: e2505000 subs r5, r0, #0 <== NOT EXECUTED
31520: 1a000079 bne 3170c <msdos_eval4make+0x25c> <== 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)
31524: e59f91f4 ldr r9, [pc, #500] ; 31720 <msdos_eval4make+0x270><== NOT EXECUTED
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
if (rc != RC_OK)
31528: e1a06005 mov r6, r5 <== NOT EXECUTED
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
3152c: e0878006 add r8, r7, r6 <== NOT EXECUTED
31530: e1a00008 mov r0, r8 <== NOT EXECUTED
31534: eb00496e bl 43af4 <strlen> <== NOT EXECUTED
31538: e28d2018 add r2, sp, #24 <== NOT EXECUTED
3153c: e1a01000 mov r1, r0 <== NOT EXECUTED
31540: e28d301c add r3, sp, #28 <== NOT EXECUTED
31544: e1a00008 mov r0, r8 <== NOT EXECUTED
31548: eb0005dc bl 32cc0 <msdos_get_token> <== NOT EXECUTED
i += token_len;
fat_fd = pathloc->node_access;
3154c: e594e000 ldr lr, [r4] <== NOT EXECUTED
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
i += token_len;
31550: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED
fat_fd = pathloc->node_access;
31554: e1a0800e mov r8, lr <== NOT EXECUTED
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
i += token_len;
31558: e0866002 add r6, r6, r2 <== NOT EXECUTED
fat_fd = pathloc->node_access;
switch (type)
3155c: e3500004 cmp r0, #4 <== NOT EXECUTED
31560: 979ff100 ldrls pc, [pc, r0, lsl #2] <== NOT EXECUTED
31564: eafffff0 b 3152c <msdos_eval4make+0x7c> <== NOT EXECUTED
31568: 0003167c .word 0x0003167c <== NOT EXECUTED
3156c: 0003152c .word 0x0003152c <== NOT EXECUTED
31570: 0003157c .word 0x0003157c <== NOT EXECUTED
31574: 0003164c .word 0x0003164c <== NOT EXECUTED
31578: 00031688 .word 0x00031688 <== NOT EXECUTED
{
case MSDOS_UP_DIR:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
3157c: e59e3010 ldr r3, [lr, #16] <== NOT EXECUTED
31580: e3530001 cmp r3, #1 <== NOT EXECUTED
pathloc, name);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
31584: 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)
31588: 1a000053 bne 316dc <msdos_eval4make+0x22c> <== NOT EXECUTED
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
pathloc->mt_entry->mt_fs_root.node_access)
3158c: e594c010 ldr ip, [r4, #16] <== NOT EXECUTED
}
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
31590: e59c301c ldr r3, [ip, #28] <== NOT EXECUTED
31594: e15e0003 cmp lr, r3 <== NOT EXECUTED
31598: 1a00001f bne 3161c <msdos_eval4make+0x16c> <== 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)
3159c: e5993000 ldr r3, [r9] <== NOT EXECUTED
315a0: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED
315a4: e15e0003 cmp lr, r3 <== NOT EXECUTED
315a8: 0affffdf beq 3152c <msdos_eval4make+0x7c> <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
315ac: e28cc008 add ip, ip, #8 <== NOT EXECUTED
315b0: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
315b4: e28d8004 add r8, sp, #4 <== NOT EXECUTED
315b8: e8a8000f stmia r8!, {r0, r1, r2, r3} <== NOT EXECUTED
*pathloc = newloc;
315bc: e28d5004 add r5, sp, #4 <== NOT EXECUTED
315c0: e8b5000f ldm r5!, {r0, r1, r2, r3} <== NOT EXECUTED
315c4: e1a05004 mov r5, r4 <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
315c8: e59cc000 ldr ip, [ip] <== NOT EXECUTED
*pathloc = newloc;
315cc: e8a5000f stmia r5!, {r0, r1, r2, r3} <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, fat_fd);
315d0: e1a0000c mov r0, ip <== NOT EXECUTED
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
*pathloc = newloc;
315d4: e585c000 str ip, [r5] <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, fat_fd);
315d8: e1a0100e mov r1, lr <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
315dc: e588c000 str ip, [r8] <== NOT EXECUTED
*pathloc = newloc;
rc = fat_file_close(pathloc->mt_entry, fat_fd);
315e0: ebffc334 bl 222b8 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
315e4: e2505000 subs r5, r0, #0 <== NOT EXECUTED
315e8: 1a000047 bne 3170c <msdos_eval4make+0x25c> <== NOT EXECUTED
goto err;
rtems_semaphore_release(fs_info->vol_sema);
315ec: e59a0094 ldr r0, [sl, #148] ; 0x94 <== NOT EXECUTED
315f0: ebff68f8 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)(&path[i-token_len],
315f4: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED
315f8: e0636006 rsb r6, r3, r6 <== NOT EXECUTED
315fc: e0870006 add r0, r7, r6 <== NOT EXECUTED
31600: e1a01004 mov r1, r4 <== NOT EXECUTED
31604: e59d2000 ldr r2, [sp] <== NOT EXECUTED
31608: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
3160c: e1a0e00f mov lr, pc <== NOT EXECUTED
31610: e593f004 ldr pc, [r3, #4] <== NOT EXECUTED
31614: e1a05000 mov r5, r0 <== NOT EXECUTED
31618: ea00003d b 31714 <msdos_eval4make+0x264> <== NOT EXECUTED
pathloc, name);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
3161c: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED
31620: eb0006ff bl 33224 <msdos_find_name> <== NOT EXECUTED
if (rc != RC_OK)
31624: e250b000 subs fp, r0, #0 <== NOT EXECUTED
31628: 0affffbf beq 3152c <msdos_eval4make+0x7c> <== NOT EXECUTED
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
3162c: e59f30f0 ldr r3, [pc, #240] ; 31724 <msdos_eval4make+0x274><== NOT EXECUTED
31630: e15b0003 cmp fp, r3 <== NOT EXECUTED
31634: 1a000030 bne 316fc <msdos_eval4make+0x24c> <== NOT EXECUTED
{
errno = ENOENT;
31638: eb002e30 bl 3cf00 <__errno> <== NOT EXECUTED
3163c: e3a03002 mov r3, #2 <== NOT EXECUTED
31640: e5803000 str r3, [r0] <== NOT EXECUTED
31644: e3e0b000 mvn fp, #0 <== NOT EXECUTED
31648: ea00002b b 316fc <msdos_eval4make+0x24c> <== NOT EXECUTED
case MSDOS_NAME:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
3164c: e59e3010 ldr r3, [lr, #16] <== NOT EXECUTED
31650: 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);
31654: e1a00004 mov r0, r4 <== NOT EXECUTED
case MSDOS_NAME:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
31658: 1a00001f bne 316dc <msdos_eval4make+0x22c> <== 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);
3165c: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED
31660: eb0006ef bl 33224 <msdos_find_name> <== NOT EXECUTED
if (rc)
31664: e3500000 cmp r0, #0 <== NOT EXECUTED
31668: 0affffaf beq 3152c <msdos_eval4make+0x7c> <== NOT EXECUTED
{
if (rc != MSDOS_NAME_NOT_FOUND_ERR)
3166c: e59f30b0 ldr r3, [pc, #176] ; 31724 <msdos_eval4make+0x274><== NOT EXECUTED
31670: e1500003 cmp r0, r3 <== NOT EXECUTED
31674: 0a000006 beq 31694 <msdos_eval4make+0x1e4> <== NOT EXECUTED
31678: eaffffee b 31638 <msdos_eval4make+0x188> <== NOT EXECUTED
done = true;
}
break;
case MSDOS_NO_MORE_PATH:
errno = EEXIST;
3167c: eb002e1f bl 3cf00 <__errno> <== NOT EXECUTED
31680: e3a03011 mov r3, #17 <== NOT EXECUTED
31684: eaffffed b 31640 <msdos_eval4make+0x190> <== NOT EXECUTED
case MSDOS_CURRENT_DIR:
break;
case MSDOS_INVALID_TOKEN:
errno = ENAMETOOLONG;
31688: eb002e1c bl 3cf00 <__errno> <== NOT EXECUTED
3168c: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED
31690: eaffffea b 31640 <msdos_eval4make+0x190> <== NOT EXECUTED
break;
}
}
*name = &path[i - token_len];
31694: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED
31698: e59d2000 ldr r2, [sp] <== NOT EXECUTED
3169c: e0633006 rsb r3, r3, r6 <== NOT EXECUTED
316a0: e0873003 add r3, r7, r3 <== NOT EXECUTED
316a4: e5823000 str r3, [r2] <== NOT EXECUTED
316a8: e0876006 add r6, r7, r6 <== 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++)
316ac: ea000003 b 316c0 <msdos_eval4make+0x210> <== NOT EXECUTED
{
if (!msdos_is_separator(path[i]))
316b0: ebff5e34 bl 8f88 <rtems_filesystem_is_separator> <== NOT EXECUTED
316b4: e3500000 cmp r0, #0 <== NOT EXECUTED
316b8: e2866001 add r6, r6, #1 <== NOT EXECUTED
316bc: 0affffdd beq 31638 <msdos_eval4make+0x188> <== 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++)
316c0: e5d63000 ldrb r3, [r6] <== NOT EXECUTED
316c4: e2530000 subs r0, r3, #0 <== NOT EXECUTED
316c8: 1afffff8 bne 316b0 <msdos_eval4make+0x200> <== NOT EXECUTED
rc = -1;
goto error;
}
}
fat_fd = pathloc->node_access;
316cc: e5948000 ldr r8, [r4] <== NOT EXECUTED
if (fat_fd->fat_file_type != FAT_DIRECTORY)
316d0: e5983010 ldr r3, [r8, #16] <== NOT EXECUTED
316d4: e3530001 cmp r3, #1 <== NOT EXECUTED
316d8: 0a000002 beq 316e8 <msdos_eval4make+0x238> <== NOT EXECUTED
{
errno = ENOTDIR;
316dc: eb002e07 bl 3cf00 <__errno> <== NOT EXECUTED
316e0: e3a03014 mov r3, #20 <== NOT EXECUTED
316e4: eaffffd5 b 31640 <msdos_eval4make+0x190> <== 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;
316e8: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
316ec: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED
316f0: e593308c ldr r3, [r3, #140] ; 0x8c <== NOT EXECUTED
316f4: e5843008 str r3, [r4, #8] <== NOT EXECUTED
316f8: ea000003 b 3170c <msdos_eval4make+0x25c> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
error:
fat_file_close(pathloc->mt_entry, fat_fd);
316fc: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
31700: e1a01008 mov r1, r8 <== NOT EXECUTED
31704: ebffc2eb bl 222b8 <fat_file_close> <== NOT EXECUTED
31708: e1a0500b mov r5, fp <== NOT EXECUTED
err:
rtems_semaphore_release(fs_info->vol_sema);
3170c: e59a0094 ldr r0, [sl, #148] ; 0x94 <== NOT EXECUTED
31710: ebff68b0 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
31714: e1a00005 mov r0, r5 <== NOT EXECUTED
31718: e28dd020 add sp, sp, #32 <== NOT EXECUTED
3171c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0003125c <msdos_eval_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
3125c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
31260: 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;
31264: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED
31268: e5939034 ldr r9, [r3, #52] ; 0x34 <== NOT EXECUTED
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
3126c: 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;
31270: e3a03000 mov r3, #0 <== NOT EXECUTED
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
31274: e88d0005 stm sp, {r0, r2} <== NOT EXECUTED
31278: e1a0a001 mov sl, 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,
3127c: e5990094 ldr r0, [r9, #148] ; 0x94 <== NOT EXECUTED
31280: e1a01003 mov r1, r3 <== NOT EXECUTED
31284: 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;
31288: 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,
3128c: ebff698b bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
31290: e3500000 cmp r0, #0 <== NOT EXECUTED
31294: 0a000004 beq 312ac <msdos_eval_path+0x50> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
31298: eb002f18 bl 3cf00 <__errno> <== NOT EXECUTED
3129c: e3a03005 mov r3, #5 <== NOT EXECUTED
312a0: e5803000 str r3, [r0] <== NOT EXECUTED
312a4: e3e05000 mvn r5, #0 <== NOT EXECUTED
312a8: ea00007b b 3149c <msdos_eval_path+0x240> <== NOT EXECUTED
if (!pathloc->node_access)
312ac: e5940000 ldr r0, [r4] <== NOT EXECUTED
312b0: e3500000 cmp r0, #0 <== NOT EXECUTED
312b4: 1a000004 bne 312cc <msdos_eval_path+0x70> <== NOT EXECUTED
{
errno = ENOENT;
312b8: eb002f10 bl 3cf00 <__errno> <== NOT EXECUTED
312bc: e3a03002 mov r3, #2 <== NOT EXECUTED
312c0: e5803000 str r3, [r0] <== NOT EXECUTED
312c4: e3e05000 mvn r5, #0 <== NOT EXECUTED
rc = -1;
goto err;
312c8: ea000071 b 31494 <msdos_eval_path+0x238> <== NOT EXECUTED
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
312cc: ebffc16c bl 21884 <fat_file_reopen> <== NOT EXECUTED
if (rc != RC_OK)
312d0: e2505000 subs r5, r0, #0 <== NOT EXECUTED
312d4: 03a06001 moveq r6, #1 <== NOT EXECUTED
312d8: 01a08005 moveq r8, r5 <== NOT EXECUTED
312dc: 0a000057 beq 31440 <msdos_eval_path+0x1e4> <== NOT EXECUTED
312e0: ea00006b b 31494 <msdos_eval_path+0x238> <== NOT EXECUTED
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
{
type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
312e4: eb000675 bl 32cc0 <msdos_get_token> <== NOT EXECUTED
pathnamelen -= token_len;
312e8: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED
i += token_len;
fat_fd = pathloc->node_access;
switch (type)
312ec: 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);
312f0: e1a06000 mov r6, r0 <== NOT EXECUTED
pathnamelen -= token_len;
312f4: e062a00a rsb sl, r2, sl <== NOT EXECUTED
i += token_len;
312f8: e0888002 add r8, r8, r2 <== NOT EXECUTED
fat_fd = pathloc->node_access;
312fc: e5947000 ldr r7, [r4] <== NOT EXECUTED
switch (type)
31300: 0a000039 beq 313ec <msdos_eval_path+0x190> <== NOT EXECUTED
31304: e3500004 cmp r0, #4 <== NOT EXECUTED
31308: 0a000048 beq 31430 <msdos_eval_path+0x1d4> <== NOT EXECUTED
3130c: e3500002 cmp r0, #2 <== NOT EXECUTED
31310: 1a00004a bne 31440 <msdos_eval_path+0x1e4> <== NOT EXECUTED
{
case MSDOS_UP_DIR:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
31314: e5973010 ldr r3, [r7, #16] <== NOT EXECUTED
31318: e3530001 cmp r3, #1 <== NOT EXECUTED
flags, pathloc);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
3131c: 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)
31320: 1a000035 bne 313fc <msdos_eval_path+0x1a0> <== NOT EXECUTED
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
pathloc->mt_entry->mt_fs_root.node_access)
31324: e594c010 ldr ip, [r4, #16] <== NOT EXECUTED
}
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
31328: e59c301c ldr r3, [ip, #28] <== NOT EXECUTED
3132c: e1570003 cmp r7, r3 <== NOT EXECUTED
31330: 1a000022 bne 313c0 <msdos_eval_path+0x164> <== 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)
31334: e59f216c ldr r2, [pc, #364] ; 314a8 <msdos_eval_path+0x24c><== NOT EXECUTED
31338: e5923000 ldr r3, [r2] <== NOT EXECUTED
3133c: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED
31340: e1570003 cmp r7, r3 <== NOT EXECUTED
31344: 0a00003d beq 31440 <msdos_eval_path+0x1e4> <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
31348: e28cc008 add ip, ip, #8 <== NOT EXECUTED
3134c: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
31350: e28d5008 add r5, sp, #8 <== NOT EXECUTED
31354: e8a5000f stmia r5!, {r0, r1, r2, r3} <== NOT EXECUTED
*pathloc = newloc;
31358: e28de008 add lr, sp, #8 <== NOT EXECUTED
3135c: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
31360: e1a0e004 mov lr, r4 <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
31364: e59cc000 ldr ip, [ip] <== NOT EXECUTED
*pathloc = newloc;
31368: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, fat_fd);
3136c: e1a0000c mov r0, ip <== NOT EXECUTED
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
*pathloc = newloc;
31370: e58ec000 str ip, [lr] <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, fat_fd);
31374: e1a01007 mov r1, r7 <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
31378: e585c000 str ip, [r5] <== NOT EXECUTED
*pathloc = newloc;
rc = fat_file_close(pathloc->mt_entry, fat_fd);
3137c: ebffc3cd bl 222b8 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
31380: e2505000 subs r5, r0, #0 <== NOT EXECUTED
31384: 1a000042 bne 31494 <msdos_eval_path+0x238> <== NOT EXECUTED
goto err;
rtems_semaphore_release(fs_info->vol_sema);
31388: e5990094 ldr r0, [r9, #148] ; 0x94 <== NOT EXECUTED
3138c: ebff6991 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)(&(pathname[i-token_len]),
31390: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED
31394: e59d2000 ldr r2, [sp] <== NOT EXECUTED
31398: e0610008 rsb r0, r1, r8 <== NOT EXECUTED
3139c: e0820000 add r0, r2, r0 <== NOT EXECUTED
313a0: e08a1001 add r1, sl, r1 <== NOT EXECUTED
313a4: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED
313a8: e1a03004 mov r3, r4 <== NOT EXECUTED
313ac: e594c00c ldr ip, [r4, #12] <== NOT EXECUTED
313b0: e1a0e00f mov lr, pc <== NOT EXECUTED
313b4: e59cf000 ldr pc, [ip] <== NOT EXECUTED
313b8: e1a05000 mov r5, r0 <== NOT EXECUTED
313bc: ea000036 b 3149c <msdos_eval_path+0x240> <== NOT EXECUTED
flags, pathloc);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
313c0: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED
313c4: eb000796 bl 33224 <msdos_find_name> <== NOT EXECUTED
if (rc != RC_OK)
313c8: e250b000 subs fp, r0, #0 <== NOT EXECUTED
313cc: 0a00001b beq 31440 <msdos_eval_path+0x1e4> <== NOT EXECUTED
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
313d0: e59f30d4 ldr r3, [pc, #212] ; 314ac <msdos_eval_path+0x250><== NOT EXECUTED
313d4: e15b0003 cmp fp, r3 <== NOT EXECUTED
313d8: 1a000029 bne 31484 <msdos_eval_path+0x228> <== NOT EXECUTED
{
errno = ENOENT;
313dc: eb002ec7 bl 3cf00 <__errno> <== NOT EXECUTED
313e0: e5806000 str r6, [r0] <== NOT EXECUTED
313e4: e3e0b000 mvn fp, #0 <== NOT EXECUTED
313e8: ea000025 b 31484 <msdos_eval_path+0x228> <== NOT EXECUTED
case MSDOS_NAME:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
313ec: e5973010 ldr r3, [r7, #16] <== NOT EXECUTED
313f0: 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);
313f4: e1a00004 mov r0, r4 <== NOT EXECUTED
case MSDOS_NAME:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
313f8: 0a000002 beq 31408 <msdos_eval_path+0x1ac> <== NOT EXECUTED
{
errno = ENOTSUP;
313fc: eb002ebf bl 3cf00 <__errno> <== NOT EXECUTED
31400: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
31404: ea00000b b 31438 <msdos_eval_path+0x1dc> <== 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);
31408: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED
3140c: eb000784 bl 33224 <msdos_find_name> <== NOT EXECUTED
if (rc != RC_OK)
31410: e250b000 subs fp, r0, #0 <== NOT EXECUTED
31414: 0a000009 beq 31440 <msdos_eval_path+0x1e4> <== NOT EXECUTED
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
31418: e59f308c ldr r3, [pc, #140] ; 314ac <msdos_eval_path+0x250><== NOT EXECUTED
3141c: e15b0003 cmp fp, r3 <== NOT EXECUTED
31420: 1a000017 bne 31484 <msdos_eval_path+0x228> <== NOT EXECUTED
{
errno = ENOENT;
31424: eb002eb5 bl 3cf00 <__errno> <== NOT EXECUTED
31428: e3a03002 mov r3, #2 <== NOT EXECUTED
3142c: ea000001 b 31438 <msdos_eval_path+0x1dc> <== NOT EXECUTED
case MSDOS_NO_MORE_PATH:
case MSDOS_CURRENT_DIR:
break;
case MSDOS_INVALID_TOKEN:
errno = ENAMETOOLONG;
31430: eb002eb2 bl 3cf00 <__errno> <== NOT EXECUTED
31434: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED
31438: e5803000 str r3, [r0] <== NOT EXECUTED
3143c: eaffffe8 b 313e4 <msdos_eval_path+0x188> <== 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);
31440: e59dc000 ldr ip, [sp] <== NOT EXECUTED
rc = fat_file_reopen(fat_fd);
if (rc != RC_OK)
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
31444: e3560004 cmp r6, #4 <== NOT EXECUTED
31448: 13560000 cmpne r6, #0 <== NOT EXECUTED
{
type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
3144c: e1a0100a mov r1, sl <== NOT EXECUTED
31450: e28d201c add r2, sp, #28 <== NOT EXECUTED
31454: e28d3020 add r3, sp, #32 <== NOT EXECUTED
31458: e08c0008 add r0, ip, r8 <== NOT EXECUTED
rc = fat_file_reopen(fat_fd);
if (rc != RC_OK)
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
3145c: 1affffa0 bne 312e4 <msdos_eval_path+0x88> <== NOT EXECUTED
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
31460: e5943000 ldr r3, [r4] <== NOT EXECUTED
31464: e5932010 ldr r2, [r3, #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;
31468: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
3146c: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED
fat_file_fd_t *fat_fd = loc->node_access;
31470: e3520001 cmp r2, #1 <== NOT EXECUTED
if (fat_fd->fat_file_type == FAT_DIRECTORY)
loc->handlers = fs_info->directory_handlers;
31474: 0593308c ldreq r3, [r3, #140] ; 0x8c <== NOT EXECUTED
else
loc->handlers = fs_info->file_handlers;
31478: 15933090 ldrne r3, [r3, #144] ; 0x90 <== NOT EXECUTED
3147c: e5843008 str r3, [r4, #8] <== NOT EXECUTED
31480: ea000003 b 31494 <msdos_eval_path+0x238> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
error:
fat_file_close(pathloc->mt_entry, fat_fd);
31484: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
31488: e1a01007 mov r1, r7 <== NOT EXECUTED
3148c: ebffc389 bl 222b8 <fat_file_close> <== NOT EXECUTED
31490: e1a0500b mov r5, fp <== NOT EXECUTED
err:
rtems_semaphore_release(fs_info->vol_sema);
31494: e5990094 ldr r0, [r9, #148] ; 0x94 <== NOT EXECUTED
31498: ebff694e bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
3149c: e1a00005 mov r0, r5 <== NOT EXECUTED
314a0: e28dd024 add sp, sp, #36 ; 0x24 <== NOT EXECUTED
314a4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00031730 <msdos_file_chmod>:
int
msdos_file_chmod(rtems_filesystem_location_info_t *pathloc,
mode_t mode)
{
return RC_OK;
}
31730: e3a00000 mov r0, #0 <== NOT EXECUTED
31734: e12fff1e bx lr <== NOT EXECUTED
00031c1c <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;
31c1c: 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)
{
31c20: 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;
31c24: 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,
31c28: 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)
{
31c2c: 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,
31c30: e1a02001 mov r2, r1 <== NOT EXECUTED
31c34: e5950094 ldr r0, [r5, #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;
31c38: e5946038 ldr r6, [r4, #56] ; 0x38 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
31c3c: ebff671f bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
31c40: e3500000 cmp r0, #0 <== NOT EXECUTED
31c44: 0a000004 beq 31c5c <msdos_file_close+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
31c48: eb002cac bl 3cf00 <__errno> <== NOT EXECUTED
31c4c: e3a03005 mov r3, #5 <== NOT EXECUTED
31c50: e5803000 str r3, [r0] <== NOT EXECUTED
31c54: e3e07000 mvn r7, #0 <== NOT EXECUTED
31c58: ea000017 b 31cbc <msdos_file_close+0xa0> <== 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))
31c5c: e5d63030 ldrb r3, [r6, #48] ; 0x30 <== NOT EXECUTED
31c60: e3130001 tst r3, #1 <== NOT EXECUTED
31c64: 1a00000e bne 31ca4 <msdos_file_close+0x88> <== NOT EXECUTED
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
31c68: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
31c6c: e1a01006 mov r1, r6 <== NOT EXECUTED
31c70: eb00034e bl 329b0 <msdos_set_first_cluster_num> <== NOT EXECUTED
if (rc != RC_OK)
31c74: e2507000 subs r7, r0, #0 <== NOT EXECUTED
31c78: 1a00000d bne 31cb4 <msdos_file_close+0x98> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
31c7c: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
31c80: e1a01006 mov r1, r6 <== NOT EXECUTED
31c84: eb00032b bl 32938 <msdos_set_file_size> <== NOT EXECUTED
if (rc != RC_OK)
31c88: e2507000 subs r7, r0, #0 <== NOT EXECUTED
31c8c: 1a000008 bne 31cb4 <msdos_file_close+0x98> <== 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);
31c90: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
31c94: e1a01006 mov r1, r6 <== NOT EXECUTED
31c98: eb0003c0 bl 32ba0 <msdos_set_dir_wrt_time_and_date> <== NOT EXECUTED
if (rc != RC_OK)
31c9c: e2507000 subs r7, r0, #0 <== NOT EXECUTED
31ca0: 1a000003 bne 31cb4 <msdos_file_close+0x98> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
31ca4: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
31ca8: e1a01006 mov r1, r6 <== NOT EXECUTED
31cac: ebffc181 bl 222b8 <fat_file_close> <== NOT EXECUTED
31cb0: e1a07000 mov r7, r0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
31cb4: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
31cb8: ebff6746 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
31cbc: e1a00007 mov r0, r7 <== NOT EXECUTED
31cc0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00031850 <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;
31850: 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)
{
31854: 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;
31858: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
3185c: 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)
{
31860: 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,
31864: e1a02001 mov r2, r1 <== NOT EXECUTED
31868: 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;
3186c: 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,
31870: ebff6812 bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
31874: e2507000 subs r7, r0, #0 <== NOT EXECUTED
31878: 0a000004 beq 31890 <msdos_file_datasync+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
3187c: eb002d9f bl 3cf00 <__errno> <== NOT EXECUTED
31880: e3a03005 mov r3, #5 <== NOT EXECUTED
31884: e5803000 str r3, [r0] <== NOT EXECUTED
31888: e3e00000 mvn r0, #0 <== NOT EXECUTED
3188c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
/* synchronize file data */
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
31890: e1a01006 mov r1, r6 <== NOT EXECUTED
31894: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
31898: ebffc04c bl 219d0 <fat_file_datasync> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
3189c: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
318a0: ebff684c bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
318a4: e1a00007 mov r0, r7 <== NOT EXECUTED
return RC_OK;
}
318a8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00031968 <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)
{
31968: 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;
3196c: 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)
{
31970: e1a08002 mov r8, 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;
31974: e5906038 ldr r6, [r0, #56] ; 0x38 <== NOT EXECUTED
if (length >= fat_fd->fat_file_size)
31978: e3a02000 mov r2, #0 <== NOT EXECUTED
3197c: e1520008 cmp r2, r8 <== 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;
31980: e5937034 ldr r7, [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)
{
31984: e1a04000 mov r4, r0 <== NOT EXECUTED
31988: e1a05001 mov r5, 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)
3198c: e5963018 ldr r3, [r6, #24] <== NOT EXECUTED
31990: ca000004 bgt 319a8 <msdos_file_ftruncate+0x40> <== NOT EXECUTED
31994: 1a000001 bne 319a0 <msdos_file_ftruncate+0x38> <== NOT EXECUTED
31998: e1530001 cmp r3, r1 <== NOT EXECUTED
3199c: 8a000001 bhi 319a8 <msdos_file_ftruncate+0x40> <== NOT EXECUTED
319a0: e3a0a000 mov sl, #0 <== NOT EXECUTED
319a4: ea00001c b 31a1c <msdos_file_ftruncate+0xb4> <== NOT EXECUTED
return RC_OK;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
319a8: e3a01000 mov r1, #0 <== NOT EXECUTED
319ac: e5970094 ldr r0, [r7, #148] ; 0x94 <== NOT EXECUTED
319b0: e1a02001 mov r2, r1 <== NOT EXECUTED
319b4: ebff67c1 bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
319b8: e3500000 cmp r0, #0 <== NOT EXECUTED
319bc: 0a000004 beq 319d4 <msdos_file_ftruncate+0x6c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
319c0: eb002d4e bl 3cf00 <__errno> <== NOT EXECUTED
319c4: e3a03005 mov r3, #5 <== NOT EXECUTED
319c8: e5803000 str r3, [r0] <== NOT EXECUTED
319cc: e3e0a000 mvn sl, #0 <== NOT EXECUTED
319d0: ea000011 b 31a1c <msdos_file_ftruncate+0xb4> <== NOT EXECUTED
rc = fat_file_truncate(iop->pathinfo.mt_entry, fat_fd, length);
319d4: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
319d8: e1a01006 mov r1, r6 <== NOT EXECUTED
319dc: e1a02005 mov r2, r5 <== NOT EXECUTED
319e0: ebffc07b bl 21bd4 <fat_file_truncate> <== NOT EXECUTED
if (rc != RC_OK)
319e4: e250a000 subs sl, r0, #0 <== NOT EXECUTED
319e8: 1a000009 bne 31a14 <msdos_file_ftruncate+0xac> <== 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)
319ec: e15a0008 cmp sl, r8 <== NOT EXECUTED
319f0: e5963018 ldr r3, [r6, #24] <== NOT EXECUTED
319f4: ca000002 bgt 31a04 <msdos_file_ftruncate+0x9c> <== NOT EXECUTED
319f8: 1a000005 bne 31a14 <msdos_file_ftruncate+0xac> <== NOT EXECUTED
319fc: e1530005 cmp r3, r5 <== NOT EXECUTED
31a00: 9a000003 bls 31a14 <msdos_file_ftruncate+0xac> <== NOT EXECUTED
iop->size = fat_fd->fat_file_size = length;
31a04: e3a03000 mov r3, #0 <== NOT EXECUTED
31a08: e5843008 str r3, [r4, #8] <== NOT EXECUTED
31a0c: e5865018 str r5, [r6, #24] <== NOT EXECUTED
31a10: e5845004 str r5, [r4, #4] <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
31a14: e5970094 ldr r0, [r7, #148] ; 0x94 <== NOT EXECUTED
31a18: ebff67ee bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
}
31a1c: e1a0000a mov r0, sl <== NOT EXECUTED
31a20: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
00031728 <msdos_file_ioctl>:
msdos_file_ioctl(rtems_libio_t *iop,uint32_t command, void *buffer)
{
int rc = RC_OK;
return rc;
}
31728: e3a00000 mov r0, #0 <== NOT EXECUTED
3172c: e12fff1e bx lr <== NOT EXECUTED
00031a24 <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)
{
31a24: e92d40f1 push {r0, 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;
31a28: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
31a2c: e5936034 ldr r6, [r3, #52] ; 0x34 <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->file_info;
uint32_t real_size = 0;
31a30: 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)
{
31a34: 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,
31a38: e1a01003 mov r1, r3 <== NOT EXECUTED
31a3c: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED
31a40: 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;
31a44: 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;
31a48: e5945038 ldr r5, [r4, #56] ; 0x38 <== NOT EXECUTED
uint32_t real_size = 0;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
31a4c: ebff679b bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
31a50: e3500000 cmp r0, #0 <== NOT EXECUTED
31a54: 0a000005 beq 31a70 <msdos_file_lseek+0x4c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
31a58: eb002d28 bl 3cf00 <__errno> <== NOT EXECUTED
31a5c: e3a03005 mov r3, #5 <== NOT EXECUTED
31a60: e5803000 str r3, [r0] <== NOT EXECUTED
31a64: e3e04000 mvn r4, #0 <== NOT EXECUTED
31a68: e3e03000 mvn r3, #0 <== NOT EXECUTED
31a6c: ea000019 b 31ad8 <msdos_file_lseek+0xb4> <== NOT EXECUTED
rc = fat_file_extend(iop->pathinfo.mt_entry, fat_fd, iop->offset,
31a70: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
31a74: e1a01005 mov r1, r5 <== NOT EXECUTED
31a78: e594200c ldr r2, [r4, #12] <== NOT EXECUTED
31a7c: e1a0300d mov r3, sp <== NOT EXECUTED
31a80: ebffc091 bl 21ccc <fat_file_extend> <== NOT EXECUTED
&real_size);
if (rc != RC_OK)
31a84: e2507000 subs r7, r0, #0 <== NOT EXECUTED
31a88: 0a000004 beq 31aa0 <msdos_file_lseek+0x7c> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
31a8c: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED
31a90: ebff67d0 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
31a94: e1a03007 mov r3, r7 <== NOT EXECUTED
31a98: e1a04fc3 asr r4, r3, #31 <== NOT EXECUTED
31a9c: ea00000d b 31ad8 <msdos_file_lseek+0xb4> <== NOT EXECUTED
}
if (real_size > fat_fd->fat_file_size)
31aa0: e59d3000 ldr r3, [sp] <== NOT EXECUTED
31aa4: e5952018 ldr r2, [r5, #24] <== NOT EXECUTED
31aa8: e1530002 cmp r3, r2 <== NOT EXECUTED
fat_fd->fat_file_size = iop->offset = real_size;
31aac: 85853018 strhi r3, [r5, #24] <== NOT EXECUTED
31ab0: 8584300c strhi r3, [r4, #12] <== NOT EXECUTED
iop->size = fat_fd->fat_file_size;
31ab4: e5953018 ldr r3, [r5, #24] <== NOT EXECUTED
31ab8: e5843004 str r3, [r4, #4] <== NOT EXECUTED
31abc: e3a03000 mov r3, #0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (real_size > fat_fd->fat_file_size)
fat_fd->fat_file_size = iop->offset = real_size;
31ac0: 85847010 strhi r7, [r4, #16] <== NOT EXECUTED
iop->size = fat_fd->fat_file_size;
31ac4: e5843008 str r3, [r4, #8] <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
31ac8: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED
31acc: ebff67c1 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return iop->offset;
31ad0: e284400c add r4, r4, #12 <== NOT EXECUTED
31ad4: e8940018 ldm r4, {r3, r4} <== NOT EXECUTED
}
31ad8: e1a01004 mov r1, r4 <== NOT EXECUTED
31adc: e1a00003 mov r0, r3 <== NOT EXECUTED
31ae0: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
00031cc4 <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;
31cc4: 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)
{
31cc8: 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;
31ccc: 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,
31cd0: 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)
{
31cd4: 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,
31cd8: e1a02001 mov r2, r1 <== NOT EXECUTED
31cdc: 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;
31ce0: e5946038 ldr r6, [r4, #56] ; 0x38 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
31ce4: ebff66f5 bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
31ce8: e3500000 cmp r0, #0 <== NOT EXECUTED
31cec: 0a000004 beq 31d04 <msdos_file_open+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
31cf0: eb002c82 bl 3cf00 <__errno> <== NOT EXECUTED
31cf4: e3a03005 mov r3, #5 <== NOT EXECUTED
31cf8: e5803000 str r3, [r0] <== NOT EXECUTED
31cfc: e3e07000 mvn r7, #0 <== NOT EXECUTED
31d00: ea00000e b 31d40 <msdos_file_open+0x7c> <== NOT EXECUTED
rc = fat_file_reopen(fat_fd);
31d04: e1a00006 mov r0, r6 <== NOT EXECUTED
31d08: ebffbedd bl 21884 <fat_file_reopen> <== NOT EXECUTED
if (rc != RC_OK)
31d0c: e2507000 subs r7, r0, #0 <== NOT EXECUTED
31d10: 1a000008 bne 31d38 <msdos_file_open+0x74> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
31d14: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
31d18: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
iop->offset = fat_fd->fat_file_size;
31d1c: 15963018 ldrne r3, [r6, #24] <== NOT EXECUTED
31d20: 1584300c strne r3, [r4, #12] <== NOT EXECUTED
iop->size = fat_fd->fat_file_size;
31d24: e5963018 ldr r3, [r6, #24] <== NOT EXECUTED
31d28: e3a02000 mov r2, #0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
iop->offset = fat_fd->fat_file_size;
31d2c: 15847010 strne r7, [r4, #16] <== NOT EXECUTED
iop->size = fat_fd->fat_file_size;
31d30: e5842008 str r2, [r4, #8] <== NOT EXECUTED
31d34: e5843004 str r3, [r4, #4] <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
31d38: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
31d3c: ebff6725 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
}
31d40: e1a00007 mov r0, r7 <== NOT EXECUTED
31d44: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00031ba8 <msdos_file_read>:
ssize_t
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;
31ba8: e5903028 ldr r3, [r0, #40] ; 0x28 <== 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)
{
31bac: e92d41f1 push {r0, 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;
31bb0: e5935034 ldr r5, [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)
{
31bb4: e1a06001 mov r6, 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,
31bb8: 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)
{
31bbc: e1a04000 mov r4, r0 <== NOT EXECUTED
31bc0: 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,
31bc4: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
31bc8: 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;
31bcc: e5948038 ldr r8, [r4, #56] ; 0x38 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
31bd0: ebff673a bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
31bd4: e3500000 cmp r0, #0 <== NOT EXECUTED
31bd8: 0a000004 beq 31bf0 <msdos_file_read+0x48> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
31bdc: eb002cc7 bl 3cf00 <__errno> <== NOT EXECUTED
31be0: e3a03005 mov r3, #5 <== NOT EXECUTED
31be4: e5803000 str r3, [r0] <== NOT EXECUTED
31be8: e3e04000 mvn r4, #0 <== NOT EXECUTED
31bec: ea000008 b 31c14 <msdos_file_read+0x6c> <== NOT EXECUTED
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
31bf0: e594200c ldr r2, [r4, #12] <== NOT EXECUTED
31bf4: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
31bf8: e1a01008 mov r1, r8 <== NOT EXECUTED
31bfc: e1a03007 mov r3, r7 <== NOT EXECUTED
31c00: e58d6000 str r6, [sp] <== NOT EXECUTED
31c04: ebffc131 bl 220d0 <fat_file_read> <== NOT EXECUTED
31c08: e1a04000 mov r4, r0 <== NOT EXECUTED
buffer);
rtems_semaphore_release(fs_info->vol_sema);
31c0c: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
31c10: ebff6770 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return ret;
}
31c14: e1a00004 mov r0, r4 <== NOT EXECUTED
31c18: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
000317e0 <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;
317e0: 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)
{
317e4: 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;
317e8: 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)
{
317ec: 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,
317f0: e3a01000 mov r1, #0 <== NOT EXECUTED
317f4: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
317f8: 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;
317fc: e5946000 ldr r6, [r4] <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
31800: ebff682e bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
31804: e3500000 cmp r0, #0 <== NOT EXECUTED
31808: 0a000004 beq 31820 <msdos_file_rmnod+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
3180c: eb002dbb bl 3cf00 <__errno> <== NOT EXECUTED
31810: e3a03005 mov r3, #5 <== NOT EXECUTED
31814: e5803000 str r3, [r0] <== NOT EXECUTED
31818: e3e07000 mvn r7, #0 <== NOT EXECUTED
3181c: ea000009 b 31848 <msdos_file_rmnod+0x68> <== NOT EXECUTED
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry,
31820: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
31824: e2861020 add r1, r6, #32 <== NOT EXECUTED
31828: e3a020e5 mov r2, #229 ; 0xe5 <== NOT EXECUTED
3182c: eb00048c bl 32a64 <msdos_set_first_char4file_name> <== NOT EXECUTED
&fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
31830: 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);
31834: 05940010 ldreq r0, [r4, #16] <== NOT EXECUTED
31838: 01a01006 moveq r1, r6 <== NOT EXECUTED
3183c: 0bffc0a3 bleq 21ad0 <fat_file_mark_removed> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
31840: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
31844: ebff6863 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
}
31848: e1a00007 mov r0, r7 <== NOT EXECUTED
3184c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00031738 <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;
31738: e5902010 ldr r2, [r0, #16] <== NOT EXECUTED
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
3173c: 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;
31740: e5925034 ldr r5, [r2, #52] ; 0x34 <== NOT EXECUTED
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
31744: 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,
31748: e3a01000 mov r1, #0 <== NOT EXECUTED
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
3174c: 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,
31750: e1a02001 mov r2, r1 <== NOT EXECUTED
31754: 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;
31758: e5936000 ldr r6, [r3] <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
3175c: ebff6857 bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
31760: e2507000 subs r7, r0, #0 <== NOT EXECUTED
31764: 0a000004 beq 3177c <msdos_file_stat+0x44> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
31768: eb002de4 bl 3cf00 <__errno> <== NOT EXECUTED
3176c: e3a03005 mov r3, #5 <== NOT EXECUTED
31770: e5803000 str r3, [r0] <== NOT EXECUTED
31774: e3e00000 mvn r0, #0 <== NOT EXECUTED
31778: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
3177c: e596300c ldr r3, [r6, #12] <== NOT EXECUTED
31780: e5843008 str r3, [r4, #8] <== NOT EXECUTED
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
31784: e59f3050 ldr r3, [pc, #80] ; 317dc <msdos_file_stat+0xa4> <== NOT EXECUTED
31788: e584300c str r3, [r4, #12] <== NOT EXECUTED
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
3178c: 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;
31790: 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;
31794: e1a014a3 lsr r1, r3, #9 <== NOT EXECUTED
31798: e5841044 str r1, [r4, #68] ; 0x44 <== NOT EXECUTED
buf->st_blksize = fs_info->fat.vol.bps;
3179c: e5842040 str r2, [r4, #64] ; 0x40 <== NOT EXECUTED
buf->st_mtime = fat_fd->mtime;
317a0: e5962040 ldr r2, [r6, #64] ; 0x40 <== NOT EXECUTED
317a4: 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;
317a8: e2852054 add r2, r5, #84 ; 0x54 <== NOT EXECUTED
317ac: e8920006 ldm r2, {r1, r2} <== NOT EXECUTED
317b0: 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;
317b4: e3a01000 mov r1, #0 <== NOT EXECUTED
317b8: e3a02000 mov r2, #0 <== NOT EXECUTED
317bc: e5841018 str r1, [r4, #24] <== NOT EXECUTED
317c0: e584201c str r2, [r4, #28] <== NOT EXECUTED
buf->st_size = fat_fd->fat_file_size;
317c4: e5843020 str r3, [r4, #32] <== NOT EXECUTED
317c8: 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);
317cc: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
317d0: ebff6880 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
317d4: e1a00007 mov r0, r7 <== NOT EXECUTED
return RC_OK;
}
317d8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
000318ac <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;
318ac: 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)
{
318b0: 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;
318b4: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
318b8: 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)
{
318bc: e1a05000 mov r5, 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,
318c0: e1a02001 mov r2, r1 <== NOT EXECUTED
318c4: e5940094 ldr r0, [r4, #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;
318c8: e5956038 ldr r6, [r5, #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,
318cc: ebff67fb bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
318d0: e3500000 cmp r0, #0 <== NOT EXECUTED
318d4: 0a000004 beq 318ec <msdos_file_sync+0x40> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
318d8: eb002d88 bl 3cf00 <__errno> <== NOT EXECUTED
318dc: e3a03005 mov r3, #5 <== NOT EXECUTED
318e0: e5803000 str r3, [r0] <== NOT EXECUTED
318e4: e3e07000 mvn r7, #0 <== NOT EXECUTED
318e8: ea00001c b 31960 <msdos_file_sync+0xb4> <== NOT EXECUTED
/* synchronize file data */
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
318ec: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
318f0: e1a01006 mov r1, r6 <== NOT EXECUTED
318f4: ebffc035 bl 219d0 <fat_file_datasync> <== NOT EXECUTED
if (rc != RC_OK)
318f8: e2507000 subs r7, r0, #0 <== NOT EXECUTED
318fc: 1a000011 bne 31948 <msdos_file_sync+0x9c> <== NOT EXECUTED
/*
* if fat-file descriptor is not marked "removed" - synchronize file
* metadata
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
31900: e5d63030 ldrb r3, [r6, #48] ; 0x30 <== NOT EXECUTED
31904: e3130001 tst r3, #1 <== NOT EXECUTED
31908: 1a000011 bne 31954 <msdos_file_sync+0xa8> <== NOT EXECUTED
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
3190c: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
31910: e1a01006 mov r1, r6 <== NOT EXECUTED
31914: eb000425 bl 329b0 <msdos_set_first_cluster_num> <== NOT EXECUTED
if (rc != RC_OK)
31918: e2507000 subs r7, r0, #0 <== NOT EXECUTED
3191c: 1a000009 bne 31948 <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);
31920: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
31924: e1a01006 mov r1, r6 <== NOT EXECUTED
31928: eb000402 bl 32938 <msdos_set_file_size> <== NOT EXECUTED
if (rc != RC_OK)
3192c: e2507000 subs r7, r0, #0 <== NOT EXECUTED
31930: 1a000004 bne 31948 <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);
31934: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
31938: e1a01006 mov r1, r6 <== NOT EXECUTED
3193c: eb000497 bl 32ba0 <msdos_set_dir_wrt_time_and_date> <== NOT EXECUTED
if (rc != RC_OK)
31940: e2507000 subs r7, r0, #0 <== NOT EXECUTED
31944: 0a000002 beq 31954 <msdos_file_sync+0xa8> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
31948: e5940094 ldr r0, [r4, #148] ; 0x94 <== NOT EXECUTED
3194c: ebff6821 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
31950: ea000002 b 31960 <msdos_file_sync+0xb4> <== NOT EXECUTED
}
}
rtems_semaphore_release(fs_info->vol_sema);
31954: e5940094 ldr r0, [r4, #148] ; 0x94 <== NOT EXECUTED
31958: ebff681e bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
3195c: e3a07000 mov r7, #0 <== NOT EXECUTED
return RC_OK;
}
31960: e1a00007 mov r0, r7 <== NOT EXECUTED
31964: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00031ae4 <msdos_file_write>:
ssize_t
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;
31ae4: e5903028 ldr r3, [r0, #40] ; 0x28 <== 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)
{
31ae8: e92d41f1 push {r0, 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;
31aec: 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)
{
31af0: 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,
31af4: 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)
{
31af8: e1a04000 mov r4, r0 <== NOT EXECUTED
31afc: e1a08002 mov r8, 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,
31b00: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED
31b04: 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;
31b08: e5945038 ldr r5, [r4, #56] ; 0x38 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
31b0c: ebff676b bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
31b10: e3500000 cmp r0, #0 <== NOT EXECUTED
31b14: 0a000003 beq 31b28 <msdos_file_write+0x44> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
31b18: eb002cf8 bl 3cf00 <__errno> <== NOT EXECUTED
31b1c: e3a03005 mov r3, #5 <== NOT EXECUTED
31b20: e5803000 str r3, [r0] <== NOT EXECUTED
31b24: ea000009 b 31b50 <msdos_file_write+0x6c> <== NOT EXECUTED
ret = fat_file_write(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
31b28: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
31b2c: e594200c ldr r2, [r4, #12] <== NOT EXECUTED
31b30: e1a03008 mov r3, r8 <== NOT EXECUTED
31b34: e1a01005 mov r1, r5 <== NOT EXECUTED
31b38: e58d7000 str r7, [sp] <== NOT EXECUTED
31b3c: ebffc0d6 bl 21e9c <fat_file_write> <== NOT EXECUTED
buffer);
if (ret < 0)
31b40: e2507000 subs r7, r0, #0 <== NOT EXECUTED
31b44: aa000003 bge 31b58 <msdos_file_write+0x74> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
31b48: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED
31b4c: ebff67a1 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
31b50: e3e07000 mvn r7, #0 <== NOT EXECUTED
return -1;
31b54: ea000011 b 31ba0 <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)
31b58: e284300c add r3, r4, #12 <== NOT EXECUTED
31b5c: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
31b60: e0920007 adds r0, r2, r7 <== NOT EXECUTED
31b64: e0a31fc7 adc r1, r3, r7, asr #31 <== NOT EXECUTED
31b68: e3510000 cmp r1, #0 <== NOT EXECUTED
31b6c: e595c018 ldr ip, [r5, #24] <== NOT EXECUTED
31b70: ca000002 bgt 31b80 <msdos_file_write+0x9c> <== NOT EXECUTED
31b74: 1a000003 bne 31b88 <msdos_file_write+0xa4> <== NOT EXECUTED
31b78: e150000c cmp r0, ip <== NOT EXECUTED
31b7c: 9a000001 bls 31b88 <msdos_file_write+0xa4> <== NOT EXECUTED
fat_fd->fat_file_size = iop->offset + ret;
31b80: e0872002 add r2, r7, r2 <== NOT EXECUTED
31b84: e5852018 str r2, [r5, #24] <== NOT EXECUTED
iop->size = fat_fd->fat_file_size;
31b88: e5953018 ldr r3, [r5, #24] <== NOT EXECUTED
31b8c: e3a02000 mov r2, #0 <== NOT EXECUTED
31b90: e5842008 str r2, [r4, #8] <== NOT EXECUTED
31b94: e5843004 str r3, [r4, #4] <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
31b98: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED
31b9c: ebff678d bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return ret;
}
31ba0: e1a00007 mov r0, r7 <== NOT EXECUTED
31ba4: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
0003b938 <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)
{
3b938: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3b93c: 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] = ' ';
3b940: e3a0c020 mov ip, #32 <== NOT EXECUTED
3b944: 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++)
3b948: e2833001 add r3, r3, #1 <== NOT EXECUTED
3b94c: e353000b cmp r3, #11 <== NOT EXECUTED
3b950: 1afffffb bne 3b944 <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) {
3b954: e5d03000 ldrb r3, [r0] <== NOT EXECUTED
3b958: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED
3b95c: 13a0c000 movne ip, #0 <== NOT EXECUTED
3b960: 03a0c001 moveq ip, #1 <== NOT EXECUTED
3b964: e3510001 cmp r1, #1 <== NOT EXECUTED
3b968: 0353002e cmpeq r3, #46 ; 0x2e <== NOT EXECUTED
dn[0] = '.';
3b96c: 03a0302e moveq r3, #46 ; 0x2e <== NOT EXECUTED
/*
* The filenames "." and ".." are handled specially, since they
* don't follow dos filename rules.
*/
if (un[0] == '.' && unlen == 1) {
3b970: 0a000007 beq 3b994 <msdos_filename_unix2dos+0x5c> <== NOT EXECUTED
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
3b974: e35c0000 cmp ip, #0 <== NOT EXECUTED
3b978: 0a000009 beq 3b9a4 <msdos_filename_unix2dos+0x6c> <== NOT EXECUTED
3b97c: e5d03001 ldrb r3, [r0, #1] <== NOT EXECUTED
3b980: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED
3b984: 03510002 cmpeq r1, #2 <== NOT EXECUTED
3b988: 1a000005 bne 3b9a4 <msdos_filename_unix2dos+0x6c> <== NOT EXECUTED
dn[0] = '.';
3b98c: e3a0302e mov r3, #46 ; 0x2e <== NOT EXECUTED
dn[1] = '.';
3b990: e5c23001 strb r3, [r2, #1] <== NOT EXECUTED
if (un[0] == '.' && unlen == 1) {
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
dn[0] = '.';
3b994: e5c23000 strb r3, [r2] <== NOT EXECUTED
dn[1] = '.';
return 0;
3b998: ea00003a b 3ba88 <msdos_filename_unix2dos+0x150> <== NOT EXECUTED
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
un++;
3b99c: e2800001 add r0, r0, #1 <== NOT EXECUTED
unlen--;
3b9a0: e2411001 sub r1, r1, #1 <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
3b9a4: e3510000 cmp r1, #0 <== NOT EXECUTED
3b9a8: 1a000002 bne 3b9b8 <msdos_filename_unix2dos+0x80> <== NOT EXECUTED
3b9ac: e3a03000 mov r3, #0 <== NOT EXECUTED
* 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++) {
if (msdos_map[c] == 0)
3b9b0: e59f50d8 ldr r5, [pc, #216] ; 3ba90 <msdos_filename_unix2dos+0x158><== NOT EXECUTED
3b9b4: ea000009 b 3b9e0 <msdos_filename_unix2dos+0xa8> <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
3b9b8: e5d03000 ldrb r3, [r0] <== NOT EXECUTED
3b9bc: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED
3b9c0: 0afffff5 beq 3b99c <msdos_filename_unix2dos+0x64> <== NOT EXECUTED
3b9c4: eafffff8 b 3b9ac <msdos_filename_unix2dos+0x74> <== NOT EXECUTED
* 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++) {
if (msdos_map[c] == 0)
3b9c8: e7d54004 ldrb r4, [r5, r4] <== NOT EXECUTED
3b9cc: e3540000 cmp r4, #0 <== NOT EXECUTED
3b9d0: 0a000013 beq 3ba24 <msdos_filename_unix2dos+0xec> <== NOT EXECUTED
break;
dn[i] = msdos_map[c];
3b9d4: e7c24003 strb r4, [r2, r3] <== NOT EXECUTED
un++;
unlen--;
3b9d8: e2411001 sub r1, r1, #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++) {
3b9dc: e2833001 add r3, r3, #1 <== NOT EXECUTED
3b9e0: e251c000 subs ip, r1, #0 <== NOT EXECUTED
3b9e4: 13a0c001 movne ip, #1 <== NOT EXECUTED
3b9e8: e3530007 cmp r3, #7 <== NOT EXECUTED
3b9ec: c3a0c000 movgt ip, #0 <== NOT EXECUTED
3b9f0: e35c0000 cmp ip, #0 <== NOT EXECUTED
/*
* 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)
3b9f4: e080c003 add ip, r0, 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++) {
3b9f8: 0a000009 beq 3ba24 <msdos_filename_unix2dos+0xec> <== NOT EXECUTED
3b9fc: e7d04003 ldrb r4, [r0, r3] <== NOT EXECUTED
3ba00: e3540000 cmp r4, #0 <== NOT EXECUTED
3ba04: 0a000006 beq 3ba24 <msdos_filename_unix2dos+0xec> <== NOT EXECUTED
3ba08: e354002e cmp r4, #46 ; 0x2e <== NOT EXECUTED
3ba0c: 1affffed bne 3b9c8 <msdos_filename_unix2dos+0x90> <== NOT EXECUTED
3ba10: ea000003 b 3ba24 <msdos_filename_unix2dos+0xec> <== NOT EXECUTED
*/
while (unlen && (c = *un)) {
un++;
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
3ba14: 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++;
3ba18: e28cc001 add ip, ip, #1 <== NOT EXECUTED
unlen--;
3ba1c: e2411001 sub r1, r1, #1 <== NOT EXECUTED
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
3ba20: 0a000004 beq 3ba38 <msdos_filename_unix2dos+0x100> <== NOT EXECUTED
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
3ba24: e3510000 cmp r1, #0 <== NOT EXECUTED
3ba28: 0a000002 beq 3ba38 <msdos_filename_unix2dos+0x100> <== NOT EXECUTED
3ba2c: e5dc3000 ldrb r3, [ip] <== NOT EXECUTED
3ba30: e3530000 cmp r3, #0 <== NOT EXECUTED
3ba34: 1afffff6 bne 3ba14 <msdos_filename_unix2dos+0xdc> <== NOT EXECUTED
3ba38: e3a00000 mov r0, #0 <== NOT EXECUTED
3ba3c: e3a03008 mov r3, #8 <== 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++) {
if (msdos_map[c] == 0)
3ba40: e59f5048 ldr r5, [pc, #72] ; 3ba90 <msdos_filename_unix2dos+0x158><== NOT EXECUTED
3ba44: ea000006 b 3ba64 <msdos_filename_unix2dos+0x12c> <== NOT EXECUTED
3ba48: e7d54004 ldrb r4, [r5, r4] <== NOT EXECUTED
3ba4c: e3540000 cmp r4, #0 <== NOT EXECUTED
3ba50: e2800001 add r0, r0, #1 <== NOT EXECUTED
3ba54: 0a00000b beq 3ba88 <msdos_filename_unix2dos+0x150> <== NOT EXECUTED
break;
dn[i] = msdos_map[c];
3ba58: e7c24003 strb r4, [r2, r3] <== NOT EXECUTED
un++;
unlen--;
3ba5c: e2411001 sub r1, r1, #1 <== 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++) {
3ba60: e2833001 add r3, r3, #1 <== NOT EXECUTED
3ba64: e2514000 subs r4, r1, #0 <== NOT EXECUTED
3ba68: 13a04001 movne r4, #1 <== NOT EXECUTED
3ba6c: e353000a cmp r3, #10 <== NOT EXECUTED
3ba70: c3a04000 movgt r4, #0 <== NOT EXECUTED
3ba74: e3540000 cmp r4, #0 <== NOT EXECUTED
3ba78: 0a000002 beq 3ba88 <msdos_filename_unix2dos+0x150> <== NOT EXECUTED
3ba7c: e7dc4000 ldrb r4, [ip, r0] <== NOT EXECUTED
3ba80: e3540000 cmp r4, #0 <== NOT EXECUTED
3ba84: 1affffef bne 3ba48 <msdos_filename_unix2dos+0x110> <== NOT EXECUTED
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
3ba88: e3a00000 mov r0, #0 <== NOT EXECUTED
3ba8c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00033224 <msdos_find_name>:
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
33224: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
33228: e24dd040 sub sp, sp, #64 ; 0x40 <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
3322c: e3a06000 mov r6, #0 <== NOT EXECUTED
const char *name,
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
33230: 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);
33234: e28d500c add r5, sp, #12 <== NOT EXECUTED
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
33238: e1a07001 mov r7, r1 <== NOT EXECUTED
3323c: e1a08002 mov r8, r2 <== 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);
33240: e1a01006 mov r1, r6 <== NOT EXECUTED
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
33244: e1a04000 mov r4, r0 <== 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);
33248: e3a02020 mov r2, #32 <== NOT EXECUTED
3324c: e1a00005 mov r0, r5 <== NOT EXECUTED
const char *name,
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
33250: e593a034 ldr sl, [r3, #52] ; 0x34 <== NOT EXECUTED
fat_file_fd_t *fat_fd = NULL;
33254: e58d603c str r6, [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);
33258: eb00345f bl 403dc <memset> <== NOT EXECUTED
name_type = msdos_long_to_short (name,
3325c: e1a00007 mov r0, r7 <== NOT EXECUTED
33260: e1a01008 mov r1, r8 <== NOT EXECUTED
33264: e1a02005 mov r2, r5 <== NOT EXECUTED
33268: e3a0300b mov r3, #11 <== NOT EXECUTED
3326c: ebfffecb bl 32da0 <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,
33270: e1a01006 mov r1, r6 <== NOT EXECUTED
33274: e58d0000 str r0, [sp] <== NOT EXECUTED
33278: e1a02007 mov r2, r7 <== NOT EXECUTED
3327c: e1a03008 mov r3, r8 <== NOT EXECUTED
33280: e28d602c add r6, sp, #44 ; 0x2c <== NOT EXECUTED
33284: e1a00004 mov r0, r4 <== NOT EXECUTED
33288: e58d6004 str r6, [sp, #4] <== NOT EXECUTED
3328c: e58d5008 str r5, [sp, #8] <== NOT EXECUTED
33290: ebffffac bl 33148 <msdos_get_name_node> <== NOT EXECUTED
&dir_pos, node_entry);
if (rc != RC_OK)
33294: e2507000 subs r7, r0, #0 <== NOT EXECUTED
33298: 1a000045 bne 333b4 <msdos_find_name+0x190> <== NOT EXECUTED
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
3329c: e5dd3017 ldrb r3, [sp, #23] <== NOT EXECUTED
332a0: e3130008 tst r3, #8 <== NOT EXECUTED
332a4: 1a000041 bne 333b0 <msdos_find_name+0x18c> <== NOT EXECUTED
332a8: e203303f and r3, r3, #63 ; 0x3f <== NOT EXECUTED
332ac: e353000f cmp r3, #15 <== NOT EXECUTED
332b0: 0a00003e beq 333b0 <msdos_find_name+0x18c> <== 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);
332b4: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
332b8: e1a01006 mov r1, r6 <== NOT EXECUTED
332bc: e28d203c add r2, sp, #60 ; 0x3c <== NOT EXECUTED
332c0: ebffbc25 bl 2235c <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
332c4: e2507000 subs r7, r0, #0 <== NOT EXECUTED
332c8: 1a000039 bne 333b4 <msdos_find_name+0x190> <== NOT EXECUTED
return rc;
fat_fd->dir_pos = dir_pos;
332cc: 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)
332d0: 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;
332d4: e896000f ldm r6, {r0, r1, r2, r3} <== NOT EXECUTED
332d8: 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)
332dc: 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;
332e0: 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)
332e4: 1a000026 bne 33384 <msdos_find_name+0x160> <== NOT EXECUTED
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
332e8: e1d521b4 ldrh r2, [r5, #20] <== NOT EXECUTED
332ec: e1d531ba ldrh r3, [r5, #26] <== NOT EXECUTED
332f0: e1833802 orr r3, r3, r2, lsl #16 <== NOT EXECUTED
332f4: 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));
332f8: e1d511b6 ldrh r1, [r5, #22] <== NOT EXECUTED
332fc: e1d501b8 ldrh r0, [r5, #24] <== NOT EXECUTED
33300: eb00214a bl 3b830 <msdos_date_dos2unix> <== NOT EXECUTED
33304: e5870040 str r0, [r7, #64] ; 0x40 <== NOT EXECUTED
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
33308: e5dd3017 ldrb r3, [sp, #23] <== NOT EXECUTED
3330c: e3130010 tst r3, #16 <== NOT EXECUTED
33310: e59d103c ldr r1, [sp, #60] ; 0x3c <== NOT EXECUTED
33314: 0a000007 beq 33338 <msdos_find_name+0x114> <== NOT EXECUTED
{
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
33318: e3a03602 mov r3, #2097152 ; 0x200000 <== 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;
3331c: e5818010 str r8, [r1, #16] <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
33320: e5813014 str r3, [r1, #20] <== NOT EXECUTED
rc = fat_file_size(parent_loc->mt_entry, fat_fd);
33324: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
33328: ebffb95a bl 21898 <fat_file_size> <== NOT EXECUTED
if (rc != RC_OK)
3332c: e2507000 subs r7, r0, #0 <== NOT EXECUTED
33330: 0a000006 beq 33350 <msdos_find_name+0x12c> <== NOT EXECUTED
33334: ea000019 b 333a0 <msdos_find_name+0x17c> <== NOT EXECUTED
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
33338: e595301c ldr r3, [r5, #28] <== NOT EXECUTED
fat_fd->fat_file_type = FAT_FILE;
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
3333c: e3e02000 mvn r2, #0 <== NOT EXECUTED
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
33340: e5813018 str r3, [r1, #24] <== NOT EXECUTED
fat_fd->fat_file_type = FAT_FILE;
33344: e3a03005 mov r3, #5 <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
33348: e5812014 str r2, [r1, #20] <== NOT EXECUTED
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
fat_fd->fat_file_type = FAT_FILE;
3334c: e5813010 str r3, [r1, #16] <== 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;
33350: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
33354: e2831018 add r1, r3, #24 <== NOT EXECUTED
33358: e8910006 ldm r1, {r1, r2} <== 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;
3335c: e3a00000 mov r0, #0 <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
33360: e3510000 cmp r1, #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;
33364: e5830034 str r0, [r3, #52] ; 0x34 <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
33368: e5832038 str r2, [r3, #56] ; 0x38 <== NOT EXECUTED
if ((fat_fd->fat_file_size != 0) &&
3336c: 0a000002 beq 3337c <msdos_find_name+0x158> <== NOT EXECUTED
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
33370: e1da00b6 ldrh r0, [sl, #6] <== NOT EXECUTED
33374: e1510000 cmp r1, r0 <== NOT EXECUTED
33378: 9a000000 bls 33380 <msdos_find_name+0x15c> <== NOT EXECUTED
{
fat_fd->map.last_cln = fat_fd->cln;
}
else
{
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
3337c: e3e02000 mvn r2, #0 <== NOT EXECUTED
33380: e583203c str r2, [r3, #60] ; 0x3c <== NOT EXECUTED
}
}
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(parent_loc->mt_entry, parent_loc->node_access);
33384: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
33388: e5941000 ldr r1, [r4] <== NOT EXECUTED
3338c: ebffbbc9 bl 222b8 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
33390: e2507000 subs r7, r0, #0 <== NOT EXECUTED
fat_file_close(parent_loc->mt_entry, fat_fd);
return rc;
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
33394: 059d303c ldreq r3, [sp, #60] ; 0x3c <== NOT EXECUTED
33398: 05843000 streq r3, [r4] <== 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)
3339c: 0a000004 beq 333b4 <msdos_find_name+0x190> <== NOT EXECUTED
{
fat_file_close(parent_loc->mt_entry, fat_fd);
333a0: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
333a4: e59d103c ldr r1, [sp, #60] ; 0x3c <== NOT EXECUTED
333a8: ebffbbc2 bl 222b8 <fat_file_close> <== NOT EXECUTED
return rc;
333ac: ea000000 b 333b4 <msdos_find_name+0x190> <== NOT EXECUTED
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
return rc;
333b0: e59f7008 ldr r7, [pc, #8] ; 333c0 <msdos_find_name+0x19c> <== NOT EXECUTED
}
333b4: e1a00007 mov r0, r7 <== NOT EXECUTED
333b8: e28dd040 add sp, sp, #64 ; 0x40 <== NOT EXECUTED
333bc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
00031f4c <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
)
{
31f4c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
31f50: e24dd050 sub sp, sp, #80 ; 0x50 <== NOT EXECUTED
31f54: e58d001c str r0, [sp, #28] <== 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);
31f58: e59d0074 ldr r0, [sp, #116] ; 0x74 <== NOT EXECUTED
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
31f5c: e1a05001 mov r5, r1 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
31f60: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
31f64: 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);
31f68: 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
)
{
31f6c: e58d3038 str r3, [sp, #56] ; 0x38 <== NOT EXECUTED
31f70: e58d2024 str r2, [sp, #36] ; 0x24 <== NOT EXECUTED
31f74: e59d807c ldr r8, [sp, #124] ; 0x7c <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
31f78: e5917034 ldr r7, [r1, #52] ; 0x34 <== 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);
31f7c: d59f0874 ldrle r0, [pc, #2164] ; 327f8 <msdos_find_name_in_fat_file+0x8ac><== NOT EXECUTED
31f80: d59f1874 ldrle r1, [pc, #2164] ; 327fc <msdos_find_name_in_fat_file+0x8b0><== NOT EXECUTED
31f84: d59f2874 ldrle r2, [pc, #2164] ; 32800 <msdos_find_name_in_fat_file+0x8b4><== NOT EXECUTED
31f88: d59f3874 ldrle r3, [pc, #2164] ; 32804 <msdos_find_name_in_fat_file+0x8b8><== NOT EXECUTED
31f8c: da000034 ble 32064 <msdos_find_name_in_fat_file+0x118> <== 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))
31f90: e59d2024 ldr r2, [sp, #36] ; 0x24 <== NOT EXECUTED
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
31f94: e3a0a000 mov sl, #0 <== NOT EXECUTED
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
31f98: e3e03000 mvn r3, #0 <== NOT EXECUTED
31f9c: e3520000 cmp r2, #0 <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
31fa0: e588300c str r3, [r8, #12] <== NOT EXECUTED
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
31fa4: e588a000 str sl, [r8] <== NOT EXECUTED
dir_pos->sname.ofs = 0;
31fa8: e588a004 str sl, [r8, #4] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
31fac: e5883008 str r3, [r8, #8] <== NOT EXECUTED
31fb0: 0a000002 beq 31fc0 <msdos_find_name_in_fat_file+0x74> <== NOT EXECUTED
31fb4: e59d3078 ldr r3, [sp, #120] ; 0x78 <== NOT EXECUTED
31fb8: e3530001 cmp r3, #1 <== NOT EXECUTED
31fbc: 0a000004 beq 31fd4 <msdos_find_name_in_fat_file+0x88> <== NOT EXECUTED
lfn_entries = 0;
else
lfn_entries =
31fc0: e59dc074 ldr ip, [sp, #116] ; 0x74 <== NOT EXECUTED
31fc4: e3a0100d mov r1, #13 <== NOT EXECUTED
31fc8: e28c000c add r0, ip, #12 <== NOT EXECUTED
31fcc: eb008bcd bl 54f08 <__aeabi_idiv> <== NOT EXECUTED
31fd0: e1a0a000 mov sl, r0 <== NOT EXECUTED
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
31fd4: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED
31fd8: e3530001 cmp r3, #1 <== NOT EXECUTED
31fdc: 1a000006 bne 31ffc <msdos_find_name_in_fat_file+0xb0> <== NOT EXECUTED
31fe0: e5953024 ldr r3, [r5, #36] ; 0x24 <== NOT EXECUTED
31fe4: e3530000 cmp r3, #0 <== NOT EXECUTED
31fe8: 1a000003 bne 31ffc <msdos_find_name_in_fat_file+0xb0> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
31fec: e5d7300a ldrb r3, [r7, #10] <== NOT EXECUTED
31ff0: e3130003 tst r3, #3 <== NOT EXECUTED
bts2rd = fat_fd->fat_file_size;
31ff4: 15954018 ldrne r4, [r5, #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)))
31ff8: 1a000000 bne 32000 <msdos_find_name_in_fat_file+0xb4> <== NOT EXECUTED
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
31ffc: e1d740b6 ldrh r4, [r7, #6] <== NOT EXECUTED
assert(name_len > 0);
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
32000: e3a06000 mov r6, #0 <== NOT EXECUTED
32004: e3e03000 mvn r3, #0 <== NOT EXECUTED
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
32008: e28a0001 add r0, sl, #1 <== NOT EXECUTED
3200c: e58d8034 str r8, [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;
32010: e58d3048 str r3, [sp, #72] ; 0x48 <== NOT EXECUTED
32014: e58d3044 str r3, [sp, #68] ; 0x44 <== NOT EXECUTED
32018: e58d6010 str r6, [sp, #16] <== NOT EXECUTED
3201c: e1a09006 mov r9, r6 <== NOT EXECUTED
32020: e1a0b006 mov fp, r6 <== NOT EXECUTED
32024: e58d6020 str r6, [sp, #32] <== NOT EXECUTED
32028: e58d6014 str r6, [sp, #20] <== NOT EXECUTED
3202c: e58d602c str r6, [sp, #44] ; 0x2c <== NOT EXECUTED
32030: e58d6030 str r6, [sp, #48] ; 0x30 <== NOT EXECUTED
32034: e58d6018 str r6, [sp, #24] <== NOT EXECUTED
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
32038: e58d0040 str r0, [sp, #64] ; 0x40 <== NOT EXECUTED
3203c: e1a08005 mov r8, r5 <== 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),
32040: ea0000de b 323c0 <msdos_find_name_in_fat_file+0x474> <== 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)
32044: e350001f cmp r0, #31 <== NOT EXECUTED
32048: da0001d6 ble 327a8 <msdos_find_name_in_fat_file+0x85c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
3204c: e1500004 cmp r0, r4 <== NOT EXECUTED
32050: 0a000004 beq 32068 <msdos_find_name_in_fat_file+0x11c> <== NOT EXECUTED
32054: e59f079c ldr r0, [pc, #1948] ; 327f8 <msdos_find_name_in_fat_file+0x8ac><== NOT EXECUTED
32058: e59f17a8 ldr r1, [pc, #1960] ; 32808 <msdos_find_name_in_fat_file+0x8bc><== NOT EXECUTED
3205c: e59f279c ldr r2, [pc, #1948] ; 32800 <msdos_find_name_in_fat_file+0x8b4><== NOT EXECUTED
32060: e59f37a4 ldr r3, [pc, #1956] ; 3280c <msdos_find_name_in_fat_file+0x8c0><== NOT EXECUTED
32064: ebffcaf2 bl 24c34 <__assert_func> <== NOT EXECUTED
32068: e59d1030 ldr r1, [sp, #48] ; 0x30 <== NOT EXECUTED
3206c: e1a0c006 mov ip, r6 <== NOT EXECUTED
32070: e3a05000 mov r5, #0 <== NOT EXECUTED
32074: e1a06004 mov r6, r4 <== NOT EXECUTED
/* 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)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
32078: e5974098 ldr r4, [r7, #152] ; 0x98 <== 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)
3207c: e59d2020 ldr r2, [sp, #32] <== 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) ==
32080: e7d43005 ldrb r3, [r4, 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)
32084: e59d0018 ldr r0, [sp, #24] <== NOT EXECUTED
32088: e3590000 cmp r9, #0 <== NOT EXECUTED
3208c: 01a02000 moveq r2, r0 <== NOT EXECUTED
32090: 01a0b005 moveq fp, r5 <== NOT EXECUTED
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
32094: e3530000 cmp r3, #0 <== 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)
32098: e58d2020 str r2, [sp, #32] <== NOT EXECUTED
/* 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)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
3209c: e0844005 add r4, r4, r5 <== NOT EXECUTED
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
320a0: 1a00000b bne 320d4 <msdos_find_name_in_fat_file+0x188> <== NOT EXECUTED
#endif
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
320a4: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED
320a8: e3510000 cmp r1, #0 <== NOT EXECUTED
320ac: e1a0c005 mov ip, r5 <== NOT EXECUTED
320b0: e1a04006 mov r4, r6 <== NOT EXECUTED
320b4: e1a05008 mov r5, r8 <== NOT EXECUTED
320b8: e59d8034 ldr r8, [sp, #52] ; 0x34 <== NOT EXECUTED
320bc: 0a0001c8 beq 327e4 <msdos_find_name_in_fat_file+0x898> <== 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)
320c0: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED
320c4: e3520000 cmp r2, #0 <== NOT EXECUTED
{
empty_space_count +=
entries_per_block - (dir_entry / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
320c8: 008992a6 addeq r9, r9, r6, 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 +=
320cc: 004992ac subeq r9, r9, ip, lsr #5 <== NOT EXECUTED
320d0: ea0000c8 b 323f8 <msdos_find_name_in_fat_file+0x4ac> <== NOT EXECUTED
printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif
}
break;
}
else if (entry_empty)
320d4: e35300e5 cmp r3, #229 ; 0xe5 <== NOT EXECUTED
320d8: 1a000009 bne 32104 <msdos_find_name_in_fat_file+0x1b8> <== NOT EXECUTED
{
if (create_node)
320dc: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
320e0: e3530000 cmp r3, #0 <== NOT EXECUTED
320e4: 0a0000ac beq 3239c <msdos_find_name_in_fat_file+0x450> <== NOT EXECUTED
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
320e8: e59d2040 ldr r2, [sp, #64] ; 0x40 <== NOT EXECUTED
if (create_node)
{
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
320ec: e2899001 add r9, r9, #1 <== NOT EXECUTED
if (empty_space_count == (lfn_entries + 1))
320f0: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED
320f4: e1590002 cmp r9, r2 <== NOT EXECUTED
320f8: 03a00001 moveq r0, #1 <== NOT EXECUTED
320fc: e58d0010 str r0, [sp, #16] <== NOT EXECUTED
32100: ea0000a5 b 3239c <msdos_find_name_in_fat_file+0x450> <== 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)
32104: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED
32108: e3500000 cmp r0, #0 <== NOT EXECUTED
3210c: 0a000003 beq 32120 <msdos_find_name_in_fat_file+0x1d4> <== NOT EXECUTED
32110: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED
32114: e3520000 cmp r2, #0 <== NOT EXECUTED
32118: 01a0b002 moveq fp, r2 <== NOT EXECUTED
3211c: 01a09002 moveq r9, r2 <== 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) ==
32120: e5d4200b ldrb r2, [r4, #11] <== NOT EXECUTED
32124: e202203f and r2, r2, #63 ; 0x3f <== NOT EXECUTED
32128: e352000f cmp r2, #15 <== NOT EXECUTED
3212c: 1a000051 bne 32278 <msdos_find_name_in_fat_file+0x32c> <== 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)
32130: e59d2044 ldr r2, [sp, #68] ; 0x44 <== NOT EXECUTED
32134: e3720001 cmn r2, #1 <== NOT EXECUTED
32138: 1a00000b bne 3216c <msdos_find_name_in_fat_file+0x220> <== NOT EXECUTED
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
3213c: e3130040 tst r3, #64 ; 0x40 <== NOT EXECUTED
32140: 0a000094 beq 32398 <msdos_find_name_in_fat_file+0x44c> <== 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) &
32144: e203303f and r3, r3, #63 ; 0x3f <== NOT EXECUTED
32148: e15a0003 cmp sl, r3 <== NOT EXECUTED
3214c: 1a000091 bne 32398 <msdos_find_name_in_fat_file+0x44c> <== NOT EXECUTED
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
32150: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
lfn_start.ofs = dir_entry;
32154: e58d5048 str r5, [sp, #72] ; 0x48 <== NOT EXECUTED
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
32158: e58d3044 str r3, [sp, #68] ; 0x44 <== NOT EXECUTED
lfn_start.ofs = dir_entry;
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
3215c: e5d4000d ldrb r0, [r4, #13] <== NOT EXECUTED
32160: e58da014 str sl, [sp, #20] <== NOT EXECUTED
32164: e58d002c str r0, [sp, #44] ; 0x2c <== NOT EXECUTED
32168: e3a01000 mov r1, #0 <== 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) &
3216c: e5d43000 ldrb r3, [r4] <== NOT EXECUTED
32170: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED
32174: e203303f and r3, r3, #63 ; 0x3f <== NOT EXECUTED
32178: e1520003 cmp r2, r3 <== NOT EXECUTED
3217c: 1a000003 bne 32190 <msdos_find_name_in_fat_file+0x244> <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
32180: e5d4300d ldrb r3, [r4, #13] <== NOT EXECUTED
32184: e59d002c ldr r0, [sp, #44] ; 0x2c <== NOT EXECUTED
32188: e1530000 cmp r3, r0 <== NOT EXECUTED
3218c: 0a000002 beq 3219c <msdos_find_name_in_fat_file+0x250> <== NOT EXECUTED
{
#if MSDOS_FIND_PRINT
printf ("MSFS:[4.4] no match\n");
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
32190: e3e02000 mvn r2, #0 <== NOT EXECUTED
32194: e58d2044 str r2, [sp, #68] ; 0x44 <== NOT EXECUTED
continue;
32198: ea00007f b 3239c <msdos_find_name_in_fat_file+0x450> <== NOT EXECUTED
}
lfn_entry--;
3219c: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
321a0: e3a0100d mov r1, #13 <== NOT EXECUTED
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
321a4: e2432001 sub r2, r3, #1 <== NOT EXECUTED
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
321a8: e0010192 mul r1, r2, r1 <== NOT EXECUTED
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
321ac: e59d0038 ldr r0, [sp, #56] ; 0x38 <== NOT EXECUTED
321b0: e0800001 add r0, r0, r1 <== NOT EXECUTED
321b4: e58d003c str r0, [sp, #60] ; 0x3c <== NOT EXECUTED
321b8: e58d1004 str r1, [sp, #4] <== NOT EXECUTED
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
p = entry + 1;
321bc: e2844001 add r4, r4, #1 <== NOT EXECUTED
321c0: e3a03000 mov r3, #0 <== 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')
321c4: e5d41000 ldrb r1, [r4] <== NOT EXECUTED
321c8: e3510000 cmp r1, #0 <== NOT EXECUTED
321cc: e58d1030 str r1, [sp, #48] ; 0x30 <== NOT EXECUTED
321d0: 1a000008 bne 321f8 <msdos_find_name_in_fat_file+0x2ac> <== 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) &&
321d4: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED
321d8: e150000a cmp r0, sl <== NOT EXECUTED
321dc: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
321e0: 1a00001b bne 32254 <msdos_find_name_in_fat_file+0x308> <== NOT EXECUTED
321e4: e0833001 add r3, r3, r1 <== NOT EXECUTED
321e8: e59d1074 ldr r1, [sp, #116] ; 0x74 <== NOT EXECUTED
321ec: e1530001 cmp r3, r1 <== NOT EXECUTED
321f0: 1a00000b bne 32224 <msdos_find_name_in_fat_file+0x2d8> <== NOT EXECUTED
321f4: ea000016 b 32254 <msdos_find_name_in_fat_file+0x308> <== NOT EXECUTED
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
321f8: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
321fc: e59d1074 ldr r1, [sp, #116] ; 0x74 <== NOT EXECUTED
32200: e0830000 add r0, r3, r0 <== NOT EXECUTED
32204: e1500001 cmp r0, r1 <== NOT EXECUTED
32208: e58d0028 str r0, [sp, #40] ; 0x28 <== NOT EXECUTED
3220c: aa000004 bge 32224 <msdos_find_name_in_fat_file+0x2d8> <== NOT EXECUTED
32210: e59d003c ldr r0, [sp, #60] ; 0x3c <== NOT EXECUTED
32214: e59d1030 ldr r1, [sp, #48] ; 0x30 <== NOT EXECUTED
32218: e7d00003 ldrb r0, [r0, r3] <== NOT EXECUTED
3221c: e1500001 cmp r0, r1 <== NOT EXECUTED
32220: 0a000002 beq 32230 <msdos_find_name_in_fat_file+0x2e4> <== NOT EXECUTED
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
32224: e3e03000 mvn r3, #0 <== NOT EXECUTED
32228: e58d3044 str r3, [sp, #68] ; 0x44 <== NOT EXECUTED
break;
3222c: ea000008 b 32254 <msdos_find_name_in_fat_file+0x308> <== NOT EXECUTED
}
switch (i)
32230: e3530004 cmp r3, #4 <== NOT EXECUTED
{
case 4:
p += 5;
32234: 02844005 addeq r4, r4, #5 <== NOT EXECUTED
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
switch (i)
32238: 0a000002 beq 32248 <msdos_find_name_in_fat_file+0x2fc> <== NOT EXECUTED
3223c: e353000a cmp r3, #10 <== NOT EXECUTED
break;
case 10:
p += 4;
break;
default:
p += 2;
32240: 12844002 addne r4, r4, #2 <== NOT EXECUTED
{
case 4:
p += 5;
break;
case 10:
p += 4;
32244: 02844004 addeq r4, r4, #4 <== 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++)
32248: e2833001 add r3, r3, #1 <== NOT EXECUTED
3224c: e353000d cmp r3, #13 <== NOT EXECUTED
32250: 1affffdb bne 321c4 <msdos_find_name_in_fat_file+0x278> <== NOT EXECUTED
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
32254: e3520000 cmp r2, #0 <== NOT EXECUTED
32258: 13a01000 movne r1, #0 <== NOT EXECUTED
3225c: 1a000002 bne 3226c <msdos_find_name_in_fat_file+0x320> <== NOT EXECUTED
32260: e59d1044 ldr r1, [sp, #68] ; 0x44 <== NOT EXECUTED
32264: e2911001 adds r1, r1, #1 <== NOT EXECUTED
32268: 13a01001 movne r1, #1 <== NOT EXECUTED
3226c: e20110ff and r1, r1, #255 ; 0xff <== NOT EXECUTED
32270: e58d2014 str r2, [sp, #20] <== NOT EXECUTED
32274: ea000048 b 3239c <msdos_find_name_in_fat_file+0x450> <== 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)
32278: e3510000 cmp r1, #0 <== NOT EXECUTED
3227c: 0a00000f beq 322c0 <msdos_find_name_in_fat_file+0x374> <== NOT EXECUTED
32280: e3a02000 mov r2, #0 <== NOT EXECUTED
32284: e1a03002 mov r3, r2 <== 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;
32288: e7d40002 ldrb r0, [r4, r2] <== NOT EXECUTED
3228c: e2131001 ands r1, r3, #1 <== NOT EXECUTED
32290: 13a01080 movne r1, #128 ; 0x80 <== NOT EXECUTED
32294: e08030a3 add r3, r0, r3, 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++)
32298: e2822001 add r2, r2, #1 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
3229c: e0833001 add r3, r3, r1 <== 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++)
322a0: e352000b cmp r2, #11 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
322a4: e20330ff and r3, r3, #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++)
322a8: 1afffff6 bne 32288 <msdos_find_name_in_fat_file+0x33c> <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entry || (lfn_checksum != cs))
322ac: e59d002c ldr r0, [sp, #44] ; 0x2c <== NOT EXECUTED
322b0: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED
322b4: e3510000 cmp r1, #0 <== NOT EXECUTED
322b8: 01500003 cmpeq r0, r3 <== NOT EXECUTED
322bc: 0a00000d beq 322f8 <msdos_find_name_in_fat_file+0x3ac> <== 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 ||
322c0: e59d2078 ldr r2, [sp, #120] ; 0x78 <== NOT EXECUTED
322c4: e3520001 cmp r2, #1 <== NOT EXECUTED
322c8: 1a000030 bne 32390 <msdos_find_name_in_fat_file+0x444> <== NOT EXECUTED
322cc: e59d3044 ldr r3, [sp, #68] ; 0x44 <== NOT EXECUTED
322d0: e3730001 cmn r3, #1 <== NOT EXECUTED
322d4: 1a00002d bne 32390 <msdos_find_name_in_fat_file+0x444> <== NOT EXECUTED
((name_type == MSDOS_NAME_SHORT) &&
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
(memcmp(MSDOS_DIR_NAME(entry),
322d8: e1a00004 mov r0, r4 <== NOT EXECUTED
322dc: e59d1080 ldr r1, [sp, #128] ; 0x80 <== NOT EXECUTED
322e0: e282200a add r2, r2, #10 <== NOT EXECUTED
322e4: e58dc008 str ip, [sp, #8] <== NOT EXECUTED
322e8: eb00378a bl 40118 <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 ||
322ec: e3500000 cmp r0, #0 <== NOT EXECUTED
322f0: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED
322f4: 1a000025 bne 32390 <msdos_find_name_in_fat_file+0x444> <== NOT EXECUTED
322f8: e1a07004 mov r7, r4 <== NOT EXECUTED
322fc: e1a04006 mov r4, r6 <== NOT EXECUTED
32300: e1a0600c mov r6, ip <== NOT EXECUTED
32304: e1a0c005 mov ip, r5 <== NOT EXECUTED
32308: e1a05008 mov r5, r8 <== NOT EXECUTED
3230c: e59d8034 ldr r8, [sp, #52] ; 0x34 <== 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,
32310: e1a03006 mov r3, r6 <== NOT EXECUTED
32314: e59d001c ldr r0, [sp, #28] <== NOT EXECUTED
32318: e1a01005 mov r1, r5 <== NOT EXECUTED
3231c: e3a02001 mov r2, #1 <== NOT EXECUTED
32320: e58dc008 str ip, [sp, #8] <== NOT EXECUTED
32324: e58d8000 str r8, [sp] <== NOT EXECUTED
32328: ebffbdfb bl 21b1c <fat_file_ioctl> <== NOT EXECUTED
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
3232c: e3500000 cmp r0, #0 <== NOT EXECUTED
32330: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED
32334: 1a00012d bne 327f0 <msdos_find_name_in_fat_file+0x8a4> <== NOT EXECUTED
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
32338: e59d3044 ldr r3, [sp, #68] ; 0x44 <== NOT EXECUTED
3233c: 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;
32340: e588c004 str ip, [r8, #4] <== NOT EXECUTED
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
32344: 0a000008 beq 3236c <msdos_find_name_in_fat_file+0x420> <== NOT EXECUTED
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
32348: e28dc044 add ip, sp, #68 ; 0x44 <== NOT EXECUTED
3234c: e0030394 mul r3, r4, r3 <== NOT EXECUTED
32350: e59d001c ldr r0, [sp, #28] <== NOT EXECUTED
32354: e1a01005 mov r1, r5 <== NOT EXECUTED
32358: e3a02001 mov r2, #1 <== NOT EXECUTED
3235c: e58dc000 str ip, [sp] <== NOT EXECUTED
32360: ebffbded bl 21b1c <fat_file_ioctl> <== NOT EXECUTED
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
32364: e3500000 cmp r0, #0 <== NOT EXECUTED
32368: 1a000120 bne 327f0 <msdos_find_name_in_fat_file+0x8a4> <== NOT EXECUTED
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
3236c: e59d3048 ldr r3, [sp, #72] ; 0x48 <== NOT EXECUTED
32370: e588300c str r3, [r8, #12] <== NOT EXECUTED
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
32374: e59d3044 ldr r3, [sp, #68] ; 0x44 <== NOT EXECUTED
dir_pos->lname.ofs = lfn_start.ofs;
memcpy(name_dir_entry, entry,
32378: e59d0080 ldr r0, [sp, #128] ; 0x80 <== NOT EXECUTED
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
3237c: e5883008 str r3, [r8, #8] <== NOT EXECUTED
dir_pos->lname.ofs = lfn_start.ofs;
memcpy(name_dir_entry, entry,
32380: e1a01007 mov r1, r7 <== NOT EXECUTED
32384: e3a02020 mov r2, #32 <== NOT EXECUTED
32388: eb00378c bl 401c0 <memcpy> <== NOT EXECUTED
3238c: ea000112 b 327dc <msdos_find_name_in_fat_file+0x890> <== NOT EXECUTED
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
32390: e3e03000 mvn r3, #0 <== NOT EXECUTED
32394: e58d3044 str r3, [sp, #68] ; 0x44 <== NOT EXECUTED
32398: 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)
3239c: 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;
323a0: e1550006 cmp r5, r6 <== NOT EXECUTED
323a4: 3affff33 bcc 32078 <msdos_find_name_in_fat_file+0x12c> <== NOT EXECUTED
323a8: e1a04006 mov r4, r6 <== NOT EXECUTED
323ac: e08c6004 add r6, ip, r4 <== NOT EXECUTED
}
if (remainder_empty)
break;
dir_offset++;
323b0: e59dc018 ldr ip, [sp, #24] <== NOT EXECUTED
323b4: e28cc001 add ip, ip, #1 <== NOT EXECUTED
323b8: e58d1030 str r1, [sp, #48] ; 0x30 <== NOT EXECUTED
323bc: e58dc018 str ip, [sp, #24] <== 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),
323c0: e597c098 ldr ip, [r7, #152] ; 0x98 <== NOT EXECUTED
323c4: e59d001c ldr r0, [sp, #28] <== NOT EXECUTED
323c8: e1a01008 mov r1, r8 <== NOT EXECUTED
323cc: e1a02006 mov r2, r6 <== NOT EXECUTED
323d0: e1a03004 mov r3, r4 <== NOT EXECUTED
323d4: e58dc000 str ip, [sp] <== NOT EXECUTED
323d8: ebffbf3c bl 220d0 <fat_file_read> <== NOT EXECUTED
323dc: e3500000 cmp r0, #0 <== NOT EXECUTED
323e0: 1affff17 bne 32044 <msdos_find_name_in_fat_file+0xf8> <== NOT EXECUTED
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
323e4: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED
323e8: e3500000 cmp r0, #0 <== NOT EXECUTED
323ec: e1a05008 mov r5, r8 <== NOT EXECUTED
323f0: e59d8034 ldr r8, [sp, #52] ; 0x34 <== NOT EXECUTED
323f4: 0a0000fa beq 327e4 <msdos_find_name_in_fat_file+0x898> <== 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)
323f8: e59d1078 ldr r1, [sp, #120] ; 0x78 <== NOT EXECUTED
323fc: e3510002 cmp r1, #2 <== NOT EXECUTED
32400: 1a00001c bne 32478 <msdos_find_name_in_fat_file+0x52c> <== NOT EXECUTED
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
32404: e59d0020 ldr r0, [sp, #32] <== NOT EXECUTED
32408: e020b094 mla r0, r4, r0, fp <== NOT EXECUTED
3240c: e28a3001 add r3, sl, #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 = '~';
32410: e59dc080 ldr ip, [sp, #128] ; 0x80 <== 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;
32414: e08302a0 add r0, r3, r0, 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 = '~';
32418: 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;
3241c: 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 == '.'))
32420: e7dc2003 ldrb r2, [ip, r3] <== NOT EXECUTED
32424: e3520020 cmp r2, #32 <== NOT EXECUTED
32428: 1352002e cmpne r2, #46 ; 0x2e <== NOT EXECUTED
*c = '~';
3242c: 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++)
32430: e2833001 add r3, r3, #1 <== NOT EXECUTED
32434: e3530003 cmp r3, #3 <== NOT EXECUTED
32438: 1afffff8 bne 32420 <msdos_find_name_in_fat_file+0x4d4> <== NOT EXECUTED
if ((*c == ' ') || (*c == '.'))
*c = '~';
*c++ = '~';
3243c: e59d2080 ldr r2, [sp, #128] ; 0x80 <== NOT EXECUTED
32440: e283307b add r3, r3, #123 ; 0x7b <== NOT EXECUTED
32444: e5c23003 strb r3, [r2, #3] <== NOT EXECUTED
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
32448: e59f33c0 ldr r3, [pc, #960] ; 32810 <msdos_find_name_in_fat_file+0x8c4><== NOT EXECUTED
3244c: e59d2080 ldr r2, [sp, #128] ; 0x80 <== NOT EXECUTED
32450: e593c048 ldr ip, [r3, #72] ; 0x48 <== NOT EXECUTED
32454: e3a0300c mov r3, #12 <== NOT EXECUTED
32458: e1a01350 asr r1, r0, r3 <== NOT EXECUTED
3245c: e201100f and r1, r1, #15 <== NOT EXECUTED
32460: e7dc1001 ldrb r1, [ip, r1] <== NOT EXECUTED
32464: 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++)
32468: e3730004 cmn r3, #4 <== NOT EXECUTED
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
3246c: e5c21004 strb r1, [r2, #4] <== NOT EXECUTED
32470: e2822001 add r2, r2, #1 <== NOT EXECUTED
int i;
for (i = 0; i < 3; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '~';
*c++ = '~';
for (i = 0; i < 4; i++, c++)
32474: 1afffff7 bne 32458 <msdos_find_name_in_fat_file+0x50c> <== 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)
32478: e35a0000 cmp sl, #0 <== NOT EXECUTED
3247c: 058da014 streq sl, [sp, #20] <== NOT EXECUTED
32480: 0a00000d beq 324bc <msdos_find_name_in_fat_file+0x570> <== NOT EXECUTED
32484: e3a03000 mov r3, #0 <== NOT EXECUTED
32488: e58d3014 str r3, [sp, #20] <== NOT EXECUTED
3248c: e1a02003 mov r2, r3 <== NOT EXECUTED
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
32490: e59dc080 ldr ip, [sp, #128] ; 0x80 <== NOT EXECUTED
32494: e7dc0003 ldrb r0, [ip, r3] <== NOT EXECUTED
32498: e2121001 ands r1, r2, #1 <== NOT EXECUTED
3249c: 13a01080 movne r1, #128 ; 0x80 <== NOT EXECUTED
324a0: e08020a2 add r2, r0, r2, lsr #1 <== 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++)
324a4: e2833001 add r3, r3, #1 <== NOT EXECUTED
lfn_checksum =
324a8: e0822001 add r2, r2, r1 <== 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++)
324ac: e353000b cmp r3, #11 <== NOT EXECUTED
lfn_checksum =
324b0: e20220ff and r2, r2, #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++)
324b4: 1afffff5 bne 32490 <msdos_find_name_in_fat_file+0x544> <== NOT EXECUTED
324b8: e58d2014 str r2, [sp, #20] <== 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)
324bc: e3590000 cmp r9, #0 <== NOT EXECUTED
324c0: 01a0b009 moveq fp, r9 <== NOT EXECUTED
324c4: 03a03001 moveq r3, #1 <== NOT EXECUTED
324c8: 0a000005 beq 324e4 <msdos_find_name_in_fat_file+0x598> <== NOT EXECUTED
}
/*
* Have we read past the empty block ? If so go back and read it again.
*/
if (dir_offset != empty_space_offset)
324cc: e59d0018 ldr r0, [sp, #24] <== NOT EXECUTED
324d0: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED
324d4: e1500001 cmp r0, r1 <== NOT EXECUTED
324d8: 13a03001 movne r3, #1 <== NOT EXECUTED
324dc: 1a000002 bne 324ec <msdos_find_name_in_fat_file+0x5a0> <== NOT EXECUTED
324e0: e3a03000 mov r3, #0 <== NOT EXECUTED
324e4: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED
324e8: e58d2020 str r2, [sp, #32] <== 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,
324ec: e59d9020 ldr r9, [sp, #32] <== NOT EXECUTED
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
324f0: e3e02000 mvn r2, #0 <== 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,
324f4: e3a0c000 mov ip, #0 <== 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)
324f8: e28a0001 add r0, sl, #1 <== NOT EXECUTED
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
324fc: e58d2044 str r2, [sp, #68] ; 0x44 <== NOT EXECUTED
32500: e58d2048 str r2, [sp, #72] ; 0x48 <== 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,
32504: e0090994 mul r9, r4, r9 <== NOT EXECUTED
32508: e58dc010 str ip, [sp, #16] <== 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)
3250c: e58d0028 str r0, [sp, #40] ; 0x28 <== NOT EXECUTED
32510: e58da02c str sl, [sp, #44] ; 0x2c <== NOT EXECUTED
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
32514: ea0000ac b 327cc <msdos_find_name_in_fat_file+0x880> <== NOT EXECUTED
{
int length = 0;
if (read_cluster)
32518: e3530000 cmp r3, #0 <== NOT EXECUTED
3251c: 0a000023 beq 325b0 <msdos_find_name_in_fat_file+0x664> <== 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,
32520: e597c098 ldr ip, [r7, #152] ; 0x98 <== NOT EXECUTED
32524: e59d001c ldr r0, [sp, #28] <== NOT EXECUTED
32528: e1a01005 mov r1, r5 <== NOT EXECUTED
3252c: e1a02009 mov r2, r9 <== NOT EXECUTED
32530: e1a03004 mov r3, r4 <== NOT EXECUTED
32534: e58dc000 str ip, [sp] <== NOT EXECUTED
32538: ebffbee4 bl 220d0 <fat_file_read> <== NOT EXECUTED
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
3253c: e1500004 cmp r0, r4 <== NOT EXECUTED
32540: 0a00001a beq 325b0 <msdos_find_name_in_fat_file+0x664> <== NOT EXECUTED
{
if (ret != FAT_EOF)
32544: e3500000 cmp r0, #0 <== NOT EXECUTED
32548: 1a000096 bne 327a8 <msdos_find_name_in_fat_file+0x85c> <== 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,
3254c: e1a01005 mov r1, r5 <== NOT EXECUTED
32550: e59d001c ldr r0, [sp, #28] <== NOT EXECUTED
32554: e1a02009 mov r2, r9 <== NOT EXECUTED
32558: e28d304c add r3, sp, #76 ; 0x4c <== NOT EXECUTED
3255c: ebffbdda bl 21ccc <fat_file_extend> <== NOT EXECUTED
&new_length);
if (ret != RC_OK)
32560: e2501000 subs r1, r0, #0 <== NOT EXECUTED
32564: 11a00001 movne r0, r1 <== NOT EXECUTED
32568: 1a0000a0 bne 327f0 <msdos_find_name_in_fat_file+0x8a4> <== 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))
3256c: e59d304c ldr r3, [sp, #76] ; 0x4c <== NOT EXECUTED
32570: e1530009 cmp r3, r9 <== NOT EXECUTED
32574: 1a00008b bne 327a8 <msdos_find_name_in_fat_file+0x85c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
memset(fs_info->cl_buf, 0, bts2rd);
32578: e1a02004 mov r2, r4 <== NOT EXECUTED
3257c: e5970098 ldr r0, [r7, #152] ; 0x98 <== NOT EXECUTED
32580: eb003795 bl 403dc <memset> <== NOT EXECUTED
ret = fat_file_write(mt_entry, fat_fd,
32584: e597c098 ldr ip, [r7, #152] ; 0x98 <== NOT EXECUTED
32588: e59d001c ldr r0, [sp, #28] <== NOT EXECUTED
3258c: e1a01005 mov r1, r5 <== NOT EXECUTED
32590: e1a02009 mov r2, r9 <== NOT EXECUTED
32594: e1a03004 mov r3, r4 <== NOT EXECUTED
32598: e58dc000 str ip, [sp] <== NOT EXECUTED
3259c: ebffbe3e bl 21e9c <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)
325a0: e3700001 cmn r0, #1 <== NOT EXECUTED
325a4: 0a000090 beq 327ec <msdos_find_name_in_fat_file+0x8a0> <== NOT EXECUTED
return ret;
else if (ret != bts2rd)
325a8: e1500004 cmp r0, r4 <== NOT EXECUTED
325ac: 1a00007d bne 327a8 <msdos_find_name_in_fat_file+0x85c> <== NOT EXECUTED
325b0: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
325b4: e59dc028 ldr ip, [sp, #40] ; 0x28 <== NOT EXECUTED
325b8: e59d002c ldr r0, [sp, #44] ; 0x2c <== NOT EXECUTED
325bc: e2813001 add r3, r1, #1 <== NOT EXECUTED
325c0: e1e02001 mvn r2, r1 <== NOT EXECUTED
325c4: e59d1038 ldr r1, [sp, #56] ; 0x38 <== NOT EXECUTED
325c8: e0822000 add r2, r2, r0 <== NOT EXECUTED
325cc: e063300c rsb r3, r3, ip <== NOT EXECUTED
325d0: e3a0c00d mov ip, #13 <== NOT EXECUTED
325d4: e021129c mla r1, ip, r2, r1 <== NOT EXECUTED
325d8: e20330ff and r3, r3, #255 ; 0xff <== NOT EXECUTED
325dc: e1a02005 mov r2, r5 <== NOT EXECUTED
325e0: e3a00000 mov r0, #0 <== NOT EXECUTED
325e4: e1a05003 mov r5, r3 <== NOT EXECUTED
325e8: e58d1024 str r1, [sp, #36] ; 0x24 <== NOT EXECUTED
325ec: e1a03009 mov r3, r9 <== NOT EXECUTED
325f0: e1a0a00b mov sl, fp <== NOT EXECUTED
325f4: e58d0018 str r0, [sp, #24] <== NOT EXECUTED
325f8: e59dc010 ldr ip, [sp, #16] <== NOT EXECUTED
325fc: e1a09002 mov r9, r2 <== NOT EXECUTED
32600: ea000055 b 3275c <msdos_find_name_in_fat_file+0x810> <== NOT EXECUTED
char* entry = (char*) fs_info->cl_buf + dir_entry;
char* p;
const char* n;
int i;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
32604: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
32608: e59d1028 ldr r1, [sp, #40] ; 0x28 <== NOT EXECUTED
char* p;
const char* n;
int i;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
3260c: e28cc001 add ip, ip, #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;
32610: e5976098 ldr r6, [r7, #152] ; 0x98 <== NOT EXECUTED
char* p;
const char* n;
int i;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
32614: e2822020 add r2, r2, #32 <== NOT EXECUTED
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
32618: e15c0001 cmp ip, r1 <== 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;
3261c: e086600a add r6, r6, sl <== NOT EXECUTED
char* p;
const char* n;
int i;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
32620: e58d2018 str r2, [sp, #24] <== NOT EXECUTED
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
32624: 1a00001f bne 326a8 <msdos_find_name_in_fat_file+0x75c> <== NOT EXECUTED
32628: e1a05009 mov r5, r9 <== NOT EXECUTED
{
/* get current cluster number */
int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
3262c: e59d001c ldr r0, [sp, #28] <== NOT EXECUTED
32630: e1a01005 mov r1, r5 <== NOT EXECUTED
32634: e3a02001 mov r2, #1 <== NOT EXECUTED
32638: e58dc010 str ip, [sp, #16] <== NOT EXECUTED
3263c: e1a09003 mov r9, r3 <== NOT EXECUTED
32640: e58d8000 str r8, [sp] <== NOT EXECUTED
32644: ebffbd34 bl 21b1c <fat_file_ioctl> <== NOT EXECUTED
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
32648: e3500000 cmp r0, #0 <== NOT EXECUTED
3264c: 1a000067 bne 327f0 <msdos_find_name_in_fat_file+0x8a4> <== NOT EXECUTED
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
32650: e59d3044 ldr r3, [sp, #68] ; 0x44 <== NOT EXECUTED
32654: 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;
32658: e588a004 str sl, [r8, #4] <== NOT EXECUTED
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
3265c: 0a000008 beq 32684 <msdos_find_name_in_fat_file+0x738> <== NOT EXECUTED
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
32660: e28dc044 add ip, sp, #68 ; 0x44 <== NOT EXECUTED
32664: e0030394 mul r3, r4, r3 <== NOT EXECUTED
32668: e59d001c ldr r0, [sp, #28] <== NOT EXECUTED
3266c: e1a01005 mov r1, r5 <== NOT EXECUTED
32670: e3a02001 mov r2, #1 <== NOT EXECUTED
32674: e58dc000 str ip, [sp] <== NOT EXECUTED
32678: ebffbd27 bl 21b1c <fat_file_ioctl> <== NOT EXECUTED
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
3267c: e3500000 cmp r0, #0 <== NOT EXECUTED
32680: 1a00005a bne 327f0 <msdos_find_name_in_fat_file+0x8a4> <== NOT EXECUTED
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
32684: e59d3044 ldr r3, [sp, #68] ; 0x44 <== NOT EXECUTED
32688: e5883008 str r3, [r8, #8] <== NOT EXECUTED
dir_pos->lname.ofs = lfn_start.ofs;
3268c: e59d3048 ldr r3, [sp, #72] ; 0x48 <== NOT EXECUTED
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
32690: e1a00006 mov r0, r6 <== NOT EXECUTED
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
32694: e588300c str r3, [r8, #12] <== NOT EXECUTED
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
32698: e59d1080 ldr r1, [sp, #128] ; 0x80 <== NOT EXECUTED
3269c: e3a02020 mov r2, #32 <== NOT EXECUTED
326a0: eb0036c6 bl 401c0 <memcpy> <== NOT EXECUTED
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
326a4: ea000031 b 32770 <msdos_find_name_in_fat_file+0x824> <== 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)
326a8: e59d2044 ldr r2, [sp, #68] ; 0x44 <== NOT EXECUTED
326ac: e3720001 cmn r2, #1 <== NOT EXECUTED
{
lfn_start.cln = empty_space_offset;
326b0: 059d0020 ldreq r0, [sp, #32] <== NOT EXECUTED
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
326b4: e3a01000 mov r1, #0 <== 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;
326b8: 058d0044 streq r0, [sp, #68] ; 0x44 <== NOT EXECUTED
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
326bc: e3a02020 mov r2, #32 <== NOT EXECUTED
326c0: e1a00006 mov r0, r6 <== NOT EXECUTED
326c4: e58d300c str r3, [sp, #12] <== NOT EXECUTED
326c8: e58dc008 str ip, [sp, #8] <== 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;
326cc: 058da048 streq sl, [sp, #72] ; 0x48 <== NOT EXECUTED
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
326d0: eb003741 bl 403dc <memset> <== NOT EXECUTED
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
326d4: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED
326d8: e5c6100d strb r1, [r6, #13] <== NOT EXECUTED
p = entry + 1;
326dc: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED
326e0: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED
326e4: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
326e8: e2862001 add r2, r6, #1 <== NOT EXECUTED
326ec: e3a01000 mov r1, #0 <== 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;
326f0: e5d0e000 ldrb lr, [r0] <== NOT EXECUTED
326f4: e5c2e000 strb lr, [r2] <== NOT EXECUTED
if (*n != 0)
326f8: e5d0e000 ldrb lr, [r0] <== NOT EXECUTED
326fc: e35e0000 cmp lr, #0 <== NOT EXECUTED
n++;
32700: 12800001 addne r0, r0, #1 <== NOT EXECUTED
switch (i)
32704: e3510004 cmp r1, #4 <== NOT EXECUTED
{
case 4:
p += 5;
32708: 02822005 addeq r2, r2, #5 <== NOT EXECUTED
{
*p = *n;
if (*n != 0)
n++;
switch (i)
3270c: 0a000002 beq 3271c <msdos_find_name_in_fat_file+0x7d0> <== NOT EXECUTED
32710: e351000a cmp r1, #10 <== NOT EXECUTED
break;
case 10:
p += 4;
break;
default:
p += 2;
32714: 12822002 addne r2, r2, #2 <== NOT EXECUTED
{
case 4:
p += 5;
break;
case 10:
p += 4;
32718: 02822004 addeq r2, r2, #4 <== 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++)
3271c: e2811001 add r1, r1, #1 <== NOT EXECUTED
32720: e351000d cmp r1, #13 <== NOT EXECUTED
32724: 1afffff1 bne 326f0 <msdos_find_name_in_fat_file+0x7a4> <== NOT EXECUTED
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
32728: e35c0001 cmp ip, #1 <== NOT EXECUTED
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
3272c: 03852040 orreq r2, r5, #64 ; 0x40 <== NOT EXECUTED
p += 2;
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
32730: e5c65000 strb r5, [r6] <== NOT EXECUTED
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
32734: 05c62000 strbeq r2, [r6] <== NOT EXECUTED
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
32738: e5d6200b ldrb r2, [r6, #11] <== NOT EXECUTED
3273c: e382200f orr r2, r2, #15 <== NOT EXECUTED
32740: e5c6200b strb r2, [r6, #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)
32744: e59d2024 ldr r2, [sp, #36] ; 0x24 <== NOT EXECUTED
32748: e242200d sub r2, r2, #13 <== NOT EXECUTED
3274c: e2455001 sub r5, r5, #1 <== NOT EXECUTED
32750: e58d2024 str r2, [sp, #36] ; 0x24 <== NOT EXECUTED
32754: e28aa020 add sl, sl, #32 <== NOT EXECUTED
32758: e20550ff and r5, r5, #255 ; 0xff <== NOT EXECUTED
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
3275c: e15a0004 cmp sl, r4 <== NOT EXECUTED
32760: 3affffa7 bcc 32604 <msdos_find_name_in_fat_file+0x6b8> <== NOT EXECUTED
32764: e58dc010 str ip, [sp, #16] <== NOT EXECUTED
32768: e1a05009 mov r5, r9 <== NOT EXECUTED
3276c: e1a09003 mov r9, r3 <== 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,
32770: e5973098 ldr r3, [r7, #152] ; 0x98 <== NOT EXECUTED
32774: e089200b add r2, r9, fp <== NOT EXECUTED
32778: e59d001c ldr r0, [sp, #28] <== NOT EXECUTED
3277c: e083b00b add fp, r3, fp <== NOT EXECUTED
32780: e1a01005 mov r1, r5 <== NOT EXECUTED
32784: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
32788: e58db000 str fp, [sp] <== NOT EXECUTED
3278c: ebffbdc2 bl 21e9c <fat_file_write> <== NOT EXECUTED
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
32790: e3700001 cmn r0, #1 <== NOT EXECUTED
32794: 0a000014 beq 327ec <msdos_find_name_in_fat_file+0x8a0> <== NOT EXECUTED
return ret;
else if (ret != length)
32798: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
3279c: e1500003 cmp r0, r3 <== NOT EXECUTED
}
ret = fat_file_write(mt_entry, fat_fd,
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
327a0: e0899004 add r9, r9, r4 <== NOT EXECUTED
return ret;
else if (ret != length)
327a4: 0a000003 beq 327b8 <msdos_find_name_in_fat_file+0x86c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
327a8: eb0029d4 bl 3cf00 <__errno> <== NOT EXECUTED
327ac: e3a03005 mov r3, #5 <== NOT EXECUTED
327b0: e5803000 str r3, [r0] <== NOT EXECUTED
327b4: ea00000c b 327ec <msdos_find_name_in_fat_file+0x8a0> <== NOT EXECUTED
empty_space_offset++;
327b8: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED
327bc: e28cc001 add ip, ip, #1 <== NOT EXECUTED
327c0: e58dc020 str ip, [sp, #32] <== NOT EXECUTED
327c4: e3a0b000 mov fp, #0 <== NOT EXECUTED
327c8: e3a03001 mov r3, #1 <== NOT EXECUTED
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
327cc: e59d002c ldr r0, [sp, #44] ; 0x2c <== NOT EXECUTED
327d0: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
327d4: e1500001 cmp r0, r1 <== NOT EXECUTED
327d8: aaffff4e bge 32518 <msdos_find_name_in_fat_file+0x5cc> <== NOT EXECUTED
327dc: e3a00000 mov r0, #0 <== NOT EXECUTED
327e0: ea000002 b 327f0 <msdos_find_name_in_fat_file+0x8a4> <== NOT EXECUTED
327e4: e59f0028 ldr r0, [pc, #40] ; 32814 <msdos_find_name_in_fat_file+0x8c8><== NOT EXECUTED
327e8: ea000000 b 327f0 <msdos_find_name_in_fat_file+0x8a4> <== NOT EXECUTED
327ec: e3e00000 mvn r0, #0 <== NOT EXECUTED
empty_space_entry = 0;
read_cluster = true;
}
return 0;
}
327f0: e28dd050 add sp, sp, #80 ; 0x50 <== NOT EXECUTED
327f4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00031df0 <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
)
{
31df0: e92d4ff3 push {r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
31df4: e1a05001 mov r5, 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) &&
31df8: e5911020 ldr r1, [r1, #32] <== NOT EXECUTED
31dfc: e3510001 cmp r1, #1 <== NOT EXECUTED
fat_file_fd_t *fat_fd,
uint32_t cl4find,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
31e00: e1a0b000 mov fp, r0 <== NOT EXECUTED
31e04: e1a0c002 mov ip, r2 <== NOT EXECUTED
31e08: e1a09003 mov r9, r3 <== NOT EXECUTED
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
31e0c: e5907034 ldr r7, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
31e10: 1a000008 bne 31e38 <msdos_find_node_by_cluster_num_in_fat_file+0x48><== NOT EXECUTED
31e14: e5953024 ldr r3, [r5, #36] ; 0x24 <== NOT EXECUTED
31e18: e3530000 cmp r3, #0 <== NOT EXECUTED
31e1c: 1a000005 bne 31e38 <msdos_find_node_by_cluster_num_in_fat_file+0x48><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
31e20: e5d7300a ldrb r3, [r7, #10] <== NOT EXECUTED
31e24: e3130003 tst r3, #3 <== NOT EXECUTED
31e28: 0a000002 beq 31e38 <msdos_find_node_by_cluster_num_in_fat_file+0x48><== NOT EXECUTED
bts2rd = fat_fd->fat_file_size;
31e2c: e5956018 ldr r6, [r5, #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) &&
31e30: e3a0a000 mov sl, #0 <== NOT EXECUTED
31e34: ea000031 b 31f00 <msdos_find_node_by_cluster_num_in_fat_file+0x110><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
31e38: e1d760b6 ldrh r6, [r7, #6] <== NOT EXECUTED
31e3c: eafffffb b 31e30 <msdos_find_node_by_cluster_num_in_fat_file+0x40><== 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 )
31e40: e350001f cmp r0, #31 <== NOT EXECUTED
31e44: ca000004 bgt 31e5c <msdos_find_node_by_cluster_num_in_fat_file+0x6c><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
31e48: eb002c2c bl 3cf00 <__errno> <== NOT EXECUTED
31e4c: e3a03005 mov r3, #5 <== NOT EXECUTED
31e50: e5803000 str r3, [r0] <== NOT EXECUTED
31e54: e3e05000 mvn r5, #0 <== NOT EXECUTED
31e58: ea000034 b 31f30 <msdos_find_node_by_cluster_num_in_fat_file+0x140><== NOT EXECUTED
assert(ret == bts2rd);
31e5c: e1500006 cmp r0, r6 <== NOT EXECUTED
31e60: 159f00d0 ldrne r0, [pc, #208] ; 31f38 <msdos_find_node_by_cluster_num_in_fat_file+0x148><== NOT EXECUTED
31e64: 159f10d0 ldrne r1, [pc, #208] ; 31f3c <msdos_find_node_by_cluster_num_in_fat_file+0x14c><== NOT EXECUTED
31e68: 159f20d0 ldrne r2, [pc, #208] ; 31f40 <msdos_find_node_by_cluster_num_in_fat_file+0x150><== NOT EXECUTED
31e6c: 159f30d0 ldrne r3, [pc, #208] ; 31f44 <msdos_find_node_by_cluster_num_in_fat_file+0x154><== NOT EXECUTED
31e70: 1bffcb6f blne 24c34 <__assert_func> <== NOT EXECUTED
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
31e74: e5973098 ldr r3, [r7, #152] ; 0x98 <== NOT EXECUTED
31e78: e3a04000 mov r4, #0 <== NOT EXECUTED
31e7c: e1a08003 mov r8, r3 <== NOT EXECUTED
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
31e80: e7d32004 ldrb r2, [r3, r4] <== NOT EXECUTED
31e84: e3520000 cmp r2, #0 <== NOT EXECUTED
31e88: 0a000027 beq 31f2c <msdos_find_node_by_cluster_num_in_fat_file+0x13c><== 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)) ==
31e8c: e35200e5 cmp r2, #229 ; 0xe5 <== NOT EXECUTED
31e90: 0a000015 beq 31eec <msdos_find_node_by_cluster_num_in_fat_file+0xfc><== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
31e94: e1d811b4 ldrh r1, [r8, #20] <== NOT EXECUTED
31e98: e1d821ba ldrh r2, [r8, #26] <== NOT EXECUTED
31e9c: e1822801 orr r2, r2, r1, lsl #16 <== NOT EXECUTED
31ea0: e152000c cmp r2, ip <== NOT EXECUTED
31ea4: 1a000010 bne 31eec <msdos_find_node_by_cluster_num_in_fat_file+0xfc><== NOT EXECUTED
{
/* on success fill aux structure and copy all 32 bytes */
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM, j * bts2rd,
31ea8: e1a01005 mov r1, r5 <== NOT EXECUTED
31eac: e1a0000b mov r0, fp <== NOT EXECUTED
31eb0: e1a0300a mov r3, sl <== NOT EXECUTED
31eb4: e3a02001 mov r2, #1 <== NOT EXECUTED
31eb8: e58d9000 str r9, [sp] <== NOT EXECUTED
31ebc: ebffbf16 bl 21b1c <fat_file_ioctl> <== NOT EXECUTED
&dir_pos->sname.cln);
if (rc != RC_OK)
31ec0: e2505000 subs r5, r0, #0 <== NOT EXECUTED
31ec4: 1a000019 bne 31f30 <msdos_find_node_by_cluster_num_in_fat_file+0x140><== NOT EXECUTED
return rc;
dir_pos->sname.ofs = i;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
31ec8: e3e03000 mvn r3, #0 <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
31ecc: e589300c str r3, [r9, #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;
31ed0: e5894004 str r4, [r9, #4] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
31ed4: e5893008 str r3, [r9, #8] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
memcpy(dir_entry, entry,
31ed8: e59d002c ldr r0, [sp, #44] ; 0x2c <== NOT EXECUTED
31edc: e1a01008 mov r1, r8 <== NOT EXECUTED
31ee0: e3a02020 mov r2, #32 <== NOT EXECUTED
31ee4: eb0038b5 bl 401c0 <memcpy> <== NOT EXECUTED
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
31ee8: ea000010 b 31f30 <msdos_find_node_by_cluster_num_in_fat_file+0x140><== 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)
31eec: e2844020 add r4, r4, #32 <== NOT EXECUTED
31ef0: e1540006 cmp r4, r6 <== NOT EXECUTED
31ef4: e2888020 add r8, r8, #32 <== NOT EXECUTED
31ef8: 3affffe0 bcc 31e80 <msdos_find_node_by_cluster_num_in_fat_file+0x90><== NOT EXECUTED
31efc: e08aa006 add sl, sl, r6 <== 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,
31f00: e597e098 ldr lr, [r7, #152] ; 0x98 <== NOT EXECUTED
31f04: e1a0000b mov r0, fp <== NOT EXECUTED
31f08: e1a01005 mov r1, r5 <== NOT EXECUTED
31f0c: e1a0200a mov r2, sl <== NOT EXECUTED
31f10: e1a03006 mov r3, r6 <== NOT EXECUTED
31f14: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
31f18: e58de000 str lr, [sp] <== NOT EXECUTED
31f1c: ebffc06b bl 220d0 <fat_file_read> <== NOT EXECUTED
31f20: e3500000 cmp r0, #0 <== NOT EXECUTED
31f24: e59dc004 ldr ip, [sp, #4] <== NOT EXECUTED
31f28: 1affffc4 bne 31e40 <msdos_find_node_by_cluster_num_in_fat_file+0x50><== NOT EXECUTED
31f2c: e59f5014 ldr r5, [pc, #20] ; 31f48 <msdos_find_node_by_cluster_num_in_fat_file+0x158><== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
31f30: e1a00005 mov r0, r5 <== NOT EXECUTED
31f34: e8bd8ffc pop {r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0001c558 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
1c558: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
1c55c: e1a04001 mov r4, r1 <== NOT EXECUTED
1c560: e24ddfb1 sub sp, sp, #708 ; 0x2c4 <== NOT EXECUTED
1c564: e1a05000 mov r5, 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,
1c568: e1a03000 mov r3, r0 <== NOT EXECUTED
1c56c: e59f2c2c ldr r2, [pc, #3116] ; 1d1a0 <msdos_format+0xc48> <== NOT EXECUTED
1c570: e3a01001 mov r1, #1 <== NOT EXECUTED
1c574: e1a00004 mov r0, r4 <== NOT EXECUTED
1c578: ebffff81 bl 1c384 <msdos_format_printf> <== NOT EXECUTED
"formating: %s\n", devname);
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1c57c: e1a00004 mov r0, r4 <== NOT EXECUTED
1c580: e3a01002 mov r1, #2 <== NOT EXECUTED
1c584: e59f2c18 ldr r2, [pc, #3096] ; 1d1a4 <msdos_format+0xc4c> <== NOT EXECUTED
1c588: e1a03005 mov r3, r5 <== NOT EXECUTED
1c58c: ebffff7c bl 1c384 <msdos_format_printf> <== NOT EXECUTED
"stat check: %s\n", devname);
if (ret_val == 0) {
rc = stat(devname, &stat_buf);
1c590: e1a00005 mov r0, r5 <== NOT EXECUTED
1c594: e28d1e27 add r1, sp, #624 ; 0x270 <== NOT EXECUTED
1c598: ebffb225 bl 8e34 <stat> <== NOT EXECUTED
ret_val = rc;
}
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) &&
1c59c: e2507000 subs r7, r0, #0 <== NOT EXECUTED
1c5a0: 1a000007 bne 1c5c4 <msdos_format+0x6c> <== NOT EXECUTED
(!S_ISBLK(stat_buf.st_mode))) {
1c5a4: e59d327c ldr r3, [sp, #636] ; 0x27c <== NOT EXECUTED
1c5a8: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
1c5ac: e3530a06 cmp r3, #24576 ; 0x6000 <== NOT EXECUTED
1c5b0: 0a0002c7 beq 1d0d4 <msdos_format+0xb7c> <== NOT EXECUTED
errno = ENOTTY;
1c5b4: eb008251 bl 3cf00 <__errno> <== NOT EXECUTED
1c5b8: e3a03019 mov r3, #25 <== NOT EXECUTED
1c5bc: e5803000 str r3, [r0] <== NOT EXECUTED
1c5c0: e3e07000 mvn r7, #0 <== NOT EXECUTED
1c5c4: e3a06000 mov r6, #0 <== NOT EXECUTED
1c5c8: ea000003 b 1c5dc <msdos_format+0x84> <== 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;
1c5cc: eb00824b bl 3cf00 <__errno> <== NOT EXECUTED
1c5d0: e3a03019 mov r3, #25 <== NOT EXECUTED
1c5d4: e5803000 str r3, [r0] <== NOT EXECUTED
1c5d8: e3e07000 mvn r7, #0 <== NOT EXECUTED
1c5dc: e3e05000 mvn r5, #0 <== NOT EXECUTED
1c5e0: ea000136 b 1cac0 <msdos_format+0x568> <== NOT EXECUTED
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
1c5e4: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
}
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
1c5e8: e3530000 cmp r3, #0 <== NOT EXECUTED
1c5ec: 1a000001 bne 1c5f8 <msdos_format+0xa0> <== NOT EXECUTED
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
1c5f0: e3a03002 mov r3, #2 <== NOT EXECUTED
1c5f4: ea000002 b 1c604 <msdos_format+0xac> <== NOT EXECUTED
}
else if (rqdata->fat_num <= 6) {
1c5f8: e3530006 cmp r3, #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) {
1c5fc: 83a07016 movhi r7, #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) {
1c600: 8a0000e2 bhi 1c990 <msdos_format+0x438> <== NOT EXECUTED
fmt_params->fat_num = rqdata->fat_num;
1c604: e5cd3250 strb r3, [sp, #592] ; 0x250 <== NOT EXECUTED
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1c608: e1a00004 mov r0, r4 <== NOT EXECUTED
1c60c: e5dd3250 ldrb r3, [sp, #592] ; 0x250 <== NOT EXECUTED
1c610: e3a01002 mov r1, #2 <== NOT EXECUTED
1c614: e59f2b8c ldr r2, [pc, #2956] ; 1d1a8 <msdos_format+0xc50> <== NOT EXECUTED
1c618: ebffff59 bl 1c384 <msdos_format_printf> <== NOT EXECUTED
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
1c61c: e3a03001 mov r3, #1 <== NOT EXECUTED
if ((rqdata != NULL) &&
1c620: e3540000 cmp r4, #0 <== NOT EXECUTED
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
1c624: e58d322c str r3, [sp, #556] ; 0x22c <== NOT EXECUTED
if ((rqdata != NULL) &&
1c628: 0a000010 beq 1c670 <msdos_format+0x118> <== NOT EXECUTED
(rqdata->fattype == MSDOS_FMT_FAT12)) {
1c62c: e5d43014 ldrb r3, [r4, #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) &&
1c630: e3530001 cmp r3, #1 <== NOT EXECUTED
1c634: 0a000004 beq 1c64c <msdos_format+0xf4> <== NOT EXECUTED
(rqdata->fattype == MSDOS_FMT_FAT12)) {
fmt_params->fattype = FAT_FAT12;
}
else if ((rqdata != NULL) &&
1c638: e3530002 cmp r3, #2 <== NOT EXECUTED
1c63c: 0a000002 beq 1c64c <msdos_format+0xf4> <== NOT EXECUTED
(rqdata->fattype == MSDOS_FMT_FAT16)) {
fmt_params->fattype = FAT_FAT16;
}
else if ((rqdata != NULL) &&
1c640: e3530003 cmp r3, #3 <== NOT EXECUTED
1c644: 1a000002 bne 1c654 <msdos_format+0xfc> <== NOT EXECUTED
(rqdata->fattype == MSDOS_FMT_FAT32)) {
fmt_params->fattype = FAT_FAT32;
1c648: e2833001 add r3, r3, #1 <== NOT EXECUTED
1c64c: e5cd3252 strb r3, [sp, #594] ; 0x252 <== NOT EXECUTED
1c650: ea000027 b 1c6f4 <msdos_format+0x19c> <== NOT EXECUTED
}
else if ((rqdata != NULL) &&
1c654: e3530000 cmp r3, #0 <== NOT EXECUTED
1c658: 0a000004 beq 1c670 <msdos_format+0x118> <== NOT EXECUTED
(rqdata->fattype != MSDOS_FMT_FATANY)) {
ret_val = -1;
errno = EINVAL;
1c65c: eb008227 bl 3cf00 <__errno> <== NOT EXECUTED
1c660: e3a03016 mov r3, #22 <== NOT EXECUTED
1c664: e5803000 str r3, [r0] <== NOT EXECUTED
1c668: e3e07000 mvn r7, #0 <== NOT EXECUTED
1c66c: ea000021 b 1c6f8 <msdos_format+0x1a0> <== 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
1c670: e59d3224 ldr r3, [sp, #548] ; 0x224 <== NOT EXECUTED
1c674: e59f2b30 ldr r2, [pc, #2864] ; 1d1ac <msdos_format+0xc54> <== NOT EXECUTED
1c678: e1530002 cmp r3, r2 <== NOT EXECUTED
< ((uint32_t)FAT_FAT12_MAX_CLN)*8) {
fmt_params->fattype = FAT_FAT12;
1c67c: 93a03001 movls r3, #1 <== NOT EXECUTED
1c680: 95cd3252 strbls r3, [sp, #594] ; 0x252 <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
1c684: 90833003 addls r3, r3, r3 <== 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
1c688: 9a000015 bls 1c6e4 <msdos_format+0x18c> <== 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
1c68c: e59f2b1c ldr r2, [pc, #2844] ; 1d1b0 <msdos_format+0xc58> <== NOT EXECUTED
1c690: e1530002 cmp r3, r2 <== NOT EXECUTED
< ((uint32_t)FAT_FAT16_MAX_CLN)*32) {
fmt_params->fattype = FAT_FAT16;
1c694: 93a03002 movls r3, #2 <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
1c698: 958d322c strls r3, [sp, #556] ; 0x22c <== 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;
1c69c: 95cd3252 strbls r3, [sp, #594] ; 0x252 <== 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
1c6a0: 9a000010 bls 1c6e8 <msdos_format+0x190> <== 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;
1c6a4: e3a02101 mov r2, #1073741824 ; 0x40000000 <== NOT EXECUTED
1c6a8: e0922007 adds r2, r2, r7 <== NOT EXECUTED
1c6ac: e3a03000 mov r3, #0 <== NOT EXECUTED
1c6b0: e0a33008 adc r3, r3, r8 <== NOT EXECUTED
1c6b4: e1a01f22 lsr r1, r2, #30 <== NOT EXECUTED
1c6b8: e1811103 orr r1, r1, r3, lsl #2 <== 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)
1c6bc: e3a02001 mov r2, #1 <== 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;
1c6c0: 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)
1c6c4: e0110312 ands r0, r1, r2, lsl r3 <== NOT EXECUTED
1c6c8: 1a000001 bne 1c6d4 <msdos_format+0x17c> <== 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--)
1c6cc: e2533001 subs r3, r3, #1 <== NOT EXECUTED
1c6d0: 1afffffb bne 1c6c4 <msdos_format+0x16c> <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
1c6d4: e3a02001 mov r2, #1 <== NOT EXECUTED
1c6d8: e1a03312 lsl r3, r2, r3 <== 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;
1c6dc: e2822003 add r2, r2, #3 <== NOT EXECUTED
1c6e0: e5cd2252 strb r2, [sp, #594] ; 0x252 <== 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;
1c6e4: e58d322c str r3, [sp, #556] ; 0x22c <== NOT EXECUTED
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
1c6e8: e3540000 cmp r4, #0 <== NOT EXECUTED
1c6ec: 01a07004 moveq r7, r4 <== NOT EXECUTED
1c6f0: 0a000003 beq 1c704 <msdos_format+0x1ac> <== NOT EXECUTED
1c6f4: e3a07000 mov r7, #0 <== NOT EXECUTED
(rqdata->sectors_per_cluster > 0)) {
1c6f8: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
1c6fc: e3530000 cmp r3, #0 <== NOT EXECUTED
(rqdata->sectors_per_cluster > 0)) {
fmt_params->sectors_per_cluster =
1c700: 158d322c strne r3, [sp, #556] ; 0x22c <== 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) {
1c704: e59da220 ldr sl, [sp, #544] ; 0x220 <== NOT EXECUTED
1c708: e59d322c ldr r3, [sp, #556] ; 0x22c <== NOT EXECUTED
1c70c: e3a08080 mov r8, #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) {
1c710: e1530008 cmp r3, r8 <== NOT EXECUTED
fmt_params->sectors_per_cluster = onebit;
if (fmt_params->sectors_per_cluster
1c714: e1a0100a mov r1, sl <== NOT EXECUTED
1c718: 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) {
1c71c: 3a000004 bcc 1c734 <msdos_format+0x1dc> <== NOT EXECUTED
fmt_params->sectors_per_cluster = onebit;
if (fmt_params->sectors_per_cluster
1c720: eb00e1b4 bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
1c724: e1580000 cmp r8, r0 <== NOT EXECUTED
1c728: 91a03008 movls r3, r8 <== NOT EXECUTED
1c72c: 81a03008 movhi r3, r8 <== NOT EXECUTED
1c730: 93a08001 movls r8, #1 <== 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) {
1c734: e1b080a8 lsrs r8, r8, #1 <== NOT EXECUTED
1c738: 1afffff4 bne 1c710 <msdos_format+0x1b8> <== NOT EXECUTED
}
}
}
}
if (ret_val == 0) {
1c73c: e3570000 cmp r7, #0 <== 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) {
1c740: e58d322c str r3, [sp, #556] ; 0x22c <== NOT EXECUTED
}
}
}
}
if (ret_val == 0) {
1c744: 1a000091 bne 1c990 <msdos_format+0x438> <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1c748: e1a00004 mov r0, r4 <== NOT EXECUTED
1c74c: e3a01002 mov r1, #2 <== NOT EXECUTED
1c750: e59f2a5c ldr r2, [pc, #2652] ; 1d1b4 <msdos_format+0xc5c> <== NOT EXECUTED
1c754: ebffff0a bl 1c384 <msdos_format_printf> <== NOT EXECUTED
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
1c758: e5dd3252 ldrb r3, [sp, #594] ; 0x252 <== NOT EXECUTED
1c75c: e3530004 cmp r3, #4 <== NOT EXECUTED
1c760: 1a000007 bne 1c784 <msdos_format+0x22c> <== NOT EXECUTED
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
1c764: e283301c add r3, r3, #28 <== NOT EXECUTED
1c768: e58d3228 str r3, [sp, #552] ; 0x228 <== 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;
1c76c: e3a03006 mov r3, #6 <== NOT EXECUTED
1c770: e58d3248 str r3, [sp, #584] ; 0x248 <== NOT EXECUTED
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
1c774: e3a03001 mov r3, #1 <== NOT EXECUTED
1c778: e58d324c str r3, [sp, #588] ; 0x24c <== 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;
1c77c: e58d7238 str r7, [sp, #568] ; 0x238 <== NOT EXECUTED
1c780: ea000015 b 1c7dc <msdos_format+0x284> <== 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;
1c784: 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) &&
1c788: e3540000 cmp r4, #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;
1c78c: e58d3228 str r3, [sp, #552] ; 0x228 <== 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) &&
1c790: 0a000002 beq 1c7a0 <msdos_format+0x248> <== NOT EXECUTED
(rqdata->files_per_root_dir > 0)) {
1c794: e5943010 ldr r3, [r4, #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) &&
1c798: e3530000 cmp r3, #0 <== NOT EXECUTED
1c79c: 1a000003 bne 1c7b0 <msdos_format+0x258> <== 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) {
1c7a0: e5dd3252 ldrb r3, [sp, #594] ; 0x252 <== NOT EXECUTED
1c7a4: e3530002 cmp r3, #2 <== NOT EXECUTED
fmt_params->files_per_root_dir = 512;
1c7a8: 03a03c02 moveq r3, #512 ; 0x200 <== NOT EXECUTED
}
else {
fmt_params->files_per_root_dir = 64;
1c7ac: 13a03040 movne r3, #64 ; 0x40 <== NOT EXECUTED
1c7b0: e58d3238 str r3, [sp, #568] ; 0x238 <== NOT EXECUTED
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
1c7b4: e59d1220 ldr r1, [sp, #544] ; 0x220 <== NOT EXECUTED
1c7b8: e59d8238 ldr r8, [sp, #568] ; 0x238 <== NOT EXECUTED
1c7bc: e1a01081 lsl r1, r1, #1 <== NOT EXECUTED
1c7c0: e1a012a1 lsr r1, r1, #5 <== NOT EXECUTED
1c7c4: e2488001 sub r8, r8, #1 <== NOT EXECUTED
1c7c8: e0888001 add r8, r8, 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 %
1c7cc: e1a00008 mov r0, r8 <== NOT EXECUTED
1c7d0: eb00e21c bl 55048 <__umodsi3> <== NOT EXECUTED
1c7d4: e0600008 rsb r0, r0, r8 <== NOT EXECUTED
1c7d8: e58d0238 str r0, [sp, #568] ; 0x238 <== 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)
+ fmt_params->bytes_per_sector - 1)
1c7dc: e59da220 ldr sl, [sp, #544] ; 0x220 <== 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)
1c7e0: e59d0238 ldr r0, [sp, #568] ; 0x238 <== NOT EXECUTED
1c7e4: e24a3001 sub r3, sl, #1 <== NOT EXECUTED
1c7e8: e0830280 add r0, r3, r0, lsl #5 <== NOT EXECUTED
1c7ec: e1a0100a mov r1, sl <== NOT EXECUTED
1c7f0: eb00e180 bl 54df8 <__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 -
1c7f4: e28d1f89 add r1, sp, #548 ; 0x224 <== NOT EXECUTED
1c7f8: e8910006 ldm r1, {r1, r2} <== 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)
1c7fc: 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 -
1c800: e0622001 rsb r2, r2, r1 <== NOT EXECUTED
1c804: 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) {
1c808: e3a00902 mov r0, #32768 ; 0x8000 <== NOT EXECUTED
1c80c: e1a0100a mov r1, sl <== 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 -
1c810: e58d2010 str r2, [sp, #16] <== 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 =
1c814: e58d323c str r3, [sp, #572] ; 0x23c <== 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) {
1c818: eb00e176 bl 54df8 <__aeabi_uidiv> <== 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,
1c81c: e5dd2250 ldrb r2, [sp, #592] ; 0x250 <== NOT EXECUTED
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
1c820: e5dd9252 ldrb r9, [sp, #594] ; 0x252 <== NOT EXECUTED
(fmt_params->fattype,
fmt_params->bytes_per_sector,
fatdata_sect_cnt,
fmt_params->fat_num,
1c824: e58d200c str r2, [sp, #12] <== NOT EXECUTED
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
1c828: e59d822c ldr r8, [sp, #556] ; 0x22c <== NOT EXECUTED
1c82c: ea000000 b 1c834 <msdos_format+0x2dc> <== NOT EXECUTED
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) {
sectors_per_cluster /= 2;
1c830: e1a080a8 lsr r8, r8, #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) {
1c834: e1500008 cmp r0, r8 <== NOT EXECUTED
1c838: 3afffffc bcc 1c830 <msdos_format+0x2d8> <== NOT EXECUTED
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
1c83c: e24a3001 sub r3, sl, #1 <== NOT EXECUTED
1c840: e58d3014 str r3, [sp, #20] <== NOT EXECUTED
1c844: e58d7018 str r7, [sp, #24] <== 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;
1c848: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED
1c84c: e1a01008 mov r1, r8 <== NOT EXECUTED
1c850: eb00e168 bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
if (fattype == FAT_FAT12) {
1c854: e3590001 cmp r9, #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;
1c858: e1a07000 mov r7, r0 <== NOT EXECUTED
if (fattype == FAT_FAT12) {
fat_capacity = fatdata_cluster_cnt * 3 / 2;
1c85c: 03a00003 moveq r0, #3 <== NOT EXECUTED
1c860: 00000097 muleq r0, r7, r0 <== NOT EXECUTED
1c864: 01a000a0 lsreq r0, r0, #1 <== NOT EXECUTED
* - 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;
if (fattype == FAT_FAT12) {
1c868: 0a000002 beq 1c878 <msdos_format+0x320> <== NOT EXECUTED
fat_capacity = fatdata_cluster_cnt * 3 / 2;
}
else if (fattype == FAT_FAT16) {
1c86c: e3590002 cmp r9, #2 <== NOT EXECUTED
fat_capacity = fatdata_cluster_cnt * 2;
1c870: 01a00087 lsleq r0, r7, #1 <== NOT EXECUTED
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
1c874: 11a00107 lslne r0, r7, #2 <== NOT EXECUTED
}
sectors_per_fat = ((fat_capacity
1c878: e59dc014 ldr ip, [sp, #20] <== NOT EXECUTED
1c87c: e1a0100a mov r1, sl <== NOT EXECUTED
1c880: e08c0000 add r0, ip, r0 <== NOT EXECUTED
1c884: eb00e15b bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
1c888: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
1c88c: e1a0b000 mov fp, r0 <== NOT EXECUTED
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
1c890: e2480001 sub r0, r8, #1 <== NOT EXECUTED
1c894: e0200b92 mla r0, r2, fp, r0 <== NOT EXECUTED
1c898: e1a01008 mov r1, r8 <== NOT EXECUTED
1c89c: eb00e155 bl 54df8 <__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)) ||
1c8a0: e59fc910 ldr ip, [pc, #2320] ; 1d1b8 <msdos_format+0xc60> <== NOT EXECUTED
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
1c8a4: e0600007 rsb r0, r0, r7 <== 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)) ||
1c8a8: e150000c cmp r0, ip <== NOT EXECUTED
1c8ac: 93a03000 movls r3, #0 <== NOT EXECUTED
1c8b0: 83a03001 movhi r3, #1 <== NOT EXECUTED
1c8b4: e3590001 cmp r9, #1 <== NOT EXECUTED
1c8b8: 13a03000 movne r3, #0 <== NOT EXECUTED
1c8bc: e3530000 cmp r3, #0 <== NOT EXECUTED
1c8c0: 1a000008 bne 1c8e8 <msdos_format+0x390> <== NOT EXECUTED
1c8c4: e59f28f0 ldr r2, [pc, #2288] ; 1d1bc <msdos_format+0xc64> <== NOT EXECUTED
1c8c8: e1500002 cmp r0, r2 <== NOT EXECUTED
1c8cc: 93a03000 movls r3, #0 <== NOT EXECUTED
1c8d0: 83a03001 movhi r3, #1 <== NOT EXECUTED
1c8d4: e3590002 cmp r9, #2 <== NOT EXECUTED
1c8d8: 13a03000 movne r3, #0 <== NOT EXECUTED
1c8dc: e3530000 cmp r3, #0 <== NOT EXECUTED
1c8e0: 02833001 addeq r3, r3, #1 <== NOT EXECUTED
1c8e4: 0a000001 beq 1c8f0 <msdos_format+0x398> <== NOT EXECUTED
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
1c8e8: e1a08088 lsl r8, r8, #1 <== NOT EXECUTED
1c8ec: e3a03000 mov r3, #0 <== NOT EXECUTED
finished = true;
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if ((sectors_per_cluster * bytes_per_sector)
1c8f0: e002089a mul r2, sl, r8 <== NOT EXECUTED
1c8f4: e3520902 cmp r2, #32768 ; 0x8000 <== NOT EXECUTED
1c8f8: 8a000004 bhi 1c910 <msdos_format+0x3b8> <== NOT EXECUTED
> MS_BYTES_PER_CLUSTER_LIMIT) {
ret_val = EINVAL;
finished = true;
}
} while (!finished);
1c8fc: e3530000 cmp r3, #0 <== NOT EXECUTED
1c900: 0affffd0 beq 1c848 <msdos_format+0x2f0> <== NOT EXECUTED
1c904: e59d7018 ldr r7, [sp, #24] <== 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;
1c908: e58db230 str fp, [sp, #560] ; 0x230 <== NOT EXECUTED
1c90c: ea000004 b 1c924 <msdos_format+0x3cc> <== NOT EXECUTED
finished = true;
}
} while (!finished);
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
1c910: eb00817a bl 3cf00 <__errno> <== NOT EXECUTED
1c914: e3a03016 mov r3, #22 <== NOT EXECUTED
1c918: e5803000 str r3, [r0] <== NOT EXECUTED
1c91c: e3a08000 mov r8, #0 <== NOT EXECUTED
1c920: e3e07000 mvn r7, #0 <== NOT EXECUTED
}
/*
* determine media code
*/
if (ret_val == 0) {
1c924: e3570000 cmp r7, #0 <== 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;
1c928: e58d822c str r8, [sp, #556] ; 0x22c <== NOT EXECUTED
}
/*
* determine media code
*/
if (ret_val == 0) {
1c92c: 1a000013 bne 1c980 <msdos_format+0x428> <== NOT EXECUTED
if ((rqdata != NULL) &&
1c930: e3540000 cmp r4, #0 <== NOT EXECUTED
1c934: 0a000013 beq 1c988 <msdos_format+0x430> <== NOT EXECUTED
1c938: e5d48015 ldrb r8, [r4, #21] <== NOT EXECUTED
1c93c: e3580000 cmp r8, #0 <== NOT EXECUTED
1c940: 0a000010 beq 1c988 <msdos_format+0x430> <== NOT EXECUTED
(rqdata->media != 0)) {
const char valid_media_codes[] =
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
1c944: e59f3874 ldr r3, [pc, #2164] ; 1d1c0 <msdos_format+0xc68> <== NOT EXECUTED
1c948: e8930007 ldm r3, {r0, r1, r2} <== NOT EXECUTED
1c94c: e28d3fae add r3, sp, #696 ; 0x2b8 <== NOT EXECUTED
1c950: e8a30003 stmia r3!, {r0, r1} <== NOT EXECUTED
if (NULL==memchr(valid_media_codes,
1c954: e28d0fae add r0, sp, #696 ; 0x2b8 <== 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};
1c958: e5c32000 strb r2, [r3] <== NOT EXECUTED
if (NULL==memchr(valid_media_codes,
1c95c: e1a01008 mov r1, r8 <== NOT EXECUTED
1c960: e3a02009 mov r2, #9 <== NOT EXECUTED
1c964: eb008db6 bl 40044 <memchr> <== NOT EXECUTED
1c968: e3500000 cmp r0, #0 <== NOT EXECUTED
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
}
else {
fmt_params->media_code = rqdata->media;
1c96c: 15cd8251 strbne r8, [sp, #593] ; 0x251 <== 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,
1c970: 1a000006 bne 1c990 <msdos_format+0x438> <== NOT EXECUTED
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
1c974: eb008161 bl 3cf00 <__errno> <== NOT EXECUTED
1c978: e3a03016 mov r3, #22 <== NOT EXECUTED
1c97c: e5803000 str r3, [r0] <== NOT EXECUTED
1c980: e3e07000 mvn r7, #0 <== NOT EXECUTED
1c984: ea000001 b 1c990 <msdos_format+0x438> <== NOT EXECUTED
else {
fmt_params->media_code = rqdata->media;
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
1c988: e3e03007 mvn r3, #7 <== NOT EXECUTED
1c98c: e5cd3251 strb r3, [sp, #593] ; 0x251 <== NOT EXECUTED
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
1c990: e59d023c ldr r0, [sp, #572] ; 0x23c <== NOT EXECUTED
1c994: e59d3230 ldr r3, [sp, #560] ; 0x230 <== NOT EXECUTED
1c998: e5dd1250 ldrb r1, [sp, #592] ; 0x250 <== NOT EXECUTED
1c99c: e59d2228 ldr r2, [sp, #552] ; 0x228 <== NOT EXECUTED
1c9a0: e3500000 cmp r0, #0 <== NOT EXECUTED
}
else {
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
1c9a4: 00202193 mlaeq r0, r3, r1, r2 <== NOT EXECUTED
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
fmt_params->root_dir_start_sec =
1c9a8: 102c2193 mlane ip, r3, r1, r2 <== NOT EXECUTED
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
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;
1c9ac: 059d322c ldreq r3, [sp, #556] ; 0x22c <== NOT EXECUTED
*/
if (fmt_params->root_dir_sectors > 0) {
fmt_params->root_dir_start_sec =
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;
1c9b0: 158d0244 strne r0, [sp, #580] ; 0x244 <== NOT EXECUTED
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
fmt_params->root_dir_start_sec =
1c9b4: 158dc240 strne ip, [sp, #576] ; 0x240 <== NOT EXECUTED
}
else {
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
1c9b8: 058d0240 streq r0, [sp, #576] ; 0x240 <== 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;
1c9bc: 058d3244 streq r3, [sp, #580] ; 0x244 <== NOT EXECUTED
}
/*
* determine usable OEMName
*/
if (ret_val == 0) {
1c9c0: e3570000 cmp r7, #0 <== NOT EXECUTED
1c9c4: 1a00003a bne 1cab4 <msdos_format+0x55c> <== NOT EXECUTED
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
1c9c8: e3540000 cmp r4, #0 <== NOT EXECUTED
1c9cc: 059f37f0 ldreq r3, [pc, #2032] ; 1d1c4 <msdos_format+0xc6c><== NOT EXECUTED
1c9d0: 0a000003 beq 1c9e4 <msdos_format+0x48c> <== NOT EXECUTED
(rqdata->OEMName != NULL)) {
1c9d4: e5943000 ldr r3, [r4] <== 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) &&
1c9d8: e59f27e4 ldr r2, [pc, #2020] ; 1d1c4 <msdos_format+0xc6c> <== NOT EXECUTED
1c9dc: e3530000 cmp r3, #0 <== NOT EXECUTED
1c9e0: 01a03002 moveq r3, r2 <== NOT EXECUTED
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
1c9e4: e59f27dc ldr r2, [pc, #2012] ; 1d1c8 <msdos_format+0xc70> <== NOT EXECUTED
1c9e8: e28d1e22 add r1, sp, #544 ; 0x220 <== NOT EXECUTED
1c9ec: e5920000 ldr r0, [r2] <== NOT EXECUTED
}
/*=========================================================================*\
| Function: |
\*-------------------------------------------------------------------------*/
int msdos_format
1c9f0: e281803c add r8, r1, #60 ; 0x3c <== NOT EXECUTED
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
1c9f4: e2812034 add r2, r1, #52 ; 0x34 <== NOT EXECUTED
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
1c9f8: e3a07020 mov r7, #32 <== NOT EXECUTED
}
*to = '\0';
1c9fc: e3a0e000 mov lr, #0 <== NOT EXECUTED
1ca00: ea000007 b 1ca24 <msdos_format+0x4cc> <== NOT EXECUTED
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
1ca04: e5d3c000 ldrb ip, [r3] <== NOT EXECUTED
1ca08: e080a00c add sl, r0, ip <== NOT EXECUTED
1ca0c: e5daa001 ldrb sl, [sl, #1] <== NOT EXECUTED
1ca10: e31a0097 tst sl, #151 ; 0x97 <== NOT EXECUTED
*to++ = *from++;
1ca14: 1542c001 strbne ip, [r2, #-1] <== NOT EXECUTED
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
1ca18: 05427001 strbeq r7, [r2, #-1] <== NOT EXECUTED
}
*to = '\0';
1ca1c: e4c2e001 strb lr, [r2], #1 <== NOT EXECUTED
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
*to++ = *from++;
1ca20: 12833001 addne r3, r3, #1 <== NOT EXECUTED
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
(rqdata->OEMName != NULL)) {
from = rqdata->OEMName;
}
for (cnt = 0;
1ca24: e1520008 cmp r2, r8 <== NOT EXECUTED
1ca28: 1afffff5 bne 1ca04 <msdos_format+0x4ac> <== 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) &&
1ca2c: e3540000 cmp r4, #0 <== NOT EXECUTED
1ca30: 0a000004 beq 1ca48 <msdos_format+0x4f0> <== NOT EXECUTED
(rqdata->VolLabel != NULL)) {
1ca34: e5943004 ldr r3, [r4, #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) &&
1ca38: e3530000 cmp r3, #0 <== NOT EXECUTED
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
1ca3c: 13a02001 movne r2, #1 <== NOT EXECUTED
1ca40: 15cd2268 strbne r2, [sp, #616] ; 0x268 <== 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) &&
1ca44: 1a000000 bne 1ca4c <msdos_format+0x4f4> <== NOT EXECUTED
1ca48: e59f377c ldr r3, [pc, #1916] ; 1d1cc <msdos_format+0xc74> <== NOT EXECUTED
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
1ca4c: e28d2f97 add r2, sp, #604 ; 0x25c <== NOT EXECUTED
}
/*=========================================================================*\
| Function: |
\*-------------------------------------------------------------------------*/
int msdos_format
1ca50: e2811048 add r1, r1, #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;
1ca54: e2822001 add r2, r2, #1 <== NOT EXECUTED
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
1ca58: e3a07020 mov r7, #32 <== NOT EXECUTED
}
*to = '\0';
1ca5c: e3a0e000 mov lr, #0 <== NOT EXECUTED
1ca60: ea000007 b 1ca84 <msdos_format+0x52c> <== NOT EXECUTED
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
1ca64: e5d3c000 ldrb ip, [r3] <== NOT EXECUTED
1ca68: e080800c add r8, r0, ip <== NOT EXECUTED
1ca6c: e5d88001 ldrb r8, [r8, #1] <== NOT EXECUTED
1ca70: e3180097 tst r8, #151 ; 0x97 <== NOT EXECUTED
*to++ = *from++;
1ca74: 1542c001 strbne ip, [r2, #-1] <== NOT EXECUTED
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
1ca78: 05427001 strbeq r7, [r2, #-1] <== NOT EXECUTED
}
*to = '\0';
1ca7c: e4c2e001 strb lr, [r2], #1 <== NOT EXECUTED
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
*to++ = *from++;
1ca80: 12833001 addne r3, r3, #1 <== NOT EXECUTED
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
1ca84: e1520001 cmp r2, r1 <== NOT EXECUTED
1ca88: 1afffff5 bne 1ca64 <msdos_format+0x50c> <== NOT EXECUTED
{
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
1ca8c: e28d0fae add r0, sp, #696 ; 0x2b8 <== NOT EXECUTED
1ca90: ebffb9d2 bl b1e0 <rtems_clock_get_tod_timeval> <== NOT EXECUTED
if (rc == RTEMS_SUCCESSFUL) {
1ca94: e3500000 cmp r0, #0 <== NOT EXECUTED
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
1ca98: 059d32b8 ldreq r3, [sp, #696] ; 0x2b8 <== NOT EXECUTED
1ca9c: 01a03083 lsleq r3, r3, #1 <== NOT EXECUTED
1caa0: 058d326c streq r3, [sp, #620] ; 0x26c <== NOT EXECUTED
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
if (rc == RTEMS_SUCCESSFUL) {
1caa4: 0a0001ad beq 1d160 <msdos_format+0xc08> <== NOT EXECUTED
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
}
else {
*volid_ptr = rand();
1caa8: eb009576 bl 42088 <rand> <== NOT EXECUTED
1caac: e58d026c str r0, [sp, #620] ; 0x26c <== NOT EXECUTED
1cab0: ea0001aa b 1d160 <msdos_format+0xc08> <== NOT EXECUTED
}
/*
* Phuuu.... That's it.
*/
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
1cab4: eb008111 bl 3cf00 <__errno> <== NOT EXECUTED
1cab8: e5807000 str r7, [r0] <== NOT EXECUTED
1cabc: e3e07000 mvn r7, #0 <== 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) &&
1cac0: e2773001 rsbs r3, r7, #1 <== NOT EXECUTED
1cac4: 33a03000 movcc r3, #0 <== NOT EXECUTED
1cac8: e3540000 cmp r4, #0 <== NOT EXECUTED
1cacc: 03a03000 moveq r3, #0 <== NOT EXECUTED
1cad0: e3530000 cmp r3, #0 <== NOT EXECUTED
1cad4: 0a00000b beq 1cb08 <msdos_format+0x5b0> <== NOT EXECUTED
(rqdata != NULL) &&
!(rqdata->quick_format)) {
1cad8: e5d42016 ldrb r2, [r4, #22] <== NOT EXECUTED
1cadc: e3520000 cmp r2, #0 <== NOT EXECUTED
1cae0: 1a00000a bne 1cb10 <msdos_format+0x5b8> <== NOT EXECUTED
ret_val = msdos_format_fill_sectors
1cae4: e59dc220 ldr ip, [sp, #544] ; 0x220 <== NOT EXECUTED
1cae8: e1a00004 mov r0, r4 <== NOT EXECUTED
1caec: e58dc000 str ip, [sp] <== NOT EXECUTED
1caf0: e1a01005 mov r1, r5 <== NOT EXECUTED
1caf4: e3a0c0e5 mov ip, #229 ; 0xe5 <== NOT EXECUTED
1caf8: e59d3224 ldr r3, [sp, #548] ; 0x224 <== NOT EXECUTED
1cafc: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
1cb00: ebfffe48 bl 1c428 <msdos_format_fill_sectors> <== NOT EXECUTED
1cb04: e1a07000 mov r7, r0 <== NOT EXECUTED
0xe5);
}
/*
* create master boot record
*/
if (ret_val == 0) {
1cb08: e3570000 cmp r7, #0 <== NOT EXECUTED
1cb0c: 1a000167 bne 1d0b0 <msdos_format+0xb58> <== NOT EXECUTED
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1cb10: e1a00004 mov r0, r4 <== NOT EXECUTED
1cb14: e3a01002 mov r1, #2 <== NOT EXECUTED
1cb18: e59f26b0 ldr r2, [pc, #1712] ; 1d1d0 <msdos_format+0xc78> <== NOT EXECUTED
1cb1c: ebfffe18 bl 1c384 <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)) {
1cb20: e1a00005 mov r0, r5 <== NOT EXECUTED
1cb24: e3a01000 mov r1, #0 <== NOT EXECUTED
1cb28: e3a02000 mov r2, #0 <== NOT EXECUTED
1cb2c: 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,
1cb30: e59d7220 ldr r7, [sp, #544] ; 0x220 <== 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)) {
1cb34: eb002502 bl 25f44 <lseek> <== NOT EXECUTED
1cb38: e3510000 cmp r1, #0 <== NOT EXECUTED
1cb3c: ba000005 blt 1cb58 <msdos_format+0x600> <== NOT EXECUTED
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
1cb40: e1a02007 mov r2, r7 <== NOT EXECUTED
1cb44: e1a00005 mov r0, r5 <== NOT EXECUTED
1cb48: e28d1020 add r1, sp, #32 <== NOT EXECUTED
1cb4c: ebffafb0 bl 8a14 <read> <== NOT EXECUTED
1cb50: e3500000 cmp r0, #0 <== NOT EXECUTED
1cb54: aa000183 bge 1d168 <msdos_format+0xc10> <== NOT EXECUTED
1cb58: e3e07000 mvn r7, #0 <== NOT EXECUTED
1cb5c: ea000153 b 1d0b0 <msdos_format+0xb58> <== NOT EXECUTED
1cb60: e3a0b000 mov fp, #0 <== 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);
1cb64: e28da020 add sl, sp, #32 <== NOT EXECUTED
1cb68: e3a01000 mov r1, #0 <== NOT EXECUTED
1cb6c: e59f2660 ldr r2, [pc, #1632] ; 1d1d4 <msdos_format+0xc7c> <== NOT EXECUTED
1cb70: e1a0000a mov r0, sl <== NOT EXECUTED
1cb74: eb008e18 bl 403dc <memset> <== NOT EXECUTED
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
1cb78: e28d3e22 add r3, sp, #544 ; 0x220 <== NOT EXECUTED
1cb7c: e2831033 add r1, r3, #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,
1cb80: e59f3650 ldr r3, [pc, #1616] ; 1d1d8 <msdos_format+0xc80> <== NOT EXECUTED
1cb84: e3a09000 mov r9, #0 <== NOT EXECUTED
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
1cb88: e3a02008 mov r2, #8 <== 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,
1cb8c: e18a90b3 strh r9, [sl, r3] <== NOT EXECUTED
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
1cb90: e28a0003 add r0, sl, #3 <== NOT EXECUTED
1cb94: eb008d89 bl 401c0 <memcpy> <== NOT EXECUTED
/* 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);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
1cb98: e5ddc251 ldrb ip, [sp, #593] ; 0x251 <== 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);
1cb9c: e59d2228 ldr r2, [sp, #552] ; 0x228 <== 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) {
1cba0: e5dd3252 ldrb r3, [sp, #594] ; 0x252 <== NOT EXECUTED
/* 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);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
1cba4: e58dc00c str ip, [sp, #12] <== 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);
1cba8: e1a0c422 lsr ip, r2, #8 <== 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);
1cbac: e1a02c28 lsr r2, r8, #24 <== NOT EXECUTED
1cbb0: e58d201c str r2, [sp, #28] <== NOT EXECUTED
1cbb4: e1a02828 lsr r2, r8, #16 <== 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);
1cbb8: e59d0220 ldr r0, [sp, #544] ; 0x220 <== 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);
1cbbc: e58d2018 str r2, [sp, #24] <== NOT EXECUTED
if (fmt_params->fattype != FAT_FAT32) {
1cbc0: e3530004 cmp r3, #4 <== 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... */
1cbc4: e3e02000 mvn r2, #0 <== 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);
1cbc8: e59d3238 ldr r3, [sp, #568] ; 0x238 <== 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... */
1cbcc: e5cd2038 strb r2, [sp, #56] ; 0x38 <== NOT EXECUTED
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
1cbd0: e2822007 add r2, r2, #7 <== 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);
1cbd4: e1a0e420 lsr lr, r0, #8 <== 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);
1cbd8: e5cdc02f strb ip, [sp, #47] ; 0x2f <== NOT EXECUTED
/* 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);
1cbdc: e1a00423 lsr r0, r3, #8 <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
1cbe0: 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);
1cbe4: e1a03428 lsr r3, r8, #8 <== NOT EXECUTED
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... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
1cbe8: e5cd203a strb r2, [sp, #58] ; 0x3a <== NOT EXECUTED
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
1cbec: e59d201c ldr r2, [sp, #28] <== 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);
1cbf0: e5cd0032 strb r0, [sp, #50] ; 0x32 <== 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);
1cbf4: e5cd3041 strb r3, [sp, #65] ; 0x41 <== NOT EXECUTED
1cbf8: e59d0018 ldr r0, [sp, #24] <== 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);
1cbfc: e59d3220 ldr r3, [sp, #544] ; 0x220 <== NOT EXECUTED
1cc00: e5cde02c strb lr, [sp, #44] ; 0x2c <== NOT EXECUTED
/* 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);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
1cc04: e5cdc035 strb ip, [sp, #53] ; 0x35 <== 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);
1cc08: e59de22c ldr lr, [sp, #556] ; 0x22c <== 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);
1cc0c: e5cd2043 strb r2, [sp, #67] ; 0x43 <== 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);
1cc10: e59dc228 ldr ip, [sp, #552] ; 0x228 <== NOT EXECUTED
/* 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);
1cc14: e59d2238 ldr r2, [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);
1cc18: e5cd0042 strb r0, [sp, #66] ; 0x42 <== 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);
1cc1c: e5cd302b strb r3, [sp, #43] ; 0x2b <== 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);
1cc20: e1a0142b lsr r1, fp, #8 <== 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... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
1cc24: e3a03001 mov r3, #1 <== 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 */
1cc28: e3a00002 mov r0, #2 <== 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);
1cc2c: e5cde02d strb lr, [sp, #45] ; 0x2d <== 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);
1cc30: e5cd1034 strb r1, [sp, #52] ; 0x34 <== 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);
1cc34: e5cdc02e strb ip, [sp, #46] ; 0x2e <== NOT EXECUTED
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
1cc38: e5cd0030 strb r0, [sp, #48] ; 0x30 <== NOT EXECUTED
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
1cc3c: e5cd2031 strb r2, [sp, #49] ; 0x31 <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
1cc40: e5cdb033 strb fp, [sp, #51] ; 0x33 <== NOT EXECUTED
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
1cc44: e5cd9039 strb r9, [sp, #57] ; 0x39 <== NOT EXECUTED
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
1cc48: e5cd903b strb r9, [sp, #59] ; 0x3b <== 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,
1cc4c: e1a07009 mov r7, r9 <== 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... */
1cc50: e5cd303c strb r3, [sp, #60] ; 0x3c <== NOT EXECUTED
1cc54: e5cd903d strb r9, [sp, #61] ; 0x3d <== NOT EXECUTED
1cc58: e5cd903e strb r9, [sp, #62] ; 0x3e <== NOT EXECUTED
1cc5c: e5cd903f strb r9, [sp, #63] ; 0x3f <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
1cc60: e5cd8040 strb r8, [sp, #64] ; 0x40 <== NOT EXECUTED
1cc64: e59d3230 ldr r3, [sp, #560] ; 0x230 <== NOT EXECUTED
if (fmt_params->fattype != FAT_FAT32) {
1cc68: 0a00001b beq 1ccdc <msdos_format+0x784> <== NOT EXECUTED
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 */
1cc6c: e59dc26c ldr ip, [sp, #620] ; 0x26c <== 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);
1cc70: e1a0e423 lsr lr, r3, #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),
1cc74: e28d0e22 add r0, sp, #544 ; 0x220 <== NOT EXECUTED
1cc78: 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 */
1cc7c: e1a0bc2c lsr fp, ip, #24 <== NOT EXECUTED
1cc80: e1a0842c lsr r8, ip, #8 <== NOT EXECUTED
1cc84: e1a0982c lsr r9, ip, #16 <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
1cc88: 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);
1cc8c: e5cde037 strb lr, [sp, #55] ; 0x37 <== 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),
1cc90: e28a002b add r0, sl, #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);
1cc94: e3a0e029 mov lr, #41 ; 0x29 <== 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);
1cc98: e5cd3036 strb r3, [sp, #54] ; 0x36 <== NOT EXECUTED
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
1cc9c: e5cd7045 strb r7, [sp, #69] ; 0x45 <== NOT EXECUTED
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
1cca0: e5cde046 strb lr, [sp, #70] ; 0x46 <== NOT EXECUTED
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
1cca4: e5cd8048 strb r8, [sp, #72] ; 0x48 <== NOT EXECUTED
1cca8: e5cd9049 strb r9, [sp, #73] ; 0x49 <== NOT EXECUTED
1ccac: e5cdb04a strb fp, [sp, #74] ; 0x4a <== 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... */
1ccb0: e5cd7044 strb r7, [sp, #68] ; 0x44 <== NOT EXECUTED
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 */
1ccb4: e5cdc047 strb ip, [sp, #71] ; 0x47 <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
1ccb8: eb008d40 bl 401c0 <memcpy> <== NOT EXECUTED
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
1ccbc: e5dd1252 ldrb r1, [sp, #594] ; 0x252 <== NOT EXECUTED
1ccc0: e59f3514 ldr r3, [pc, #1300] ; 1d1dc <msdos_format+0xc84> <== NOT EXECUTED
1ccc4: e59f2514 ldr r2, [pc, #1300] ; 1d1e0 <msdos_format+0xc88> <== NOT EXECUTED
1ccc8: e3510001 cmp r1, #1 <== NOT EXECUTED
1cccc: 01a01002 moveq r1, r2 <== NOT EXECUTED
1ccd0: 11a01003 movne r1, r3 <== NOT EXECUTED
1ccd4: e28a0036 add r0, sl, #54 ; 0x36 <== NOT EXECUTED
1ccd8: ea000029 b 1cd84 <msdos_format+0x82c> <== 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 */
1ccdc: e59d2248 ldr r2, [sp, #584] ; 0x248 <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
1cce0: e1a0c823 lsr ip, r3, #16 <== NOT EXECUTED
1cce4: e1a0e423 lsr lr, r3, #8 <== NOT EXECUTED
1cce8: e1a08c23 lsr r8, r3, #24 <== NOT EXECUTED
1ccec: e5cdc046 strb ip, [sp, #70] ; 0x46 <== NOT EXECUTED
1ccf0: e5cd3044 strb r3, [sp, #68] ; 0x44 <== 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 */
1ccf4: e3a0c002 mov ip, #2 <== NOT EXECUTED
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 */
1ccf8: e59d3248 ldr r3, [sp, #584] ; 0x248 <== NOT EXECUTED
1ccfc: e1a0b422 lsr fp, r2, #8 <== NOT EXECUTED
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
1cd00: e1a01009 mov r1, r9 <== NOT EXECUTED
1cd04: e3a0200c mov r2, #12 <== 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 */
1cd08: e5cdc04c strb ip, [sp, #76] ; 0x4c <== NOT EXECUTED
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 */
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
1cd0c: e28d0054 add r0, sp, #84 ; 0x54 <== 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*/
1cd10: e3a0c001 mov ip, #1 <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
1cd14: e5cde045 strb lr, [sp, #69] ; 0x45 <== 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*/
1cd18: e5cdc050 strb ip, [sp, #80] ; 0x50 <== NOT EXECUTED
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
1cd1c: e5cd3052 strb r3, [sp, #82] ; 0x52 <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
1cd20: e5cd8047 strb r8, [sp, #71] ; 0x47 <== 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 */
1cd24: e5cdb053 strb fp, [sp, #83] ; 0x53 <== NOT EXECUTED
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_EXT_FLAGS(mbr , 0);
1cd28: e5cd9048 strb r9, [sp, #72] ; 0x48 <== NOT EXECUTED
1cd2c: e5cd9049 strb r9, [sp, #73] ; 0x49 <== NOT EXECUTED
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
1cd30: e5cd904a strb r9, [sp, #74] ; 0x4a <== NOT EXECUTED
1cd34: e5cd904b strb r9, [sp, #75] ; 0x4b <== NOT EXECUTED
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
1cd38: e5cd904d strb r9, [sp, #77] ; 0x4d <== NOT EXECUTED
1cd3c: e5cd904e strb r9, [sp, #78] ; 0x4e <== NOT EXECUTED
1cd40: e5cd904f strb r9, [sp, #79] ; 0x4f <== NOT EXECUTED
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
1cd44: e5cd9051 strb r9, [sp, #81] ; 0x51 <== 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);
1cd48: eb008da3 bl 403dc <memset> <== 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);
1cd4c: e1a01009 mov r1, r9 <== 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);
1cd50: e3a03029 mov r3, #41 ; 0x29 <== NOT EXECUTED
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
1cd54: e3a0200b mov r2, #11 <== NOT EXECUTED
1cd58: e28a0047 add r0, sl, #71 ; 0x47 <== 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);
1cd5c: e5cd3062 strb r3, [sp, #98] ; 0x62 <== NOT EXECUTED
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
1cd60: e5cd9066 strb r9, [sp, #102] ; 0x66 <== NOT EXECUTED
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 */
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... */
1cd64: e5cd9060 strb r9, [sp, #96] ; 0x60 <== NOT EXECUTED
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
1cd68: e5cd9061 strb r9, [sp, #97] ; 0x61 <== NOT EXECUTED
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
1cd6c: e5cd9063 strb r9, [sp, #99] ; 0x63 <== NOT EXECUTED
1cd70: e5cd9064 strb r9, [sp, #100] ; 0x64 <== NOT EXECUTED
1cd74: e5cd9065 strb r9, [sp, #101] ; 0x65 <== NOT EXECUTED
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
1cd78: eb008d97 bl 403dc <memset> <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
1cd7c: e59f1460 ldr r1, [pc, #1120] ; 1d1e4 <msdos_format+0xc8c> <== NOT EXECUTED
1cd80: e28a0052 add r0, sl, #82 ; 0x52 <== NOT EXECUTED
1cd84: e3a02008 mov r2, #8 <== NOT EXECUTED
1cd88: eb008d0c bl 401c0 <memcpy> <== NOT EXECUTED
FAT_BR_FILSYSTYPE_SIZE);
}
/*
* add boot record signature
*/
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
1cd8c: e3a03055 mov r3, #85 ; 0x55 <== NOT EXECUTED
1cd90: e5cd321e strb r3, [sp, #542] ; 0x21e <== NOT EXECUTED
1cd94: e3e03055 mvn r3, #85 ; 0x55 <== NOT EXECUTED
1cd98: e5cd321f strb r3, [sp, #543] ; 0x21f <== NOT EXECUTED
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
1cd9c: e2833041 add r3, r3, #65 ; 0x41 <== NOT EXECUTED
1cda0: e5cd3020 strb r3, [sp, #32] <== NOT EXECUTED
FAT_SET_VAL8(mbr,1,0x3c);
1cda4: e2833051 add r3, r3, #81 ; 0x51 <== 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,
1cda8: e1a00004 mov r0, r4 <== NOT EXECUTED
1cdac: e3a01002 mov r1, #2 <== NOT EXECUTED
1cdb0: e59f2430 ldr r2, [pc, #1072] ; 1d1e8 <msdos_format+0xc90> <== NOT EXECUTED
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
FAT_SET_VAL8(mbr,1,0x3c);
1cdb4: e5cd3021 strb r3, [sp, #33] ; 0x21 <== 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,
1cdb8: e28d8020 add r8, sp, #32 <== 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);
1cdbc: e3e0306f mvn r3, #111 ; 0x6f <== NOT EXECUTED
1cdc0: e5cd3022 strb r3, [sp, #34] ; 0x22 <== 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,
1cdc4: ebfffd6e bl 1c384 <msdos_format_printf> <== NOT EXECUTED
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
1cdc8: e1a00005 mov r0, r5 <== NOT EXECUTED
1cdcc: e3a01000 mov r1, #0 <== NOT EXECUTED
1cdd0: e59d2220 ldr r2, [sp, #544] ; 0x220 <== NOT EXECUTED
1cdd4: e1a03008 mov r3, r8 <== NOT EXECUTED
1cdd8: ebfffd7e bl 1c3d8 <msdos_format_write_sec> <== NOT EXECUTED
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
1cddc: e2507000 subs r7, r0, #0 <== NOT EXECUTED
1cde0: 1a0000b2 bne 1d0b0 <msdos_format+0xb58> <== NOT EXECUTED
1cde4: e59d3248 ldr r3, [sp, #584] ; 0x248 <== NOT EXECUTED
1cde8: e3530000 cmp r3, #0 <== NOT EXECUTED
1cdec: 0a00000a beq 1ce1c <msdos_format+0x8c4> <== NOT EXECUTED
(fmt_params.mbr_copy_sec != 0)) {
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1cdf0: e3a01002 mov r1, #2 <== NOT EXECUTED
1cdf4: e59f23f0 ldr r2, [pc, #1008] ; 1d1ec <msdos_format+0xc94> <== NOT EXECUTED
1cdf8: e1a00004 mov r0, r4 <== NOT EXECUTED
1cdfc: ebfffd60 bl 1c384 <msdos_format_printf> <== NOT EXECUTED
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
1ce00: e1a00005 mov r0, r5 <== NOT EXECUTED
1ce04: e1a03008 mov r3, r8 <== NOT EXECUTED
1ce08: e59d1248 ldr r1, [sp, #584] ; 0x248 <== NOT EXECUTED
1ce0c: e59d2220 ldr r2, [sp, #544] ; 0x220 <== NOT EXECUTED
1ce10: ebfffd70 bl 1c3d8 <msdos_format_write_sec> <== NOT EXECUTED
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
1ce14: e2507000 subs r7, r0, #0 <== NOT EXECUTED
1ce18: 1a0000a4 bne 1d0b0 <msdos_format+0xb58> <== NOT EXECUTED
1ce1c: e59d324c ldr r3, [sp, #588] ; 0x24c <== NOT EXECUTED
1ce20: e3530000 cmp r3, #0 <== NOT EXECUTED
1ce24: 0a0000d9 beq 1d190 <msdos_format+0xc38> <== NOT EXECUTED
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
1ce28: e3a01000 mov r1, #0 <== NOT EXECUTED
1ce2c: e3a02c02 mov r2, #512 ; 0x200 <== NOT EXECUTED
1ce30: e28d0020 add r0, sp, #32 <== NOT EXECUTED
1ce34: eb008d68 bl 403dc <memset> <== 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);
1ce38: e3a0e055 mov lr, #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,
1ce3c: 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 );
1ce40: e3a0c052 mov ip, #82 ; 0x52 <== NOT EXECUTED
1ce44: e3a00061 mov r0, #97 ; 0x61 <== NOT EXECUTED
1ce48: e3a01041 mov r1, #65 ; 0x41 <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
1ce4c: e3a02072 mov r2, #114 ; 0x72 <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
1ce50: e5cde21e strb lr, [sp, #542] ; 0x21e <== NOT EXECUTED
1ce54: e3e0e055 mvn lr, #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 );
1ce58: e5cdc021 strb ip, [sp, #33] ; 0x21 <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
1ce5c: e5cd2205 strb r2, [sp, #517] ; 0x205 <== NOT EXECUTED
1ce60: e5cd1206 strb r1, [sp, #518] ; 0x206 <== NOT EXECUTED
1ce64: e5cd0207 strb r0, [sp, #519] ; 0x207 <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
1ce68: e5cde21f strb lr, [sp, #543] ; 0x21f <== 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,
1ce6c: e5cd320f strb r3, [sp, #527] ; 0x20f <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
1ce70: e5cdc020 strb ip, [sp, #32] <== NOT EXECUTED
1ce74: e5cd0022 strb r0, [sp, #34] ; 0x22 <== NOT EXECUTED
1ce78: e5cd1023 strb r1, [sp, #35] ; 0x23 <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
1ce7c: e5cd2204 strb r2, [sp, #516] ; 0x204 <== 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,
1ce80: e5cd3208 strb r3, [sp, #520] ; 0x208 <== NOT EXECUTED
1ce84: e5cd3209 strb r3, [sp, #521] ; 0x209 <== NOT EXECUTED
1ce88: e5cd320a strb r3, [sp, #522] ; 0x20a <== NOT EXECUTED
1ce8c: e5cd320b strb r3, [sp, #523] ; 0x20b <== NOT EXECUTED
0xffffffff);
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
1ce90: e5cd320c strb r3, [sp, #524] ; 0x20c <== NOT EXECUTED
1ce94: e5cd320d strb r3, [sp, #525] ; 0x20d <== NOT EXECUTED
1ce98: e5cd320e strb r3, [sp, #526] ; 0x20e <== NOT EXECUTED
1ce9c: ea0000bb b 1d190 <msdos_format+0xc38> <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
1cea0: e1a00005 mov r0, r5 <== NOT EXECUTED
1cea4: e59d2220 ldr r2, [sp, #544] ; 0x220 <== NOT EXECUTED
1cea8: e28d3020 add r3, sp, #32 <== NOT EXECUTED
1ceac: ebfffd49 bl 1c3d8 <msdos_format_write_sec> <== NOT EXECUTED
}
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
1ceb0: e2507000 subs r7, r0, #0 <== NOT EXECUTED
1ceb4: 1a00007d bne 1d0b0 <msdos_format+0xb58> <== NOT EXECUTED
ret_val = msdos_format_fill_sectors
1ceb8: e59d2230 ldr r2, [sp, #560] ; 0x230 <== NOT EXECUTED
1cebc: e59dc220 ldr ip, [sp, #544] ; 0x220 <== NOT EXECUTED
1cec0: e5dd3250 ldrb r3, [sp, #592] ; 0x250 <== NOT EXECUTED
1cec4: e58dc000 str ip, [sp] <== NOT EXECUTED
1cec8: e0030392 mul r3, r2, r3 <== NOT EXECUTED
1cecc: e3a0c000 mov ip, #0 <== NOT EXECUTED
1ced0: e1a00004 mov r0, r4 <== NOT EXECUTED
1ced4: e1a01005 mov r1, r5 <== NOT EXECUTED
1ced8: e59d2228 ldr r2, [sp, #552] ; 0x228 <== NOT EXECUTED
1cedc: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
1cee0: ebfffd50 bl 1c428 <msdos_format_fill_sectors> <== NOT EXECUTED
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
1cee4: e2507000 subs r7, r0, #0 <== NOT EXECUTED
1cee8: 1a000070 bne 1d0b0 <msdos_format+0xb58> <== NOT EXECUTED
ret_val = msdos_format_fill_sectors
1ceec: e59dc220 ldr ip, [sp, #544] ; 0x220 <== NOT EXECUTED
1cef0: e1a00004 mov r0, r4 <== NOT EXECUTED
1cef4: e1a01005 mov r1, r5 <== NOT EXECUTED
1cef8: e28d2d09 add r2, sp, #576 ; 0x240 <== NOT EXECUTED
1cefc: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
1cf00: e58d7004 str r7, [sp, #4] <== NOT EXECUTED
1cf04: e58dc000 str ip, [sp] <== NOT EXECUTED
1cf08: ebfffd46 bl 1c428 <msdos_format_fill_sectors> <== NOT EXECUTED
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
1cf0c: e2507000 subs r7, r0, #0 <== NOT EXECUTED
1cf10: 1a000066 bne 1d0b0 <msdos_format+0xb58> <== NOT EXECUTED
1cf14: e5dd3268 ldrb r3, [sp, #616] ; 0x268 <== NOT EXECUTED
1cf18: e3530000 cmp r3, #0 <== NOT EXECUTED
1cf1c: 0a000014 beq 1cf74 <msdos_format+0xa1c> <== NOT EXECUTED
memset(tmp_sec,0,sizeof(tmp_sec));
1cf20: e28d4020 add r4, sp, #32 <== NOT EXECUTED
1cf24: e1a01007 mov r1, r7 <== NOT EXECUTED
1cf28: e3a02c02 mov r2, #512 ; 0x200 <== NOT EXECUTED
1cf2c: e1a00004 mov r0, r4 <== NOT EXECUTED
1cf30: eb008d29 bl 403dc <memset> <== NOT EXECUTED
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
1cf34: e28d3f97 add r3, sp, #604 ; 0x25c <== NOT EXECUTED
1cf38: e8930007 ldm r3, {r0, r1, r2} <== NOT EXECUTED
1cf3c: e1a0c004 mov ip, r4 <== NOT EXECUTED
1cf40: e8ac0003 stmia ip!, {r0, r1} <== NOT EXECUTED
1cf44: e1cc20b0 strh r2, [ip] <== NOT EXECUTED
1cf48: e1a0c822 lsr ip, r2, #16 <== NOT EXECUTED
1cf4c: e5cdc02a strb ip, [sp, #42] ; 0x2a <== NOT EXECUTED
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
1cf50: e1a03004 mov r3, r4 <== 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;
1cf54: e3a0c008 mov ip, #8 <== NOT EXECUTED
ret_val = msdos_format_write_sec
1cf58: e1a00005 mov r0, r5 <== NOT EXECUTED
1cf5c: e59d1240 ldr r1, [sp, #576] ; 0x240 <== NOT EXECUTED
1cf60: e59d2220 ldr r2, [sp, #544] ; 0x220 <== 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;
1cf64: e5cdc02b strb ip, [sp, #43] ; 0x2b <== NOT EXECUTED
ret_val = msdos_format_write_sec
1cf68: ebfffd1a bl 1c3d8 <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){
1cf6c: e3500000 cmp r0, #0 <== NOT EXECUTED
1cf70: 1a00004d bne 1d0ac <msdos_format+0xb54> <== NOT EXECUTED
1cf74: e5dd3268 ldrb r3, [sp, #616] ; 0x268 <== NOT EXECUTED
1cf78: e3530000 cmp r3, #0 <== NOT EXECUTED
1cf7c: 0a00004b beq 1d0b0 <msdos_format+0xb58> <== NOT EXECUTED
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
1cf80: e28d0020 add r0, sp, #32 <== NOT EXECUTED
1cf84: e3a01000 mov r1, #0 <== NOT EXECUTED
1cf88: e3a02c02 mov r2, #512 ; 0x200 <== NOT EXECUTED
1cf8c: eb008d12 bl 403dc <memset> <== NOT EXECUTED
switch(fmt_params.fattype) {
1cf90: e5dd3252 ldrb r3, [sp, #594] ; 0x252 <== NOT EXECUTED
1cf94: e3530002 cmp r3, #2 <== NOT EXECUTED
1cf98: 0a00000a beq 1cfc8 <msdos_format+0xa70> <== NOT EXECUTED
1cf9c: e3530004 cmp r3, #4 <== NOT EXECUTED
1cfa0: 0a000010 beq 1cfe8 <msdos_format+0xa90> <== NOT EXECUTED
1cfa4: e3530001 cmp r3, #1 <== NOT EXECUTED
1cfa8: 1a00001e bne 1d028 <msdos_format+0xad0> <== NOT EXECUTED
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
1cfac: e5dd3251 ldrb r3, [sp, #593] ; 0x251 <== NOT EXECUTED
1cfb0: e5cd3020 strb r3, [sp, #32] <== 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)));
1cfb4: e3e03070 mvn r3, #112 ; 0x70 <== NOT EXECUTED
1cfb8: e5cd3021 strb r3, [sp, #33] ; 0x21 <== NOT EXECUTED
/* MSBits of FAT entry 1: MSBits of EOC */
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
1cfbc: e2833070 add r3, r3, #112 ; 0x70 <== NOT EXECUTED
1cfc0: e5cd3022 strb r3, [sp, #34] ; 0x22 <== NOT EXECUTED
break;
1cfc4: ea00001b b 1d038 <msdos_format+0xae0> <== NOT EXECUTED
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL16(tmp_sec,0,0xff00|fmt_params.media_code);
1cfc8: e5dd2251 ldrb r2, [sp, #593] ; 0x251 <== NOT EXECUTED
1cfcc: e3e03000 mvn r3, #0 <== NOT EXECUTED
1cfd0: e5cd2020 strb r2, [sp, #32] <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
1cfd4: e3e02007 mvn r2, #7 <== NOT EXECUTED
1cfd8: e5cd2022 strb r2, [sp, #34] ; 0x22 <== NOT EXECUTED
1cfdc: e5cd3023 strb r3, [sp, #35] ; 0x23 <== 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);
1cfe0: e5cd3021 strb r3, [sp, #33] ; 0x21 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
1cfe4: ea000013 b 1d038 <msdos_format+0xae0> <== NOT EXECUTED
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
1cfe8: e5dd2251 ldrb r2, [sp, #593] ; 0x251 <== NOT EXECUTED
1cfec: e1e02c02 mvn r2, r2, lsl #24 <== NOT EXECUTED
1cff0: e1e02c22 mvn r2, r2, lsr #24 <== NOT EXECUTED
1cff4: e1a01c22 lsr r1, r2, #24 <== NOT EXECUTED
1cff8: e5cd1021 strb r1, [sp, #33] ; 0x21 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
1cffc: 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);
1d000: e3e03000 mvn r3, #0 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
1d004: e5cd1024 strb r1, [sp, #36] ; 0x24 <== NOT EXECUTED
1d008: e2811017 add r1, r1, #23 <== NOT EXECUTED
1d00c: e5cd3026 strb r3, [sp, #38] ; 0x26 <== NOT EXECUTED
1d010: e5cd1027 strb r1, [sp, #39] ; 0x27 <== 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);
1d014: e5cd2020 strb r2, [sp, #32] <== NOT EXECUTED
1d018: e5cd3022 strb r3, [sp, #34] ; 0x22 <== NOT EXECUTED
1d01c: e5cd3023 strb r3, [sp, #35] ; 0x23 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
1d020: e5cd3025 strb r3, [sp, #37] ; 0x25 <== NOT EXECUTED
break;
1d024: ea000003 b 1d038 <msdos_format+0xae0> <== NOT EXECUTED
default:
ret_val = -1;
errno = EINVAL;
1d028: eb007fb4 bl 3cf00 <__errno> <== NOT EXECUTED
1d02c: e3a03016 mov r3, #22 <== NOT EXECUTED
1d030: e5803000 str r3, [r0] <== NOT EXECUTED
1d034: e3e07000 mvn r7, #0 <== NOT EXECUTED
}
if (fmt_params.fattype == FAT_FAT32) {
1d038: e5dd3252 ldrb r3, [sp, #594] ; 0x252 <== NOT EXECUTED
1d03c: e3530004 cmp r3, #4 <== NOT EXECUTED
1d040: 1a000006 bne 1d060 <msdos_format+0xb08> <== 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);
1d044: e3e02007 mvn r2, #7 <== NOT EXECUTED
1d048: e3e03000 mvn r3, #0 <== NOT EXECUTED
1d04c: e5cd2028 strb r2, [sp, #40] ; 0x28 <== NOT EXECUTED
1d050: e2822017 add r2, r2, #23 <== NOT EXECUTED
1d054: e5cd302a strb r3, [sp, #42] ; 0x2a <== NOT EXECUTED
1d058: e5cd202b strb r2, [sp, #43] ; 0x2b <== NOT EXECUTED
1d05c: e5cd3029 strb r3, [sp, #41] ; 0x29 <== NOT EXECUTED
1d060: e3a04000 mov r4, #0 <== NOT EXECUTED
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
1d064: e28d8020 add r8, sp, #32 <== NOT EXECUTED
1d068: e1a00007 mov r0, r7 <== NOT EXECUTED
1d06c: ea000007 b 1d090 <msdos_format+0xb38> <== NOT EXECUTED
1d070: e59d3228 ldr r3, [sp, #552] ; 0x228 <== NOT EXECUTED
1d074: e59d1230 ldr r1, [sp, #560] ; 0x230 <== NOT EXECUTED
1d078: e1a00005 mov r0, r5 <== NOT EXECUTED
1d07c: e0213194 mla r1, r4, r1, r3 <== NOT EXECUTED
1d080: e59d2220 ldr r2, [sp, #544] ; 0x220 <== NOT EXECUTED
1d084: e1a03008 mov r3, r8 <== NOT EXECUTED
1d088: ebfffcd2 bl 1c3d8 <msdos_format_write_sec> <== NOT EXECUTED
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
1d08c: e2844001 add r4, r4, #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;
1d090: e5dd2250 ldrb r2, [sp, #592] ; 0x250 <== NOT EXECUTED
1d094: e2703001 rsbs r3, r0, #1 <== NOT EXECUTED
1d098: 33a03000 movcc r3, #0 <== NOT EXECUTED
1d09c: e1540002 cmp r4, r2 <== NOT EXECUTED
1d0a0: a3a03000 movge r3, #0 <== NOT EXECUTED
1d0a4: e3530000 cmp r3, #0 <== NOT EXECUTED
1d0a8: 1afffff0 bne 1d070 <msdos_format+0xb18> <== NOT EXECUTED
1d0ac: e1a07000 mov r7, r0 <== NOT EXECUTED
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
1d0b0: e3750001 cmn r5, #1 <== NOT EXECUTED
close(fd);
1d0b4: 11a00005 movne r0, r5 <== NOT EXECUTED
1d0b8: 1bffa85d blne 7234 <close> <== NOT EXECUTED
}
if (dd != NULL) {
1d0bc: e3560000 cmp r6, #0 <== NOT EXECUTED
rtems_disk_release(dd);
1d0c0: 11a00006 movne r0, r6 <== NOT EXECUTED
1d0c4: 1bffa4f0 blne 648c <rtems_disk_release> <== NOT EXECUTED
}
return ret_val;
}
1d0c8: e1a00007 mov r0, r7 <== NOT EXECUTED
1d0cc: e28ddfb1 add sp, sp, #708 ; 0x2c4 <== NOT EXECUTED
1d0d0: 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);
1d0d4: e28d1fa2 add r1, sp, #648 ; 0x288 <== NOT EXECUTED
1d0d8: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
1d0dc: ebffa46e bl 629c <rtems_disk_obtain> <== NOT EXECUTED
if (dd == NULL) {
1d0e0: e2506000 subs r6, r0, #0 <== NOT EXECUTED
1d0e4: 0afffd38 beq 1c5cc <msdos_format+0x74> <== NOT EXECUTED
/*
* open device for writing
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1d0e8: e3a01002 mov r1, #2 <== NOT EXECUTED
1d0ec: e59f20fc ldr r2, [pc, #252] ; 1d1f0 <msdos_format+0xc98> <== NOT EXECUTED
1d0f0: e1a00004 mov r0, r4 <== NOT EXECUTED
1d0f4: ebfffca2 bl 1c384 <msdos_format_printf> <== NOT EXECUTED
"open device\n");
fd = open(devname, O_RDWR);
1d0f8: e1a00005 mov r0, r5 <== NOT EXECUTED
1d0fc: e3a01002 mov r1, #2 <== NOT EXECUTED
1d100: ebffad91 bl 874c <open> <== NOT EXECUTED
if (fd == -1)
1d104: 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);
1d108: e1a05000 mov r5, r0 <== NOT EXECUTED
if (fd == -1)
1d10c: 01a07000 moveq r7, r0 <== NOT EXECUTED
1d110: 0afffd31 beq 1c5dc <msdos_format+0x84> <== 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));
1d114: e1a01007 mov r1, r7 <== NOT EXECUTED
1d118: e3a02050 mov r2, #80 ; 0x50 <== NOT EXECUTED
1d11c: e28d0e22 add r0, sp, #544 ; 0x220 <== NOT EXECUTED
1d120: eb008cad bl 403dc <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;
1d124: e5963020 ldr r3, [r6, #32] <== NOT EXECUTED
1d128: e58d3220 str r3, [sp, #544] ; 0x220 <== NOT EXECUTED
fmt_params->totl_sector_cnt = dd->size;
1d12c: e596c01c ldr ip, [r6, #28] <== NOT EXECUTED
total_size = dd->block_size * dd->size;
1d130: e0070c93 mul r7, r3, ip <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1d134: e1a00004 mov r0, r4 <== 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;
1d138: e3a08000 mov r8, #0 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1d13c: e3a01002 mov r1, #2 <== NOT EXECUTED
1d140: e59f20ac ldr r2, [pc, #172] ; 1d1f4 <msdos_format+0xc9c> <== NOT EXECUTED
1d144: 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;
1d148: e58dc224 str ip, [sp, #548] ; 0x224 <== NOT EXECUTED
total_size = dd->block_size * dd->size;
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1d14c: e98d0180 stmib sp, {r7, r8} <== NOT EXECUTED
1d150: ebfffc8b bl 1c384 <msdos_format_printf> <== NOT EXECUTED
}
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
1d154: e3540000 cmp r4, #0 <== NOT EXECUTED
1d158: 1afffd21 bne 1c5e4 <msdos_format+0x8c> <== NOT EXECUTED
1d15c: eafffd23 b 1c5f0 <msdos_format+0x98> <== NOT EXECUTED
1d160: e3a07000 mov r7, #0 <== NOT EXECUTED
1d164: eafffe55 b 1cac0 <msdos_format+0x568> <== 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,
1d168: e1a00004 mov r0, r4 <== NOT EXECUTED
1d16c: e3a01002 mov r1, #2 <== NOT EXECUTED
1d170: e59f2080 ldr r2, [pc, #128] ; 1d1f8 <msdos_format+0xca0> <== NOT EXECUTED
1d174: ebfffc82 bl 1c384 <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) {
1d178: e59d8224 ldr r8, [sp, #548] ; 0x224 <== NOT EXECUTED
1d17c: e3580801 cmp r8, #65536 ; 0x10000 <== NOT EXECUTED
1d180: 31a0b008 movcc fp, r8 <== NOT EXECUTED
1d184: 33a08000 movcc r8, #0 <== NOT EXECUTED
1d188: 3afffe75 bcc 1cb64 <msdos_format+0x60c> <== NOT EXECUTED
1d18c: eafffe73 b 1cb60 <msdos_format+0x608> <== NOT EXECUTED
}
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
1d190: e59d124c ldr r1, [sp, #588] ; 0x24c <== NOT EXECUTED
ret_val = msdos_format_gen_fsinfo(tmp_sec);
}
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
1d194: e3510000 cmp r1, #0 <== NOT EXECUTED
1d198: 0affff46 beq 1ceb8 <msdos_format+0x960> <== NOT EXECUTED
1d19c: eaffff3f b 1cea0 <msdos_format+0x948> <== NOT EXECUTED
0001c428 <msdos_format_fill_sectors>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
1c428: e92d4ff3 push {r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
1c42c: e1a06000 mov r6, r0 <== NOT EXECUTED
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
1c430: e59d002c ldr r0, [sp, #44] ; 0x2c <== NOT EXECUTED
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
1c434: e58d1004 str r1, [sp, #4] <== NOT EXECUTED
1c438: e1a05002 mov r5, r2 <== NOT EXECUTED
1c43c: e1a0a003 mov sl, r3 <== NOT EXECUTED
1c440: e5dd4030 ldrb r4, [sp, #48] ; 0x30 <== NOT EXECUTED
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
1c444: ebffae41 bl 7d50 <malloc> <== NOT EXECUTED
if (fill_buffer == NULL) {
1c448: e250b000 subs fp, r0, #0 <== NOT EXECUTED
1c44c: 1a000004 bne 1c464 <msdos_format_fill_sectors+0x3c> <== NOT EXECUTED
errno = ENOMEM;
1c450: eb0082aa bl 3cf00 <__errno> <== NOT EXECUTED
1c454: e3a0300c mov r3, #12 <== NOT EXECUTED
1c458: e5803000 str r3, [r0] <== NOT EXECUTED
1c45c: e3e04000 mvn r4, #0 <== NOT EXECUTED
1c460: ea000003 b 1c474 <msdos_format_fill_sectors+0x4c> <== NOT EXECUTED
ret_val = -1;
}
else {
memset(fill_buffer,fill_byte,sector_size);
1c464: e1a01004 mov r1, r4 <== NOT EXECUTED
1c468: e59d202c ldr r2, [sp, #44] ; 0x2c <== NOT EXECUTED
1c46c: eb008fda bl 403dc <memset> <== NOT EXECUTED
1c470: e3a04000 mov r4, #0 <== NOT EXECUTED
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1c474: e1a00006 mov r0, r6 <== NOT EXECUTED
1c478: e3a01002 mov r1, #2 <== NOT EXECUTED
1c47c: e59f20c4 ldr r2, [pc, #196] ; 1c548 <msdos_format_fill_sectors+0x120><== NOT EXECUTED
1c480: ebffffbf bl 1c384 <msdos_format_printf> <== NOT EXECUTED
1c484: e3a03064 mov r3, #100 ; 0x64 <== NOT EXECUTED
1c488: e0080a93 mul r8, r3, sl <== NOT EXECUTED
1c48c: e1a0900a mov r9, sl <== NOT EXECUTED
1c490: e3e03000 mvn r3, #0 <== NOT EXECUTED
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
1c494: ea000014 b 1c4ec <msdos_format_fill_sectors+0xc4> <== NOT EXECUTED
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
1c498: e58d3000 str r3, [sp] <== NOT EXECUTED
1c49c: eb00e255 bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
if (percent != last_percent) {
1c4a0: e59d3000 ldr r3, [sp] <== NOT EXECUTED
1c4a4: e1500003 cmp r0, r3 <== NOT EXECUTED
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
1c4a8: e1a07000 mov r7, r0 <== NOT EXECUTED
if (percent != last_percent) {
1c4ac: 0a000004 beq 1c4c4 <msdos_format_fill_sectors+0x9c> <== NOT EXECUTED
if ((percent & 1) == 0)
1c4b0: e3100001 tst r0, #1 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
1c4b4: 01a00006 moveq r0, r6 <== NOT EXECUTED
1c4b8: 03a01002 moveq r1, #2 <== NOT EXECUTED
1c4bc: 059f2088 ldreq r2, [pc, #136] ; 1c54c <msdos_format_fill_sectors+0x124><== NOT EXECUTED
1c4c0: 0bffffaf bleq 1c384 <msdos_format_printf> <== NOT EXECUTED
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
1c4c4: e1a01005 mov r1, r5 <== NOT EXECUTED
1c4c8: e1a0300b mov r3, fp <== NOT EXECUTED
1c4cc: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
1c4d0: e59d202c ldr r2, [sp, #44] ; 0x2c <== NOT EXECUTED
1c4d4: ebffffbf bl 1c3d8 <msdos_format_write_sec> <== NOT EXECUTED
start_sector++;
1c4d8: e2855001 add r5, r5, #1 <== 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);
1c4dc: e1a04000 mov r4, r0 <== NOT EXECUTED
start_sector++;
sector_cnt--;
1c4e0: e2499001 sub r9, r9, #1 <== NOT EXECUTED
1c4e4: e2488064 sub r8, r8, #100 ; 0x64 <== NOT EXECUTED
1c4e8: e1a03007 mov r3, r7 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
1c4ec: e2592000 subs r2, r9, #0 <== NOT EXECUTED
1c4f0: 13a02001 movne r2, #1 <== NOT EXECUTED
1c4f4: e3540000 cmp r4, #0 <== NOT EXECUTED
1c4f8: 13a02000 movne r2, #0 <== NOT EXECUTED
1c4fc: e3520000 cmp r2, #0 <== NOT EXECUTED
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
1c500: e1a0100a mov r1, sl <== NOT EXECUTED
1c504: e1a00008 mov r0, r8 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
1c508: 1affffe2 bne 1c498 <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");
1c50c: e1a00006 mov r0, r6 <== NOT EXECUTED
1c510: e3a01002 mov r1, #2 <== NOT EXECUTED
1c514: e59f2034 ldr r2, [pc, #52] ; 1c550 <msdos_format_fill_sectors+0x128><== NOT EXECUTED
1c518: ebffff99 bl 1c384 <msdos_format_printf> <== NOT EXECUTED
if (ret_val)
1c51c: e3540000 cmp r4, #0 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
1c520: 11a00006 movne r0, r6 <== NOT EXECUTED
1c524: 11a03005 movne r3, r5 <== NOT EXECUTED
1c528: 13a01001 movne r1, #1 <== NOT EXECUTED
1c52c: 159f2020 ldrne r2, [pc, #32] ; 1c554 <msdos_format_fill_sectors+0x12c><== NOT EXECUTED
1c530: 1bffff93 blne 1c384 <msdos_format_printf> <== NOT EXECUTED
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
1c534: e35b0000 cmp fp, #0 <== NOT EXECUTED
free(fill_buffer);
1c538: 11a0000b movne r0, fp <== NOT EXECUTED
1c53c: 1bffac5c blne 76b4 <free> <== NOT EXECUTED
fill_buffer = NULL;
}
return ret_val;
}
1c540: e1a00004 mov r0, r4 <== NOT EXECUTED
1c544: e8bd8ffc pop {r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0001c384 <msdos_format_printf>:
*/
static void
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
1c384: e92d000c push {r2, r3} <== NOT EXECUTED
1c388: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
va_list args;
va_start (args, format);
if (rqdata != NULL && rqdata->info_level >= info_level)
1c38c: 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);
1c390: e28d2010 add r2, sp, #16 <== NOT EXECUTED
1c394: e58d2000 str r2, [sp] <== NOT EXECUTED
if (rqdata != NULL && rqdata->info_level >= info_level)
1c398: 0a00000a beq 1c3c8 <msdos_format_printf+0x44> <== NOT EXECUTED
1c39c: e590301c ldr r3, [r0, #28] <== NOT EXECUTED
1c3a0: e1530001 cmp r3, r1 <== NOT EXECUTED
1c3a4: ba000007 blt 1c3c8 <msdos_format_printf+0x44> <== NOT EXECUTED
{
vfprintf (stdout, format, args);
1c3a8: e59f4024 ldr r4, [pc, #36] ; 1c3d4 <msdos_format_printf+0x50><== NOT EXECUTED
1c3ac: e5943000 ldr r3, [r4] <== NOT EXECUTED
1c3b0: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED
1c3b4: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
1c3b8: eb00bded bl 4bb74 <vfprintf> <== NOT EXECUTED
fflush (stdout);
1c3bc: e5943000 ldr r3, [r4] <== NOT EXECUTED
1c3c0: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
1c3c4: eb0083c0 bl 3d2cc <fflush> <== NOT EXECUTED
}
va_end (args);
}
1c3c8: e8bd4018 pop {r3, r4, lr} <== NOT EXECUTED
1c3cc: e28dd008 add sp, sp, #8 <== NOT EXECUTED
1c3d0: e12fff1e bx lr <== NOT EXECUTED
0001c3d8 <msdos_format_write_sec>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
1c3d8: 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)) {
1c3dc: e0876192 umull r6, r7, r2, r1 <== NOT EXECUTED
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
1c3e0: e1a04002 mov r4, r2 <== NOT EXECUTED
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
1c3e4: e1a01006 mov r1, r6 <== NOT EXECUTED
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
1c3e8: e1a05003 mov r5, r3 <== NOT EXECUTED
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
1c3ec: e1a02007 mov r2, r7 <== NOT EXECUTED
1c3f0: e3a03000 mov r3, #0 <== NOT EXECUTED
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
1c3f4: e1a06000 mov r6, r0 <== NOT EXECUTED
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
1c3f8: eb0026d1 bl 25f44 <lseek> <== NOT EXECUTED
1c3fc: e3510000 cmp r1, #0 <== NOT EXECUTED
1c400: ba000006 blt 1c420 <msdos_format_write_sec+0x48> <== NOT EXECUTED
ret_val = -1;
}
if (ret_val == 0) {
if (0 > write(fd,buffer,sector_size)) {
1c404: e1a00006 mov r0, r6 <== NOT EXECUTED
1c408: e1a01005 mov r1, r5 <== NOT EXECUTED
1c40c: e1a02004 mov r2, r4 <== NOT EXECUTED
1c410: ebffbad8 bl af78 <write> <== NOT EXECUTED
1c414: e3500000 cmp r0, #0 <== NOT EXECUTED
1c418: a3a00000 movge r0, #0 <== NOT EXECUTED
1c41c: a8bd80f0 popge {r4, r5, r6, r7, pc} <== NOT EXECUTED
1c420: e3e00000 mvn r0, #0 <== NOT EXECUTED
ret_val = -1;
}
}
return ret_val;
}
1c424: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00031d48 <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;
31d48: 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)
{
31d4c: 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;
31d50: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
31d54: 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)
{
31d58: 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,
31d5c: e1a02001 mov r2, r1 <== NOT EXECUTED
31d60: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
31d64: ebff66d5 bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
31d68: e3500000 cmp r0, #0 <== NOT EXECUTED
31d6c: 0a000004 beq 31d84 <msdos_free_node_info+0x3c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
31d70: eb002c62 bl 3cf00 <__errno> <== NOT EXECUTED
31d74: e3a03005 mov r3, #5 <== NOT EXECUTED
31d78: e5803000 str r3, [r0] <== NOT EXECUTED
31d7c: e3e04000 mvn r4, #0 <== NOT EXECUTED
31d80: ea000005 b 31d9c <msdos_free_node_info+0x54> <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, pathloc->node_access);
31d84: e5941000 ldr r1, [r4] <== NOT EXECUTED
31d88: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
31d8c: ebffc149 bl 222b8 <fat_file_close> <== NOT EXECUTED
31d90: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
31d94: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
31d98: ebff670e bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
31d9c: e1a00004 mov r0, r4 <== NOT EXECUTED
31da0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00032f38 <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
)
{
32f38: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
32f3c: 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;
32f40: e28dc058 add ip, sp, #88 ; 0x58 <== NOT EXECUTED
32f44: e3a0e000 mov lr, #0 <== NOT EXECUTED
32f48: e52ce004 str lr, [ip, #-4]! <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
32f4c: e1a06002 mov r6, r2 <== NOT EXECUTED
32f50: e1a07001 mov r7, r1 <== NOT EXECUTED
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
32f54: e1a0200c mov r2, ip <== NOT EXECUTED
32f58: e1a01006 mov r1, r6 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
32f5c: e1a05000 mov r5, r0 <== NOT EXECUTED
32f60: e58d3010 str r3, [sp, #16] <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
32f64: e5909034 ldr r9, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
32f68: ebffbcfb bl 2235c <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
32f6c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
32f70: 1a00006f bne 33134 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1fc><== NOT EXECUTED
return rc;
fat_fd->cln = cln;
32f74: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
32f78: 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;
32f7c: e3a08001 mov r8, #1 <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
32f80: 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;
32f84: e5813014 str r3, [r1, #20] <== NOT EXECUTED
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
32f88: e5817038 str r7, [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;
32f8c: e581701c str r7, [r1, #28] <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
32f90: e5818010 str r8, [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);
32f94: e1a00005 mov r0, r5 <== NOT EXECUTED
32f98: ebffba3e bl 21898 <fat_file_size> <== NOT EXECUTED
if (rc != RC_OK)
32f9c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
32fa0: 1a00005b bne 33114 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1dc><== 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);
32fa4: e28da034 add sl, sp, #52 ; 0x34 <== NOT EXECUTED
32fa8: e1a01004 mov r1, r4 <== NOT EXECUTED
32fac: e3a02020 mov r2, #32 <== NOT EXECUTED
32fb0: e1a0000a mov r0, sl <== NOT EXECUTED
32fb4: eb003508 bl 403dc <memset> <== NOT EXECUTED
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
32fb8: e1a01008 mov r1, r8 <== NOT EXECUTED
32fbc: e1a0200a mov r2, sl <== NOT EXECUTED
32fc0: e3a0300b mov r3, #11 <== NOT EXECUTED
32fc4: e59f0174 ldr r0, [pc, #372] ; 33140 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x208><== NOT EXECUTED
32fc8: ebffff74 bl 32da0 <msdos_long_to_short> <== NOT EXECUTED
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
32fcc: e1a02004 mov r2, r4 <== NOT EXECUTED
32fd0: e1a00005 mov r0, r5 <== NOT EXECUTED
32fd4: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED
32fd8: e59f3160 ldr r3, [pc, #352] ; 33140 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x208><== NOT EXECUTED
32fdc: e58d8000 str r8, [sp] <== NOT EXECUTED
32fe0: e58d8004 str r8, [sp, #4] <== NOT EXECUTED
32fe4: e58d6008 str r6, [sp, #8] <== NOT EXECUTED
32fe8: e58da00c str sl, [sp, #12] <== NOT EXECUTED
32fec: ebfffbd6 bl 31f4c <msdos_find_name_in_fat_file> <== NOT EXECUTED
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
32ff0: e2504000 subs r4, r0, #0 <== NOT EXECUTED
32ff4: 1a000046 bne 33114 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1dc><== 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);
32ff8: e28d7014 add r7, sp, #20 <== NOT EXECUTED
32ffc: e1a01004 mov r1, r4 <== NOT EXECUTED
33000: e3a02020 mov r2, #32 <== NOT EXECUTED
33004: e1a00007 mov r0, r7 <== NOT EXECUTED
33008: eb0034f3 bl 403dc <memset> <== NOT EXECUTED
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
3300c: e3a01002 mov r1, #2 <== NOT EXECUTED
33010: e1a02007 mov r2, r7 <== NOT EXECUTED
33014: e3a0300b mov r3, #11 <== NOT EXECUTED
33018: e59f0124 ldr r0, [pc, #292] ; 33144 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x20c><== NOT EXECUTED
3301c: ebffff5f bl 32da0 <msdos_long_to_short> <== NOT EXECUTED
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
33020: e1a02004 mov r2, r4 <== NOT EXECUTED
33024: e3a0c002 mov ip, #2 <== NOT EXECUTED
33028: e1a00005 mov r0, r5 <== NOT EXECUTED
3302c: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED
33030: e59f310c ldr r3, [pc, #268] ; 33144 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x20c><== NOT EXECUTED
33034: e58dc000 str ip, [sp] <== NOT EXECUTED
33038: e58d8004 str r8, [sp, #4] <== NOT EXECUTED
3303c: e58d6008 str r6, [sp, #8] <== NOT EXECUTED
33040: e58d700c str r7, [sp, #12] <== NOT EXECUTED
33044: ebfffbc0 bl 31f4c <msdos_find_name_in_fat_file> <== NOT EXECUTED
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
33048: e2504000 subs r4, r0, #0 <== NOT EXECUTED
3304c: 1a000030 bne 33114 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1dc><== NOT EXECUTED
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(mt_entry, fat_fd);
33050: e1a00005 mov r0, r5 <== NOT EXECUTED
33054: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
33058: e1dab1b4 ldrh fp, [sl, #20] <== NOT EXECUTED
3305c: e1daa1ba ldrh sl, [sl, #26] <== NOT EXECUTED
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(mt_entry, fat_fd);
33060: ebffbc94 bl 222b8 <fat_file_close> <== NOT EXECUTED
if ( rc != RC_OK )
33064: e2504000 subs r4, r0, #0 <== NOT EXECUTED
33068: 1a000031 bne 33134 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1fc><== NOT EXECUTED
return rc;
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
3306c: e1d731ba ldrh r3, [r7, #26] <== NOT EXECUTED
33070: e1d721b4 ldrh r2, [r7, #20] <== NOT EXECUTED
33074: e1932802 orrs r2, 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;
33078: 03e03000 mvneq r3, #0 <== NOT EXECUTED
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
3307c: 05862004 streq r2, [r6, #4] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
33080: 0586300c streq r3, [r6, #12] <== 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;
33084: 05868000 streq r8, [r6] <== 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;
33088: 05863008 streq r3, [r6, #8] <== NOT EXECUTED
}
/* open fat-file corresponded to second ".." */
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
3308c: e1a00005 mov r0, r5 <== NOT EXECUTED
33090: e1a01006 mov r1, r6 <== NOT EXECUTED
33094: e28d2054 add r2, sp, #84 ; 0x54 <== NOT EXECUTED
33098: ebffbcaf bl 2235c <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
3309c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
330a0: 1a000023 bne 33134 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1fc><== NOT EXECUTED
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
330a4: e1d731ba ldrh r3, [r7, #26] <== NOT EXECUTED
330a8: e1d721b4 ldrh r2, [r7, #20] <== NOT EXECUTED
330ac: e1932802 orrs r2, r3, r2, lsl #16 <== NOT EXECUTED
fat_fd->cln = fs_info->fat.vol.rdir_cl;
330b0: 05992038 ldreq r2, [r9, #56] ; 0x38 <== NOT EXECUTED
330b4: e59d3054 ldr r3, [sp, #84] ; 0x54 <== NOT EXECUTED
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
330b8: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED
return rc;
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);
330bc: e583201c str r2, [r3, #28] <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
330c0: 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;
330c4: 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;
330c8: e5812010 str r2, [r1, #16] <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
330cc: e3a02602 mov r2, #2097152 ; 0x200000 <== NOT EXECUTED
330d0: e5812014 str r2, [r1, #20] <== NOT EXECUTED
fat_fd->map.file_cln = 0;
330d4: e2422602 sub r2, r2, #2097152 ; 0x200000 <== NOT EXECUTED
330d8: e5812034 str r2, [r1, #52] ; 0x34 <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
330dc: e5813038 str r3, [r1, #56] ; 0x38 <== NOT EXECUTED
rc = fat_file_size(mt_entry, fat_fd);
330e0: e1a00005 mov r0, r5 <== NOT EXECUTED
330e4: ebffb9eb bl 21898 <fat_file_size> <== NOT EXECUTED
if (rc != RC_OK)
330e8: e2504000 subs r4, r0, #0 <== NOT EXECUTED
330ec: 1a000008 bne 33114 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1dc><== 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,
330f0: e59dc010 ldr ip, [sp, #16] <== NOT EXECUTED
330f4: e18a280b orr r2, sl, fp, lsl #16 <== NOT EXECUTED
330f8: e1a03006 mov r3, r6 <== NOT EXECUTED
330fc: e1a00005 mov r0, r5 <== NOT EXECUTED
33100: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED
33104: e58dc000 str ip, [sp] <== NOT EXECUTED
33108: ebfffb38 bl 31df0 <msdos_find_node_by_cluster_num_in_fat_file><== NOT EXECUTED
dir_pos, dir_entry);
if (rc != RC_OK)
3310c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
33110: 0a000003 beq 33124 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1ec><== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
33114: e1a00005 mov r0, r5 <== NOT EXECUTED
33118: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED
3311c: ebffbc65 bl 222b8 <fat_file_close> <== NOT EXECUTED
return rc;
33120: ea000003 b 33134 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1fc><== NOT EXECUTED
}
rc = fat_file_close(mt_entry, fat_fd);
33124: e1a00005 mov r0, r5 <== NOT EXECUTED
33128: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED
3312c: ebffbc61 bl 222b8 <fat_file_close> <== NOT EXECUTED
33130: e1a04000 mov r4, r0 <== NOT EXECUTED
return rc;
}
33134: e1a00004 mov r0, r4 <== NOT EXECUTED
33138: e28dd058 add sp, sp, #88 ; 0x58 <== NOT EXECUTED
3313c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00033148 <msdos_get_name_node>:
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
33148: e92d45ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, sl, lr} <== 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,
3314c: e58d3000 str r3, [sp] <== NOT EXECUTED
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
33150: e1a06000 mov r6, r0 <== NOT EXECUTED
33154: e1a08002 mov r8, r2 <== NOT EXECUTED
33158: e20170ff and r7, r1, #255 ; 0xff <== NOT EXECUTED
3315c: e28d4030 add r4, sp, #48 ; 0x30 <== NOT EXECUTED
33160: e8940030 ldm r4, {r4, r5} <== 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,
33164: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED
33168: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
3316c: e5961000 ldr r1, [r6] <== NOT EXECUTED
33170: e1a03008 mov r3, r8 <== NOT EXECUTED
33174: e1a02007 mov r2, r7 <== NOT EXECUTED
33178: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
3317c: e58d4008 str r4, [sp, #8] <== NOT EXECUTED
33180: e58d500c str r5, [sp, #12] <== NOT EXECUTED
33184: ebfffb70 bl 31f4c <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))
33188: e59f308c ldr r3, [pc, #140] ; 3321c <msdos_get_name_node+0xd4><== NOT EXECUTED
3318c: e1500003 cmp r0, r3 <== NOT EXECUTED
33190: 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,
33194: 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))
33198: 1a00001c bne 33210 <msdos_get_name_node+0xc8> <== NOT EXECUTED
return rc;
if (!create_node)
3319c: e3570000 cmp r7, #0 <== NOT EXECUTED
331a0: 1a00001a bne 33210 <msdos_get_name_node+0xc8> <== NOT EXECUTED
{
/* if we search for valid name and name not found -> return */
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
331a4: e1500003 cmp r0, r3 <== NOT EXECUTED
331a8: 0a000018 beq 33210 <msdos_get_name_node+0xc8> <== 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)
331ac: e3500000 cmp r0, #0 <== NOT EXECUTED
331b0: 1a000016 bne 33210 <msdos_get_name_node+0xc8> <== NOT EXECUTED
{
if (strncmp(name, "..", 2) == 0)
331b4: e1a00008 mov r0, r8 <== NOT EXECUTED
331b8: e59f1060 ldr r1, [pc, #96] ; 33220 <msdos_get_name_node+0xd8><== NOT EXECUTED
331bc: e3a02002 mov r2, #2 <== NOT EXECUTED
331c0: eb004295 bl 43c1c <strncmp> <== NOT EXECUTED
331c4: e3500000 cmp r0, #0 <== NOT EXECUTED
331c8: 1a000010 bne 33210 <msdos_get_name_node+0xc8> <== NOT EXECUTED
{
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
331cc: e1d511b4 ldrh r1, [r5, #20] <== NOT EXECUTED
331d0: e1d531ba ldrh r3, [r5, #26] <== NOT EXECUTED
/* are we right under root dir ? */
if (dotdot_cln == 0)
331d4: e1931801 orrs r1, r3, r1, lsl #16 <== NOT EXECUTED
331d8: 1a000006 bne 331f8 <msdos_get_name_node+0xb0> <== NOT EXECUTED
331dc: 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;
331e0: e3a02001 mov r2, #1 <== NOT EXECUTED
331e4: e5842000 str r2, [r4] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
331e8: e584300c str r3, [r4, #12] <== NOT EXECUTED
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
331ec: e584a004 str sl, [r4, #4] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
331f0: e5843008 str r3, [r4, #8] <== NOT EXECUTED
331f4: ea000005 b 33210 <msdos_get_name_node+0xc8> <== NOT EXECUTED
}
else
{
rc =
msdos_get_dotdot_dir_info_cluster_num_and_offset(parent_loc->mt_entry,
331f8: e5960010 ldr r0, [r6, #16] <== NOT EXECUTED
331fc: e1a02004 mov r2, r4 <== NOT EXECUTED
33200: e1a03005 mov r3, r5 <== NOT EXECUTED
}
}
}
}
return rc;
}
33204: e28dd010 add sp, sp, #16 <== NOT EXECUTED
33208: 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,
3320c: eaffff49 b 32f38 <msdos_get_dotdot_dir_info_cluster_num_and_offset><== NOT EXECUTED
}
}
}
}
return rc;
}
33210: e1a0000a mov r0, sl <== NOT EXECUTED
33214: e28dd010 add sp, sp, #16 <== NOT EXECUTED
33218: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
00032cc0 <msdos_get_token>:
msdos_token_types_t
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
32cc0: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
msdos_token_types_t type = MSDOS_NAME;
int i = 0;
*ret_token = NULL;
32cc4: e3a06000 mov r6, #0 <== NOT EXECUTED
*ret_token_len = 0;
if (pathlen == 0)
32cc8: 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)
{
32ccc: e1a07000 mov r7, r0 <== NOT EXECUTED
32cd0: e1a04002 mov r4, r2 <== NOT EXECUTED
32cd4: e1a05003 mov r5, r3 <== NOT EXECUTED
msdos_token_types_t type = MSDOS_NAME;
int i = 0;
*ret_token = NULL;
32cd8: e5826000 str r6, [r2] <== NOT EXECUTED
*ret_token_len = 0;
32cdc: e5836000 str r6, [r3] <== NOT EXECUTED
if (pathlen == 0)
32ce0: 01a00008 moveq r0, r8 <== NOT EXECUTED
32ce4: 1a000007 bne 32d08 <msdos_get_token+0x48> <== NOT EXECUTED
32ce8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
{
if ( !msdos_is_valid_name_char(path[i]) )
32cec: e7d70006 ldrb r0, [r7, r6] <== NOT EXECUTED
32cf0: ebffffd7 bl 32c54 <msdos_is_valid_name_char> <== NOT EXECUTED
32cf4: e3500000 cmp r0, #0 <== NOT EXECUTED
return MSDOS_INVALID_TOKEN;
++i;
32cf8: 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]) )
32cfc: 0a000025 beq 32d98 <msdos_get_token+0xd8> <== NOT EXECUTED
return MSDOS_INVALID_TOKEN;
++i;
if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )
32d00: e3560f41 cmp r6, #260 ; 0x104 <== NOT EXECUTED
32d04: 0a000023 beq 32d98 <msdos_get_token+0xd8> <== NOT EXECUTED
return MSDOS_NO_MORE_PATH;
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
32d08: e7d70006 ldrb r0, [r7, r6] <== NOT EXECUTED
32d0c: ebff589d bl 8f88 <rtems_filesystem_is_separator> <== NOT EXECUTED
32d10: e3500000 cmp r0, #0 <== NOT EXECUTED
32d14: 1a000001 bne 32d20 <msdos_get_token+0x60> <== NOT EXECUTED
32d18: e1560008 cmp r6, r8 <== NOT EXECUTED
32d1c: bafffff2 blt 32cec <msdos_get_token+0x2c> <== NOT EXECUTED
*ret_token = path;
/*
* If it is just a separator then it is the current dir.
*/
if ( i == 0 )
32d20: e3560000 cmp r6, #0 <== NOT EXECUTED
++i;
if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )
return MSDOS_INVALID_TOKEN;
}
*ret_token = path;
32d24: e5847000 str r7, [r4] <== NOT EXECUTED
/*
* If it is just a separator then it is the current dir.
*/
if ( i == 0 )
32d28: 13a00003 movne r0, #3 <== NOT EXECUTED
32d2c: 1a000003 bne 32d40 <msdos_get_token+0x80> <== NOT EXECUTED
{
if ( (*path != '\0') && pathlen )
32d30: e5d73000 ldrb r3, [r7] <== NOT EXECUTED
32d34: e3530000 cmp r3, #0 <== NOT EXECUTED
32d38: 13a06001 movne r6, #1 <== NOT EXECUTED
32d3c: e1a00006 mov r0, r6 <== NOT EXECUTED
/*
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == MSDOS_NAME )
32d40: e3500003 cmp r0, #3 <== NOT EXECUTED
}
/*
* Set the token and token_len to the token start and length.
*/
*ret_token_len = i;
32d44: 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 )
32d48: 18bd81f0 popne {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
{
if ((i == 2) && ((*ret_token)[0] == '.') && ((*ret_token)[1] == '.'))
32d4c: e3560002 cmp r6, #2 <== NOT EXECUTED
32d50: 1a000008 bne 32d78 <msdos_get_token+0xb8> <== NOT EXECUTED
32d54: e5943000 ldr r3, [r4] <== NOT EXECUTED
32d58: e5d32000 ldrb r2, [r3] <== NOT EXECUTED
32d5c: e352002e cmp r2, #46 ; 0x2e <== NOT EXECUTED
32d60: 18bd81f0 popne {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
32d64: e5d30001 ldrb r0, [r3, #1] <== NOT EXECUTED
32d68: e350002e cmp r0, #46 ; 0x2e <== NOT EXECUTED
32d6c: 13a00003 movne r0, #3 <== NOT EXECUTED
32d70: 03a00002 moveq r0, #2 <== NOT EXECUTED
32d74: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
{
type = MSDOS_UP_DIR;
return type;
}
if ((i == 1) && ((*ret_token)[0] == '.'))
32d78: e3560001 cmp r6, #1 <== NOT EXECUTED
32d7c: 18bd81f0 popne {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
32d80: e5943000 ldr r3, [r4] <== NOT EXECUTED
32d84: e5d30000 ldrb r0, [r3] <== NOT EXECUTED
32d88: e350002e cmp r0, #46 ; 0x2e <== NOT EXECUTED
32d8c: 13a00003 movne r0, #3 <== NOT EXECUTED
32d90: 03a00001 moveq r0, #1 <== NOT EXECUTED
32d94: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
32d98: e3a00004 mov r0, #4 <== NOT EXECUTED
return type;
}
}
return type;
}
32d9c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
0001d218 <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
)
{
1d218: 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;
1d21c: 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
)
{
1d220: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
1d224: e1a05000 mov r5, r0 <== NOT EXECUTED
1d228: 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));
1d22c: e3a00001 mov r0, #1 <== NOT EXECUTED
1d230: 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;
1d234: 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
)
{
1d238: e1a0a002 mov sl, r2 <== NOT EXECUTED
1d23c: 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));
1d240: ebffa7ab bl 70f4 <calloc> <== NOT EXECUTED
if (!fs_info)
1d244: e2504000 subs r4, r0, #0 <== NOT EXECUTED
1d248: 0a00003d beq 1d344 <msdos_initialize_support+0x12c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
temp_mt_entry->fs_info = fs_info;
1d24c: e5854034 str r4, [r5, #52] ; 0x34 <== NOT EXECUTED
rc = fat_init_volume_info(temp_mt_entry);
1d250: e1a00005 mov r0, r5 <== NOT EXECUTED
1d254: eb0016b7 bl 22d38 <fat_init_volume_info> <== NOT EXECUTED
if (rc != RC_OK)
1d258: e2507000 subs r7, r0, #0 <== NOT EXECUTED
1d25c: 1a00000f bne 1d2a0 <msdos_initialize_support+0x88> <== 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;
1d260: e28d1018 add r1, sp, #24 <== NOT EXECUTED
1d264: 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;
1d268: e3e03000 mvn r3, #0 <== NOT EXECUTED
1d26c: e5218014 str r8, [r1, #-20]! <== NOT EXECUTED
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
1d270: e584a090 str sl, [r4, #144] ; 0x90 <== NOT EXECUTED
fs_info->directory_handlers = directory_handlers;
1d274: 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);
1d278: e1a00005 mov r0, r5 <== NOT EXECUTED
1d27c: 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;
1d280: e58d7008 str r7, [sp, #8] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
1d284: 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;
1d288: e58d300c str r3, [sp, #12] <== NOT EXECUTED
1d28c: eb001432 bl 2235c <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
1d290: e2507000 subs r7, r0, #0 <== NOT EXECUTED
1d294: 0a000004 beq 1d2ac <msdos_initialize_support+0x94> <== NOT EXECUTED
{
fat_shutdown_drive(temp_mt_entry);
1d298: e1a00005 mov r0, r5 <== NOT EXECUTED
1d29c: eb00160a bl 22acc <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
1d2a0: e1a00004 mov r0, r4 <== NOT EXECUTED
1d2a4: ebffa902 bl 76b4 <free> <== NOT EXECUTED
return rc;
1d2a8: ea000043 b 1d3bc <msdos_initialize_support+0x1a4> <== NOT EXECUTED
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
1d2ac: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
1d2b0: e3a03602 mov r3, #2097152 ; 0x200000 <== NOT EXECUTED
1d2b4: e5813014 str r3, [r1, #20] <== NOT EXECUTED
fat_fd->cln = fs_info->fat.vol.rdir_cl;
1d2b8: 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 )
1d2bc: 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;
1d2c0: 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;
1d2c4: 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;
1d2c8: e581301c str r3, [r1, #28] <== NOT EXECUTED
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
1d2cc: e5813038 str r3, [r1, #56] ; 0x38 <== NOT EXECUTED
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
1d2d0: 1a000006 bne 1d2f0 <msdos_initialize_support+0xd8> <== NOT EXECUTED
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
1d2d4: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
1d2d8: e5813018 str r3, [r1, #24] <== NOT EXECUTED
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
1d2dc: e1d400b6 ldrh r0, [r4, #6] <== NOT EXECUTED
1d2e0: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
1d2e4: e1500003 cmp r0, r3 <== NOT EXECUTED
1d2e8: 31a00003 movcc r0, r3 <== NOT EXECUTED
1d2ec: ea000008 b 1d314 <msdos_initialize_support+0xfc> <== NOT EXECUTED
fs_info->fat.vol.bpc :
fs_info->fat.vol.rdir_size;
}
else
{
rc = fat_file_size(temp_mt_entry, fat_fd);
1d2f0: e1a00005 mov r0, r5 <== NOT EXECUTED
1d2f4: eb001167 bl 21898 <fat_file_size> <== NOT EXECUTED
if ( rc != RC_OK )
1d2f8: 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;
1d2fc: 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 )
1d300: 0a000003 beq 1d314 <msdos_initialize_support+0xfc> <== NOT EXECUTED
{
fat_file_close(temp_mt_entry, fat_fd);
1d304: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED
1d308: e1a00005 mov r0, r5 <== NOT EXECUTED
1d30c: eb0013e9 bl 222b8 <fat_file_close> <== NOT EXECUTED
1d310: eaffffe0 b 1d298 <msdos_initialize_support+0x80> <== NOT EXECUTED
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
1d314: e3a01001 mov r1, #1 <== NOT EXECUTED
1d318: ebffa775 bl 70f4 <calloc> <== NOT EXECUTED
if (fs_info->cl_buf == NULL)
1d31c: 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));
1d320: e5840098 str r0, [r4, #152] ; 0x98 <== NOT EXECUTED
if (fs_info->cl_buf == NULL)
1d324: 1a00000b bne 1d358 <msdos_initialize_support+0x140> <== NOT EXECUTED
{
fat_file_close(temp_mt_entry, fat_fd);
1d328: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED
1d32c: e1a00005 mov r0, r5 <== NOT EXECUTED
1d330: eb0013e0 bl 222b8 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
1d334: e1a00005 mov r0, r5 <== NOT EXECUTED
1d338: eb0015e3 bl 22acc <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
1d33c: e1a00004 mov r0, r4 <== NOT EXECUTED
1d340: ebffa8db bl 76b4 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
1d344: eb007eed bl 3cf00 <__errno> <== NOT EXECUTED
1d348: e3a0300c mov r3, #12 <== NOT EXECUTED
1d34c: e5803000 str r3, [r0] <== NOT EXECUTED
1d350: e3e07000 mvn r7, #0 <== NOT EXECUTED
1d354: ea000018 b 1d3bc <msdos_initialize_support+0x1a4> <== NOT EXECUTED
}
sc = rtems_semaphore_create(3,
1d358: e284c094 add ip, r4, #148 ; 0x94 <== NOT EXECUTED
1d35c: e3a00003 mov r0, #3 <== NOT EXECUTED
1d360: e3a01001 mov r1, #1 <== NOT EXECUTED
1d364: e3a02010 mov r2, #16 <== NOT EXECUTED
1d368: e3a03000 mov r3, #0 <== NOT EXECUTED
1d36c: e58dc000 str ip, [sp] <== NOT EXECUTED
1d370: ebffb8a9 bl b61c <rtems_semaphore_create> <== NOT EXECUTED
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
1d374: e2507000 subs r7, r0, #0 <== NOT EXECUTED
1d378: 0a00000b beq 1d3ac <msdos_initialize_support+0x194> <== NOT EXECUTED
{
fat_file_close(temp_mt_entry, fat_fd);
1d37c: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED
1d380: e1a00005 mov r0, r5 <== NOT EXECUTED
1d384: eb0013cb bl 222b8 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
1d388: e1a00005 mov r0, r5 <== NOT EXECUTED
1d38c: eb0015ce bl 22acc <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info->cl_buf);
1d390: e5940098 ldr r0, [r4, #152] ; 0x98 <== NOT EXECUTED
1d394: ebffa8c6 bl 76b4 <free> <== NOT EXECUTED
free(fs_info);
1d398: e1a00004 mov r0, r4 <== NOT EXECUTED
1d39c: ebffa8c4 bl 76b4 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
1d3a0: eb007ed6 bl 3cf00 <__errno> <== NOT EXECUTED
1d3a4: e3a03005 mov r3, #5 <== NOT EXECUTED
1d3a8: eaffffe7 b 1d34c <msdos_initialize_support+0x134> <== NOT EXECUTED
}
temp_mt_entry->mt_fs_root.node_access = fat_fd;
1d3ac: 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;
1d3b0: 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;
1d3b4: e585301c str r3, [r5, #28] <== NOT EXECUTED
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
1d3b8: e5856024 str r6, [r5, #36] ; 0x24 <== NOT EXECUTED
temp_mt_entry->mt_fs_root.ops = op_table;
return rc;
}
1d3bc: e1a00007 mov r0, r7 <== NOT EXECUTED
1d3c0: e28dd018 add sp, sp, #24 <== NOT EXECUTED
1d3c4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
00032c54 <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)
{
32c54: e92d4010 push {r4, lr} <== NOT EXECUTED
32c58: e20040ff and r4, r0, #255 ; 0xff <== NOT EXECUTED
if (strchr(" +,;=[]", ch) != NULL)
32c5c: e1a01004 mov r1, r4 <== NOT EXECUTED
32c60: e59f004c ldr r0, [pc, #76] ; 32cb4 <msdos_is_valid_name_char+0x60><== NOT EXECUTED
32c64: eb0040d3 bl 42fb8 <strchr> <== NOT EXECUTED
32c68: e3500000 cmp r0, #0 <== NOT EXECUTED
32c6c: 13a00002 movne r0, #2 <== NOT EXECUTED
32c70: 18bd8010 popne {r4, pc} <== NOT EXECUTED
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
32c74: e354002e cmp r4, #46 ; 0x2e <== NOT EXECUTED
32c78: 0a00000b beq 32cac <msdos_is_valid_name_char+0x58> <== NOT EXECUTED
32c7c: e59f3034 ldr r3, [pc, #52] ; 32cb8 <msdos_is_valid_name_char+0x64><== NOT EXECUTED
32c80: e5933000 ldr r3, [r3] <== NOT EXECUTED
32c84: e0833004 add r3, r3, r4 <== NOT EXECUTED
32c88: e5d33001 ldrb r3, [r3, #1] <== NOT EXECUTED
32c8c: e3130007 tst r3, #7 <== NOT EXECUTED
32c90: 1a000005 bne 32cac <msdos_is_valid_name_char+0x58> <== NOT EXECUTED
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
32c94: e1a01004 mov r1, r4 <== NOT EXECUTED
32c98: e59f001c ldr r0, [pc, #28] ; 32cbc <msdos_is_valid_name_char+0x68><== NOT EXECUTED
32c9c: eb0040c5 bl 42fb8 <strchr> <== NOT EXECUTED
32ca0: e2500000 subs r0, r0, #0 <== NOT EXECUTED
32ca4: 13a00001 movne r0, #1 <== NOT EXECUTED
32ca8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
32cac: e3a00001 mov r0, #1 <== NOT EXECUTED
return MSDOS_NAME_SHORT;
return MSDOS_NAME_INVALID;
}
32cb0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00032da0 <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)
{
32da0: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
32da4: e1a06002 mov r6, r2 <== NOT EXECUTED
32da8: e1a04000 mov r4, r0 <== NOT EXECUTED
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
32dac: 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)
{
32db0: e1a05001 mov r5, r1 <== NOT EXECUTED
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
32db4: e1a00006 mov r0, r6 <== NOT EXECUTED
32db8: e3a01020 mov r1, #32 <== NOT EXECUTED
32dbc: eb003586 bl 403dc <memset> <== NOT EXECUTED
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
32dc0: e5d43000 ldrb r3, [r4] <== NOT EXECUTED
32dc4: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED
32dc8: 13a02000 movne r2, #0 <== NOT EXECUTED
32dcc: 03a02001 moveq r2, #1 <== NOT EXECUTED
32dd0: e3550001 cmp r5, #1 <== NOT EXECUTED
32dd4: 0353002e cmpeq r3, #46 ; 0x2e <== NOT EXECUTED
{
sfn[0] = '.';
32dd8: 03a0302e moveq r3, #46 ; 0x2e <== NOT EXECUTED
32ddc: 05c63000 strbeq r3, [r6] <== NOT EXECUTED
memset (sfn, ' ', sfn_len);
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
32de0: 0a000008 beq 32e08 <msdos_long_to_short+0x68> <== 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))
32de4: e3520000 cmp r2, #0 <== NOT EXECUTED
32de8: 0a00000e beq 32e28 <msdos_long_to_short+0x88> <== NOT EXECUTED
32dec: e5d43001 ldrb r3, [r4, #1] <== NOT EXECUTED
32df0: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED
32df4: 03550002 cmpeq r5, #2 <== NOT EXECUTED
32df8: 1a00000a bne 32e28 <msdos_long_to_short+0x88> <== NOT EXECUTED
{
sfn[0] = sfn[1] = '.';
32dfc: e3a0302e mov r3, #46 ; 0x2e <== NOT EXECUTED
32e00: e5c63000 strb r3, [r6] <== NOT EXECUTED
32e04: e5c63001 strb r3, [r6, #1] <== NOT EXECUTED
32e08: e3a00001 mov r0, #1 <== NOT EXECUTED
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
32e0c: ea000044 b 32f24 <msdos_long_to_short+0x184> <== NOT EXECUTED
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
32e10: e7d42003 ldrb r2, [r4, r3] <== NOT EXECUTED
32e14: e352002e cmp r2, #46 ; 0x2e <== NOT EXECUTED
32e18: 13520020 cmpne r2, #32 <== NOT EXECUTED
32e1c: 1a00002c bne 32ed4 <msdos_long_to_short+0x134> <== NOT EXECUTED
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
32e20: e2833001 add r3, r3, #1 <== NOT EXECUTED
32e24: ea000000 b 32e2c <msdos_long_to_short+0x8c> <== NOT EXECUTED
32e28: e3a03000 mov r3, #0 <== NOT EXECUTED
32e2c: e1530005 cmp r3, r5 <== NOT EXECUTED
32e30: bafffff6 blt 32e10 <msdos_long_to_short+0x70> <== NOT EXECUTED
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
32e34: 03a00000 moveq r0, #0 <== NOT EXECUTED
32e38: 1a000025 bne 32ed4 <msdos_long_to_short+0x134> <== NOT EXECUTED
32e3c: ea000038 b 32f24 <msdos_long_to_short+0x184> <== 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);
32e40: e1a0000a mov r0, sl <== NOT EXECUTED
32e44: e58d3000 str r3, [sp] <== NOT EXECUTED
32e48: ebffff81 bl 32c54 <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))
32e4c: e3500000 cmp r0, #0 <== NOT EXECUTED
32e50: 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);
32e54: 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))
32e58: e59d3000 ldr r3, [sp] <== NOT EXECUTED
32e5c: 0a000029 beq 32f08 <msdos_long_to_short+0x168> <== NOT EXECUTED
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
32e60: e35a002e cmp sl, #46 ; 0x2e <== NOT EXECUTED
32e64: 13a02000 movne r2, #0 <== NOT EXECUTED
32e68: 03a02001 moveq r2, #1 <== NOT EXECUTED
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
return type;
if (dot_at >= 0)
32e6c: e37b0001 cmn fp, #1 <== NOT EXECUTED
32e70: 0a000005 beq 32e8c <msdos_long_to_short+0xec> <== NOT EXECUTED
{
if (is_dot || ((count - dot_at) > 3))
32e74: e3520000 cmp r2, #0 <== NOT EXECUTED
32e78: 1a00002c bne 32f30 <msdos_long_to_short+0x190> <== NOT EXECUTED
32e7c: e06b2008 rsb r2, fp, r8 <== NOT EXECUTED
32e80: e3520003 cmp r2, #3 <== NOT EXECUTED
32e84: da000007 ble 32ea8 <msdos_long_to_short+0x108> <== NOT EXECUTED
32e88: ea000028 b 32f30 <msdos_long_to_short+0x190> <== NOT EXECUTED
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
32e8c: e3580008 cmp r8, #8 <== NOT EXECUTED
32e90: 1a000002 bne 32ea0 <msdos_long_to_short+0x100> <== NOT EXECUTED
32e94: e3520000 cmp r2, #0 <== NOT EXECUTED
32e98: 1a00000a bne 32ec8 <msdos_long_to_short+0x128> <== NOT EXECUTED
32e9c: ea000023 b 32f30 <msdos_long_to_short+0x190> <== NOT EXECUTED
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
32ea0: e3520000 cmp r2, #0 <== NOT EXECUTED
32ea4: 1a000007 bne 32ec8 <msdos_long_to_short+0x128> <== NOT EXECUTED
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
32ea8: e24a2041 sub r2, sl, #65 ; 0x41 <== NOT EXECUTED
32eac: e3520019 cmp r2, #25 <== NOT EXECUTED
32eb0: 93a03001 movls r3, #1 <== NOT EXECUTED
32eb4: 9a000004 bls 32ecc <msdos_long_to_short+0x12c> <== NOT EXECUTED
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
32eb8: e24aa061 sub sl, sl, #97 ; 0x61 <== NOT EXECUTED
32ebc: e35a0019 cmp sl, #25 <== NOT EXECUTED
32ec0: 93a09001 movls r9, #1 <== NOT EXECUTED
32ec4: ea000000 b 32ecc <msdos_long_to_short+0x12c> <== NOT EXECUTED
32ec8: e1a0b008 mov fp, r8 <== NOT EXECUTED
lowercase = true;
count++;
32ecc: e2888001 add r8, r8, #1 <== NOT EXECUTED
32ed0: ea000003 b 32ee4 <msdos_long_to_short+0x144> <== NOT EXECUTED
32ed4: e3a08000 mov r8, #0 <== NOT EXECUTED
32ed8: e3e0b000 mvn fp, #0 <== NOT EXECUTED
32edc: e1a03008 mov r3, r8 <== NOT EXECUTED
32ee0: e1a09008 mov r9, r8 <== NOT EXECUTED
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
32ee4: e7d4a008 ldrb sl, [r4, r8] <== NOT EXECUTED
32ee8: e35a0000 cmp sl, #0 <== NOT EXECUTED
32eec: 11580005 cmpne r8, r5 <== NOT EXECUTED
32ef0: baffffd2 blt 32e40 <msdos_long_to_short+0xa0> <== NOT EXECUTED
count++;
name++;
}
if (lowercase && uppercase)
32ef4: e3590000 cmp r9, #0 <== NOT EXECUTED
32ef8: 0a00000a beq 32f28 <msdos_long_to_short+0x188> <== NOT EXECUTED
32efc: e3530000 cmp r3, #0 <== NOT EXECUTED
32f00: 1a00000a bne 32f30 <msdos_long_to_short+0x190> <== NOT EXECUTED
32f04: ea000007 b 32f28 <msdos_long_to_short+0x188> <== NOT EXECUTED
* Is this a short name ?
*/
type = msdos_name_type (lfn, lfn_len);
if (type == MSDOS_NAME_INVALID)
32f08: e3500000 cmp r0, #0 <== NOT EXECUTED
32f0c: 0a000004 beq 32f24 <msdos_long_to_short+0x184> <== 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);
32f10: e1a00004 mov r0, r4 <== NOT EXECUTED
32f14: e1a01005 mov r1, r5 <== NOT EXECUTED
32f18: e1a02006 mov r2, r6 <== NOT EXECUTED
32f1c: eb002285 bl 3b938 <msdos_filename_unix2dos> <== NOT EXECUTED
32f20: e1a00007 mov r0, r7 <== NOT EXECUTED
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
}
32f24: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== 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;
32f28: e3a07001 mov r7, #1 <== NOT EXECUTED
32f2c: eafffff7 b 32f10 <msdos_long_to_short+0x170> <== NOT EXECUTED
32f30: e3a07002 mov r7, #2 <== NOT EXECUTED
32f34: eafffff5 b 32f10 <msdos_long_to_short+0x170> <== NOT EXECUTED
0001d3c8 <msdos_mknod>:
const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
1d3c8: e92d45f3 push {r0, r1, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
1d3cc: e59d8024 ldr r8, [sp, #36] ; 0x24 <== NOT EXECUTED
msdos_token_types_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
1d3d0: 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;
1d3d4: e5982010 ldr r2, [r8, #16] <== NOT EXECUTED
msdos_token_types_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
1d3d8: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED
const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
1d3dc: e1a05001 mov r5, r1 <== NOT EXECUTED
1d3e0: e1a07000 mov r7, r0 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
1d3e4: e5924034 ldr r4, [r2, #52] ; 0x34 <== NOT EXECUTED
msdos_token_types_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
1d3e8: 0a000005 beq 1d404 <msdos_mknod+0x3c> <== NOT EXECUTED
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
1d3ec: e3530902 cmp r3, #32768 ; 0x8000 <== NOT EXECUTED
1d3f0: 03a0a005 moveq sl, #5 <== NOT EXECUTED
1d3f4: 0a000003 beq 1d408 <msdos_mknod+0x40> <== NOT EXECUTED
{
type = MSDOS_REGULAR_FILE;
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
1d3f8: eb007ec0 bl 3cf00 <__errno> <== NOT EXECUTED
1d3fc: e3a03016 mov r3, #22 <== NOT EXECUTED
1d400: ea000008 b 1d428 <msdos_mknod+0x60> <== NOT EXECUTED
1d404: e3a0a001 mov sl, #1 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
1d408: e3a01000 mov r1, #0 <== NOT EXECUTED
1d40c: e5940094 ldr r0, [r4, #148] ; 0x94 <== NOT EXECUTED
1d410: e1a02001 mov r2, r1 <== NOT EXECUTED
1d414: ebffb929 bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
1d418: e2506000 subs r6, r0, #0 <== NOT EXECUTED
1d41c: 0a000004 beq 1d434 <msdos_mknod+0x6c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
1d420: eb007eb6 bl 3cf00 <__errno> <== NOT EXECUTED
1d424: e3a03005 mov r3, #5 <== NOT EXECUTED
1d428: e5803000 str r3, [r0] <== NOT EXECUTED
1d42c: e3e05000 mvn r5, #0 <== NOT EXECUTED
1d430: ea00000a b 1d460 <msdos_mknod+0x98> <== NOT EXECUTED
/* Create an MSDOS node */
rc = msdos_creat_node(pathloc, type, name, strlen(name), mode, NULL);
1d434: e1a00007 mov r0, r7 <== NOT EXECUTED
1d438: eb0099ad bl 43af4 <strlen> <== NOT EXECUTED
1d43c: e1a0100a mov r1, sl <== NOT EXECUTED
1d440: e1a03000 mov r3, r0 <== NOT EXECUTED
1d444: e1a02007 mov r2, r7 <== NOT EXECUTED
1d448: e1a00008 mov r0, r8 <== NOT EXECUTED
1d44c: e88d0060 stm sp, {r5, r6} <== NOT EXECUTED
1d450: eb004eab bl 30f04 <msdos_creat_node> <== NOT EXECUTED
1d454: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
1d458: e5940094 ldr r0, [r4, #148] ; 0x94 <== NOT EXECUTED
1d45c: ebffb95d bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
1d460: e1a00005 mov r0, r5 <== NOT EXECUTED
1d464: e8bd85fc pop {r2, r3, r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
0001d468 <msdos_node_type>:
* node type
*
*/
rtems_filesystem_node_types_t
msdos_node_type(rtems_filesystem_location_info_t *pathloc)
{
1d468: e5903000 ldr r3, [r0] <== NOT EXECUTED
* call
*/
fat_fd = pathloc->node_access;
return fat_fd->fat_file_type;
}
1d46c: e5930010 ldr r0, [r3, #16] <== NOT EXECUTED
1d470: e12fff1e bx lr <== NOT EXECUTED
0001d474 <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)
{
1d474: e92d45ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
1d478: e1a05003 mov r5, 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;
1d47c: e5923010 ldr r3, [r2, #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)) {
1d480: e1a00005 mov r0, r5 <== 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)
{
1d484: e1a06001 mov r6, 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;
1d488: e5934034 ldr r4, [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)
{
1d48c: e1a07002 mov r7, 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)) {
1d490: eb009997 bl 43af4 <strlen> <== NOT EXECUTED
1d494: e28d200c add r2, sp, #12 <== NOT EXECUTED
1d498: e1a01000 mov r1, r0 <== NOT EXECUTED
1d49c: e28d3008 add r3, sp, #8 <== NOT EXECUTED
1d4a0: e1a00005 mov r0, r5 <== 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;
1d4a4: e5968000 ldr r8, [r6] <== NOT EXECUTED
int len;
/*
* check spelling and format new node name
*/
if (MSDOS_NAME != msdos_get_token(new_name, strlen(new_name), &token, &len)) {
1d4a8: eb005604 bl 32cc0 <msdos_get_token> <== NOT EXECUTED
1d4ac: e3500003 cmp r0, #3 <== NOT EXECUTED
1d4b0: e1a0a000 mov sl, r0 <== NOT EXECUTED
1d4b4: 0a000002 beq 1d4c4 <msdos_rename+0x50> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
1d4b8: eb007e90 bl 3cf00 <__errno> <== NOT EXECUTED
1d4bc: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED
1d4c0: ea000007 b 1d4e4 <msdos_rename+0x70> <== NOT EXECUTED
}
/*
* lock volume
*/
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
1d4c4: e3a01000 mov r1, #0 <== NOT EXECUTED
1d4c8: e5940094 ldr r0, [r4, #148] ; 0x94 <== NOT EXECUTED
1d4cc: e1a02001 mov r2, r1 <== NOT EXECUTED
1d4d0: ebffb8fa bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
1d4d4: e3500000 cmp r0, #0 <== NOT EXECUTED
1d4d8: 0a000004 beq 1d4f0 <msdos_rename+0x7c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
1d4dc: eb007e87 bl 3cf00 <__errno> <== NOT EXECUTED
1d4e0: e3a03005 mov r3, #5 <== NOT EXECUTED
1d4e4: e5803000 str r3, [r0] <== NOT EXECUTED
1d4e8: e3e05000 mvn r5, #0 <== NOT EXECUTED
1d4ec: ea000010 b 1d534 <msdos_rename+0xc0> <== NOT EXECUTED
/*
* create new directory entry as "hard link", copying relevant info from
* existing file
*/
rc = msdos_creat_node(new_parent_loc,
1d4f0: e1a02005 mov r2, r5 <== NOT EXECUTED
1d4f4: e3a0c902 mov ip, #32768 ; 0x8000 <== NOT EXECUTED
1d4f8: e1a00007 mov r0, r7 <== NOT EXECUTED
1d4fc: e1a0100a mov r1, sl <== NOT EXECUTED
1d500: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
1d504: e58dc000 str ip, [sp] <== NOT EXECUTED
1d508: e58d8004 str r8, [sp, #4] <== NOT EXECUTED
1d50c: eb004e7c bl 30f04 <msdos_creat_node> <== NOT EXECUTED
MSDOS_HARD_LINK,new_name,len,S_IFREG,
old_fat_fd);
if (rc != RC_OK)
1d510: e2505000 subs r5, r0, #0 <== NOT EXECUTED
1d514: 1a000004 bne 1d52c <msdos_rename+0xb8> <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
1d518: e5960010 ldr r0, [r6, #16] <== NOT EXECUTED
1d51c: e2881020 add r1, r8, #32 <== NOT EXECUTED
1d520: e3a020e5 mov r2, #229 ; 0xe5 <== NOT EXECUTED
1d524: eb00554e bl 32a64 <msdos_set_first_char4file_name> <== NOT EXECUTED
1d528: e1a05000 mov r5, r0 <== NOT EXECUTED
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
rtems_semaphore_release(fs_info->vol_sema);
1d52c: e5940094 ldr r0, [r4, #148] ; 0x94 <== NOT EXECUTED
1d530: ebffb928 bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
1d534: e1a00005 mov r0, r5 <== NOT EXECUTED
1d538: e28dd010 add sp, sp, #16 <== NOT EXECUTED
1d53c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
00032ba0 <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
)
{
32ba0: e92d40f3 push {r0, r1, r4, r5, r6, r7, lr} <== NOT EXECUTED
32ba4: e1a05001 mov r5, r1 <== NOT EXECUTED
32ba8: 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);
32bac: e28d2006 add r2, sp, #6 <== NOT EXECUTED
32bb0: e28d1004 add r1, sp, #4 <== NOT EXECUTED
32bb4: 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;
32bb8: e5947034 ldr r7, [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);
32bbc: eb0022c9 bl 3b6e8 <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);
32bc0: 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)) )
32bc4: 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;
32bc8: e5943034 ldr r3, [r4, #52] ; 0x34 <== NOT EXECUTED
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
32bcc: 1a000003 bne 32be0 <msdos_set_dir_wrt_time_and_date+0x40> <== NOT EXECUTED
32bd0: e5d3100a ldrb r1, [r3, #10] <== NOT EXECUTED
32bd4: e3110003 tst r1, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
32bd8: 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)) )
32bdc: 1a000003 bne 32bf0 <msdos_set_dir_wrt_time_and_date+0x50> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
32be0: e5931030 ldr r1, [r3, #48] ; 0x30 <== NOT EXECUTED
32be4: e5d33005 ldrb r3, [r3, #5] <== NOT EXECUTED
32be8: e2426002 sub r6, r2, #2 <== NOT EXECUTED
32bec: e0816316 add r6, r1, r6, lsl r3 <== NOT EXECUTED
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
32bf0: e5953024 ldr r3, [r5, #36] ; 0x24 <== NOT EXECUTED
32bf4: e5d72002 ldrb r2, [r7, #2] <== NOT EXECUTED
32bf8: e0866233 add r6, r6, r3, lsr r2 <== NOT EXECUTED
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
32bfc: e1d750b0 ldrh r5, [r7] <== NOT EXECUTED
32c00: e2455001 sub r5, r5, #1 <== NOT EXECUTED
32c04: 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,
32c08: e28dc006 add ip, sp, #6 <== NOT EXECUTED
32c0c: e1a01006 mov r1, r6 <== NOT EXECUTED
32c10: e2852016 add r2, r5, #22 <== NOT EXECUTED
32c14: e3a03002 mov r3, #2 <== NOT EXECUTED
32c18: e1a00004 mov r0, r4 <== NOT EXECUTED
32c1c: e58dc000 str ip, [sp] <== NOT EXECUTED
32c20: ebffbf65 bl 229bc <_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,
32c24: e28dc004 add ip, sp, #4 <== 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,
32c28: 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,
32c2c: e1a01006 mov r1, r6 <== NOT EXECUTED
32c30: e1a00004 mov r0, r4 <== NOT EXECUTED
32c34: e2852018 add r2, r5, #24 <== NOT EXECUTED
32c38: e3a03002 mov r3, #2 <== NOT EXECUTED
32c3c: e58dc000 str ip, [sp] <== NOT EXECUTED
32c40: ebffbf5d bl 229bc <_fat_block_write> <== NOT EXECUTED
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) )
32c44: e1a07fa7 lsr r7, r7, #31 <== NOT EXECUTED
32c48: e1970fa0 orrs r0, r7, r0, lsr #31 <== NOT EXECUTED
return -1;
return RC_OK;
}
32c4c: 13e00000 mvnne r0, #0 <== NOT EXECUTED
32c50: e8bd80fc pop {r2, r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
00032938 <msdos_set_file_size>:
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);
32938: 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)) )
3293c: 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
)
{
32940: e92d4013 push {r0, r1, r4, lr} <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
32944: e590c034 ldr ip, [r0, #52] ; 0x34 <== NOT EXECUTED
32948: 1a000003 bne 3295c <msdos_set_file_size+0x24> <== NOT EXECUTED
3294c: e5dc200a ldrb r2, [ip, #10] <== NOT EXECUTED
32950: e3120003 tst r2, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
32954: 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)) )
32958: 1a000003 bne 3296c <msdos_set_file_size+0x34> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
3295c: e5dce005 ldrb lr, [ip, #5] <== NOT EXECUTED
32960: e59c2030 ldr r2, [ip, #48] ; 0x30 <== NOT EXECUTED
32964: e2433002 sub r3, r3, #2 <== NOT EXECUTED
32968: 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));
3296c: e1dc20b0 ldrh r2, [ip] <== NOT EXECUTED
le_new_length = CT_LE_L((fat_fd->fat_file_size));
32970: e5914018 ldr r4, [r1, #24] <== 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);
32974: e5911024 ldr r1, [r1, #36] ; 0x24 <== NOT EXECUTED
32978: e5dce002 ldrb lr, [ip, #2] <== NOT EXECUTED
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
3297c: e2422001 sub r2, r2, #1 <== NOT EXECUTED
le_new_length = CT_LE_L((fat_fd->fat_file_size));
32980: e28dc008 add ip, sp, #8 <== NOT EXECUTED
32984: 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));
32988: e0022001 and r2, r2, r1 <== 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,
3298c: e282201c add r2, r2, #28 <== NOT EXECUTED
32990: e0831e31 add r1, r3, r1, lsr lr <== NOT EXECUTED
32994: e3a03004 mov r3, #4 <== NOT EXECUTED
32998: e58dc000 str ip, [sp] <== NOT EXECUTED
3299c: ebffc006 bl 229bc <_fat_block_write> <== NOT EXECUTED
(char *)(&le_new_length));
if ( ret < 0 )
329a0: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
return RC_OK;
}
329a4: b3e00000 mvnlt r0, #0 <== NOT EXECUTED
329a8: a3a00000 movge r0, #0 <== NOT EXECUTED
329ac: e8bd801c pop {r2, r3, r4, pc} <== NOT EXECUTED
00032a64 <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
)
{
32a64: e92d47ff push {r0, r1, r2, r3, 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;
32a68: e2814008 add r4, r1, #8 <== NOT EXECUTED
32a6c: 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
)
{
32a70: 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;
32a74: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
32a78: 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;
32a7c: e5904034 ldr r4, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
32a80: e5916000 ldr r6, [r1] <== NOT EXECUTED
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
32a84: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED
32a88: e1560003 cmp r6, r3 <== NOT EXECUTED
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
32a8c: e1a05000 mov r5, r0 <== 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;
fat_pos_t end = dir_pos->sname;
32a90: e5918004 ldr r8, [r1, #4] <== NOT EXECUTED
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
32a94: 1a000003 bne 32aa8 <msdos_set_first_char4file_name+0x44> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
32a98: e5d4300a ldrb r3, [r4, #10] <== NOT EXECUTED
32a9c: e3130003 tst r3, #3 <== NOT EXECUTED
dir_block_size = fs_info->fat.vol.rdir_size;
32aa0: 15947028 ldrne r7, [r4, #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)))
32aa4: 1a000000 bne 32aac <msdos_set_first_char4file_name+0x48> <== NOT EXECUTED
dir_block_size = fs_info->fat.vol.rdir_size;
else
dir_block_size = fs_info->fat.vol.bpc;
32aa8: e1d470b6 ldrh r7, [r4, #6] <== NOT EXECUTED
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
32aac: e5913008 ldr r3, [r1, #8] <== NOT EXECUTED
32ab0: e3730001 cmn r3, #1 <== NOT EXECUTED
start = dir_pos->sname;
32ab4: 0891000c ldmeq r1, {r2, r3} <== NOT EXECUTED
32ab8: 058d2008 streq r2, [sp, #8] <== NOT EXECUTED
32abc: 058d300c streq r3, [sp, #12] <== 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,
32ac0: e28da004 add sl, 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);
32ac4: e28d9008 add r9, sp, #8 <== NOT EXECUTED
* name code was written rather than use the fat_file_write
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
32ac8: e59d2008 ldr r2, [sp, #8] <== 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)) )
32acc: 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;
32ad0: e5953034 ldr r3, [r5, #52] ; 0x34 <== NOT EXECUTED
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
32ad4: 1a000003 bne 32ae8 <msdos_set_first_char4file_name+0x84> <== NOT EXECUTED
32ad8: e5d3100a ldrb r1, [r3, #10] <== NOT EXECUTED
32adc: e3110003 tst r1, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
32ae0: 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)) )
32ae4: 1a000003 bne 32af8 <msdos_set_first_char4file_name+0x94> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
32ae8: e5930030 ldr r0, [r3, #48] ; 0x30 <== NOT EXECUTED
32aec: e5d33005 ldrb r3, [r3, #5] <== NOT EXECUTED
32af0: e2421002 sub r1, r2, #2 <== NOT EXECUTED
32af4: e0801311 add r1, r0, r1, lsl r3 <== NOT EXECUTED
(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,
32af8: e1d420b0 ldrh r2, [r4] <== NOT EXECUTED
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
32afc: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
32b00: e5d40002 ldrb r0, [r4, #2] <== NOT EXECUTED
32b04: e2422001 sub r2, r2, #1 <== NOT EXECUTED
32b08: e0811033 add r1, r1, r3, lsr r0 <== NOT EXECUTED
32b0c: e0022003 and r2, r2, r3 <== NOT EXECUTED
32b10: e1a00005 mov r0, r5 <== NOT EXECUTED
32b14: e3a03001 mov r3, #1 <== NOT EXECUTED
32b18: e58da000 str sl, [sp] <== NOT EXECUTED
32b1c: ebffbfa6 bl 229bc <_fat_block_write> <== NOT EXECUTED
&fchar);
if (ret < 0)
32b20: e3500000 cmp r0, #0 <== NOT EXECUTED
32b24: ba000018 blt 32b8c <msdos_set_first_char4file_name+0x128> <== NOT EXECUTED
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
32b28: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
32b2c: e1530006 cmp r3, r6 <== NOT EXECUTED
32b30: 1a000002 bne 32b40 <msdos_set_first_char4file_name+0xdc> <== NOT EXECUTED
32b34: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
32b38: e1530008 cmp r3, r8 <== NOT EXECUTED
32b3c: 0a000014 beq 32b94 <msdos_set_first_char4file_name+0x130> <== NOT EXECUTED
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
32b40: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
32b44: e2833020 add r3, r3, #32 <== NOT EXECUTED
if (start.ofs >= dir_block_size)
32b48: e1530007 cmp r3, r7 <== NOT EXECUTED
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
32b4c: e58d300c str r3, [sp, #12] <== NOT EXECUTED
if (start.ofs >= dir_block_size)
32b50: 3affffdc bcc 32ac8 <msdos_set_first_char4file_name+0x64> <== NOT EXECUTED
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
32b54: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED
32b58: e1560003 cmp r6, r3 <== NOT EXECUTED
32b5c: 1a000002 bne 32b6c <msdos_set_first_char4file_name+0x108> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
32b60: e5d4300a ldrb r3, [r4, #10] <== NOT EXECUTED
32b64: e3130003 tst r3, #3 <== NOT EXECUTED
32b68: 1a000009 bne 32b94 <msdos_set_first_char4file_name+0x130> <== NOT EXECUTED
break;
rc = fat_get_fat_cluster(mt_entry, start.cln, &start.cln);
32b6c: e1a00005 mov r0, r5 <== NOT EXECUTED
32b70: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED
32b74: e1a02009 mov r2, r9 <== NOT EXECUTED
32b78: eb0019e6 bl 39318 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
32b7c: e3500000 cmp r0, #0 <== NOT EXECUTED
32b80: 1a000004 bne 32b98 <msdos_set_first_char4file_name+0x134> <== NOT EXECUTED
return rc;
start.ofs = 0;
32b84: e58d000c str r0, [sp, #12] <== NOT EXECUTED
32b88: eaffffce b 32ac8 <msdos_set_first_char4file_name+0x64> <== NOT EXECUTED
32b8c: e3e00000 mvn r0, #0 <== NOT EXECUTED
32b90: ea000000 b 32b98 <msdos_set_first_char4file_name+0x134> <== NOT EXECUTED
32b94: e3a00000 mov r0, #0 <== NOT EXECUTED
}
}
return RC_OK;
}
32b98: e28dd010 add sp, sp, #16 <== NOT EXECUTED
32b9c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
000329b0 <msdos_set_first_cluster_num>:
/*
* 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);
329b0: 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)) )
329b4: 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
)
{
329b8: e92d41f3 push {r0, r1, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
329bc: e5902034 ldr r2, [r0, #52] ; 0x34 <== NOT EXECUTED
int
msdos_set_first_cluster_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
329c0: e1a04000 mov r4, r0 <== 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;
329c4: e591701c ldr r7, [r1, #28] <== NOT EXECUTED
329c8: 1a000003 bne 329dc <msdos_set_first_cluster_num+0x2c> <== NOT EXECUTED
329cc: e5d2000a ldrb r0, [r2, #10] <== NOT EXECUTED
329d0: e3100003 tst r0, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
329d4: 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)) )
329d8: 1a000003 bne 329ec <msdos_set_first_cluster_num+0x3c> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
329dc: e5d2c005 ldrb ip, [r2, #5] <== NOT EXECUTED
329e0: e5920030 ldr r0, [r2, #48] ; 0x30 <== NOT EXECUTED
329e4: e2433002 sub r3, r3, #2 <== NOT EXECUTED
329e8: 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);
329ec: e5d26002 ldrb r6, [r2, #2] <== NOT EXECUTED
329f0: e5911024 ldr r1, [r1, #36] ; 0x24 <== NOT EXECUTED
329f4: 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);
329f8: e1d250b0 ldrh r5, [r2] <== NOT EXECUTED
329fc: e2455001 sub r5, r5, #1 <== NOT EXECUTED
32a00: 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,
32a04: e28dc006 add ip, sp, #6 <== NOT EXECUTED
32a08: e1a01006 mov r1, r6 <== NOT EXECUTED
32a0c: e285201a add r2, r5, #26 <== NOT EXECUTED
32a10: e58dc000 str ip, [sp] <== NOT EXECUTED
32a14: 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;
32a18: 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,
32a1c: 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));
32a20: 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;
32a24: 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,
32a28: ebffbfe3 bl 229bc <_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));
32a2c: e1a07827 lsr r7, r7, #16 <== NOT EXECUTED
32a30: e28dc008 add ip, sp, #8 <== NOT EXECUTED
32a34: 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,
32a38: 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,
32a3c: e1a01006 mov r1, r6 <== NOT EXECUTED
32a40: e1a00004 mov r0, r4 <== NOT EXECUTED
32a44: e2852014 add r2, r5, #20 <== NOT EXECUTED
32a48: e3a03002 mov r3, #2 <== NOT EXECUTED
32a4c: e58dc000 str ip, [sp] <== NOT EXECUTED
32a50: ebffbfd9 bl 229bc <_fat_block_write> <== NOT EXECUTED
byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
(char *)(&le_cl_hi));
if ( (ret1 < 0) || (ret2 < 0) )
32a54: e1a08fa8 lsr r8, r8, #31 <== NOT EXECUTED
32a58: e1980fa0 orrs r0, r8, r0, lsr #31 <== NOT EXECUTED
return -1;
return RC_OK;
}
32a5c: 13e00000 mvnne r0, #0 <== NOT EXECUTED
32a60: e8bd81fc pop {r2, r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00031da4 <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)
{
31da4: 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)
31da8: 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)
{
31dac: e1a04000 mov r4, r0 <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = temp_mt_entry->fs_info;
31db0: 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)
31db4: ebffc13f bl 222b8 <fat_file_close> <== NOT EXECUTED
31db8: 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)
31dbc: 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)
31dc0: 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)
31dc4: ebffc340 bl 22acc <fat_shutdown_drive> <== NOT EXECUTED
31dc8: e3500000 cmp r0, #0 <== NOT EXECUTED
{
/* no return - try to free as much as possible */
rc = -1;
}
rtems_semaphore_delete(fs_info->vol_sema);
31dcc: 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)
31dd0: 13e06000 mvnne r6, #0 <== NOT EXECUTED
{
/* no return - try to free as much as possible */
rc = -1;
}
rtems_semaphore_delete(fs_info->vol_sema);
31dd4: ebff667b bl b7c8 <rtems_semaphore_delete> <== NOT EXECUTED
free(fs_info->cl_buf);
31dd8: e5950098 ldr r0, [r5, #152] ; 0x98 <== NOT EXECUTED
31ddc: ebff5634 bl 76b4 <free> <== NOT EXECUTED
free(temp_mt_entry->fs_info);
31de0: e5940034 ldr r0, [r4, #52] ; 0x34 <== NOT EXECUTED
31de4: ebff5632 bl 76b4 <free> <== NOT EXECUTED
return rc;
}
31de8: e1a00006 mov r0, r6 <== NOT EXECUTED
31dec: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00002838 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
2838: e92d4010 push {r4, lr}
283c: e1a04000 mov r4, r0
switch ( fileno(fp) ) {
2840: eb002bde bl d7c0 <fileno>
2844: e3500002 cmp r0, #2
2848: 8a00000b bhi 287c <newlib_free_buffers+0x44>
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
284c: e1d430bc ldrh r3, [r4, #12]
2850: e3130080 tst r3, #128 ; 0x80
2854: 0a00000a beq 2884 <newlib_free_buffers+0x4c>
free( fp->_bf._base );
2858: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
285c: ebfffd9b bl 1ed0 <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
2860: e1d420bc ldrh r2, [r4, #12] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
2864: e3a03000 mov r3, #0 <== NOT EXECUTED
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
2868: e3c22080 bic r2, r2, #128 ; 0x80 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
286c: e5843010 str r3, [r4, #16] <== NOT EXECUTED
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
2870: e1c420bc strh r2, [r4, #12] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
2874: e5843000 str r3, [r4] <== NOT EXECUTED
2878: ea000001 b 2884 <newlib_free_buffers+0x4c> <== NOT EXECUTED
}
break;
default:
fclose(fp);
287c: e1a00004 mov r0, r4 <== NOT EXECUTED
2880: eb002b1c bl d4f8 <fclose> <== NOT EXECUTED
}
return 0;
}
2884: e3a00000 mov r0, #0
2888: e8bd8010 pop {r4, pc}
00002aac <open>:
int open(
const char *pathname,
int flags,
...
)
{
2aac: e92d000e push {r1, r2, r3}
2ab0: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
2ab4: e24dd01c sub sp, sp, #28
2ab8: e59d503c ldr r5, [sp, #60] ; 0x3c
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
2abc: e2853001 add r3, r5, #1
if ( ( status & _FREAD ) == _FREAD )
2ac0: e2138001 ands r8, r3, #1
2ac4: 13a08004 movne r8, #4
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
2ac8: e3130002 tst r3, #2
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
va_start(ap, flags);
mode = va_arg( ap, int );
2acc: e28d3044 add r3, sp, #68 ; 0x44
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;
2ad0: 13888002 orrne r8, r8, #2
int open(
const char *pathname,
int flags,
...
)
{
2ad4: e1a06000 mov r6, r0
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
va_start(ap, flags);
mode = va_arg( ap, int );
2ad8: e58d3018 str r3, [sp, #24]
2adc: e59d9040 ldr r9, [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();
2ae0: eb001e28 bl a388 <rtems_libio_allocate>
if ( iop == 0 ) {
2ae4: e2504000 subs r4, r0, #0
2ae8: 03a05017 moveq r5, #23
2aec: 0a000077 beq 2cd0 <open+0x224>
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
2af0: e1a00006 mov r0, r6
2af4: eb002e37 bl e3d8 <strlen>
2af8: e28d7004 add r7, sp, #4
2afc: e1a01000 mov r1, r0
2b00: e1a02008 mov r2, r8
2b04: e1a00006 mov r0, r6
2b08: e3a08001 mov r8, #1
2b0c: e1a03007 mov r3, r7
2b10: e58d8000 str r8, [sp]
2b14: ebfffccf bl 1e58 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
2b18: e3700001 cmn r0, #1
2b1c: 1a00001f bne 2ba0 <open+0xf4>
if ( errno != ENOENT ) {
2b20: eb002a27 bl d3c4 <__errno>
2b24: e5903000 ldr r3, [r0]
2b28: e3530002 cmp r3, #2
2b2c: 1a00000a bne 2b5c <open+0xb0>
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
2b30: e215ac02 ands sl, r5, #512 ; 0x200
2b34: 01a0700a moveq r7, sl
2b38: 01a05003 moveq r5, r3
2b3c: 0a000056 beq 2c9c <open+0x1f0>
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
2b40: e1a00006 mov r0, r6
2b44: e3891902 orr r1, r9, #32768 ; 0x8000
2b48: e3a02000 mov r2, #0
2b4c: e3a03000 mov r3, #0
2b50: ebfffdec bl 2308 <mknod>
if ( rc ) {
2b54: e250a000 subs sl, r0, #0
2b58: 0a000003 beq 2b6c <open+0xc0>
rc = errno;
2b5c: eb002a18 bl d3c4 <__errno>
2b60: e3a07000 mov r7, #0
2b64: e5905000 ldr r5, [r0]
goto done;
2b68: ea000049 b 2c94 <open+0x1e8>
}
/* Sanity check to see if the file name exists after the mknod() */
status = rtems_filesystem_evaluate_path( pathname, strlen( pathname ), 0x0, &loc, true );
2b6c: e1a00006 mov r0, r6
2b70: eb002e18 bl e3d8 <strlen>
2b74: e1a03007 mov r3, r7
2b78: e1a01000 mov r1, r0
2b7c: e1a0200a mov r2, sl
2b80: e1a00006 mov r0, r6
2b84: e58d8000 str r8, [sp]
2b88: ebfffcb2 bl 1e58 <rtems_filesystem_evaluate_path>
if ( status != 0 ) { /* The file did not exist */
2b8c: e3500000 cmp r0, #0
2b90: 11a0700a movne r7, sl
2b94: 13a0500d movne r5, #13
2b98: 1a00003f bne 2c9c <open+0x1f0>
2b9c: ea000003 b 2bb0 <open+0x104>
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
2ba0: e2053c0a and r3, r5, #2560 ; 0xa00
2ba4: e3530c0a cmp r3, #2560 ; 0xa00
2ba8: 03a05011 moveq r5, #17
2bac: 0a00003a beq 2c9c <open+0x1f0>
* 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;
2bb0: e28d701c add r7, sp, #28
2bb4: e5373018 ldr r3, [r7, #-24]!
2bb8: e5843038 str r3, [r4, #56] ; 0x38
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->handlers = loc.handlers;
2bbc: e59d300c ldr r3, [sp, #12]
iop->file_info = loc.node_access;
iop->flags |= rtems_libio_fcntl_flags( flags );
2bc0: e1a00005 mov r0, r5
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->handlers = loc.handlers;
2bc4: e584303c str r3, [r4, #60] ; 0x3c
iop->file_info = loc.node_access;
iop->flags |= rtems_libio_fcntl_flags( flags );
2bc8: e5948014 ldr r8, [r4, #20]
2bcc: eb001e1a bl a43c <rtems_libio_fcntl_flags>
2bd0: e180e008 orr lr, r0, r8
iop->pathinfo = loc;
2bd4: e8b7000f ldm r7!, {r0, r1, r2, r3}
2bd8: e284c018 add ip, r4, #24
2bdc: e8ac000f stmia ip!, {r0, r1, r2, r3}
if ( !iop->handlers || !iop->handlers->open_h ) {
2be0: 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;
2be4: e5972000 ldr r2, [r7]
if ( !iop->handlers || !iop->handlers->open_h ) {
2be8: e3530000 cmp r3, #0
*/
iop->handlers = loc.handlers;
iop->file_info = loc.node_access;
iop->flags |= rtems_libio_fcntl_flags( flags );
iop->pathinfo = loc;
2bec: 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 );
2bf0: e584e014 str lr, [r4, #20]
iop->pathinfo = loc;
if ( !iop->handlers || !iop->handlers->open_h ) {
2bf4: 0a000041 beq 2d00 <open+0x254>
2bf8: e593c000 ldr ip, [r3]
2bfc: e35c0000 cmp ip, #0
2c00: 0a00003e beq 2d00 <open+0x254>
rc = ENOTSUP;
goto done;
}
rc = (*iop->handlers->open_h)( iop, pathname, flags, mode );
2c04: e1a01006 mov r1, r6
2c08: e1a03009 mov r3, r9
2c0c: e1a00004 mov r0, r4
2c10: e1a02005 mov r2, r5
2c14: e1a0e00f mov lr, pc
2c18: e12fff1c bx ip
if ( rc ) {
2c1c: e3500000 cmp r0, #0
2c20: 0a000003 beq 2c34 <open+0x188>
rc = errno;
2c24: eb0029e6 bl d3c4 <__errno>
2c28: e28d7004 add r7, sp, #4
2c2c: e5905000 ldr r5, [r0]
goto done;
2c30: ea000017 b 2c94 <open+0x1e8>
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
2c34: e3150b01 tst r5, #1024 ; 0x400
2c38: 0a000028 beq 2ce0 <open+0x234>
rc = ftruncate( iop - rtems_libio_iops, 0 );
2c3c: e59f30c8 ldr r3, [pc, #200] ; 2d0c <open+0x260>
2c40: e5930000 ldr r0, [r3]
2c44: e0600004 rsb r0, r0, r4
2c48: e1a00340 asr r0, r0, #6
2c4c: e3a01000 mov r1, #0
2c50: e3a02000 mov r2, #0
2c54: eb001d26 bl a0f4 <ftruncate>
if ( rc ) {
2c58: e2505000 subs r5, r0, #0
2c5c: 0a00001f beq 2ce0 <open+0x234>
if(errno) rc = errno;
2c60: eb0029d7 bl d3c4 <__errno> <== NOT EXECUTED
2c64: e5903000 ldr r3, [r0] <== NOT EXECUTED
2c68: e3530000 cmp r3, #0 <== NOT EXECUTED
2c6c: 0a000001 beq 2c78 <open+0x1cc> <== NOT EXECUTED
2c70: eb0029d3 bl d3c4 <__errno> <== NOT EXECUTED
2c74: e5905000 ldr r5, [r0] <== NOT EXECUTED
close( iop - rtems_libio_iops );
2c78: e59f308c ldr r3, [pc, #140] ; 2d0c <open+0x260> <== NOT EXECUTED
2c7c: e5933000 ldr r3, [r3] <== NOT EXECUTED
2c80: e0634004 rsb r4, r3, r4 <== NOT EXECUTED
2c84: e1a00344 asr r0, r4, #6 <== NOT EXECUTED
2c88: eb001cf0 bl a050 <close> <== NOT EXECUTED
2c8c: e3a04000 mov r4, #0 <== NOT EXECUTED
2c90: e1a07004 mov r7, r4 <== NOT EXECUTED
*/
done:
va_end(ap);
if ( rc ) {
2c94: e3550000 cmp r5, #0
2c98: 0a000010 beq 2ce0 <open+0x234>
if ( iop )
2c9c: e3540000 cmp r4, #0
rtems_libio_free( iop );
2ca0: 11a00004 movne r0, r4
2ca4: 1b001da0 blne a32c <rtems_libio_free>
if ( loc_to_free )
2ca8: e3570000 cmp r7, #0
2cac: 0a000007 beq 2cd0 <open+0x224>
rtems_filesystem_freenode( loc_to_free );
2cb0: e597300c ldr r3, [r7, #12]
2cb4: e3530000 cmp r3, #0
2cb8: 0a000004 beq 2cd0 <open+0x224>
2cbc: e593301c ldr r3, [r3, #28]
2cc0: e3530000 cmp r3, #0
2cc4: 11a00007 movne r0, r7
2cc8: 11a0e00f movne lr, pc
2ccc: 112fff13 bxne r3
rtems_set_errno_and_return_minus_one( rc );
2cd0: eb0029bb bl d3c4 <__errno>
2cd4: e5805000 str r5, [r0]
2cd8: e3e00000 mvn r0, #0
2cdc: ea000003 b 2cf0 <open+0x244>
}
return iop - rtems_libio_iops;
2ce0: e59f3024 ldr r3, [pc, #36] ; 2d0c <open+0x260>
2ce4: e5930000 ldr r0, [r3]
2ce8: e0604004 rsb r4, r0, r4
2cec: e1a00344 asr r0, r4, #6
}
2cf0: e28dd01c add sp, sp, #28
2cf4: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
2cf8: e28dd00c add sp, sp, #12
2cfc: e12fff1e bx lr
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
}
return iop - rtems_libio_iops;
2d00: e28d7004 add r7, sp, #4 <== NOT EXECUTED
2d04: e3a05086 mov r5, #134 ; 0x86 <== NOT EXECUTED
2d08: eaffffe3 b 2c9c <open+0x1f0> <== NOT EXECUTED
00002a48 <open_dev_console>:
int stderr_fd;
/*
* Attempt to open /dev/console.
*/
if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) {
2a48: e3a01000 mov r1, #0
/*
* This is a replaceable stub which opens the console, if present.
*/
void open_dev_console(void)
{
2a4c: 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) {
2a50: e59f0048 ldr r0, [pc, #72] ; 2aa0 <open_dev_console+0x58>
2a54: e1a02001 mov r2, r1
2a58: eb000013 bl 2aac <open>
2a5c: e3700001 cmn r0, #1
2a60: 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)
2a64: e59f0034 ldr r0, [pc, #52] ; 2aa0 <open_dev_console+0x58>
2a68: e3a01001 mov r1, #1
2a6c: e3a02000 mov r2, #0
2a70: eb00000d bl 2aac <open>
2a74: e3700001 cmn r0, #1
rtems_fatal_error_occurred( 0x55544431 ); /* error STD1 */
2a78: 059f0024 ldreq r0, [pc, #36] ; 2aa4 <open_dev_console+0x5c>
/*
* 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)
2a7c: 0a000006 beq 2a9c <open_dev_console+0x54>
rtems_fatal_error_occurred( 0x55544431 ); /* error STD1 */
if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1)
2a80: e59f0018 ldr r0, [pc, #24] ; 2aa0 <open_dev_console+0x58>
2a84: e3a01001 mov r1, #1
2a88: e3a02000 mov r2, #0
2a8c: eb000006 bl 2aac <open>
2a90: e3700001 cmn r0, #1
2a94: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
rtems_fatal_error_occurred( 0x55544432 ); /* error STD2 */
2a98: e59f0008 ldr r0, [pc, #8] ; 2aa8 <open_dev_console+0x60> <== NOT EXECUTED
2a9c: eb000b41 bl 57a8 <rtems_fatal_error_occurred> <== NOT EXECUTED
00003448 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
3448: e92d4011 push {r0, r4, lr}
int i;
if (tty->termios.c_oflag & OPOST) {
344c: e5913034 ldr r3, [r1, #52] ; 0x34
3450: e3130001 tst r3, #1
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
3454: e1a04001 mov r4, r1
3458: e5cd0000 strb r0, [sp]
int i;
if (tty->termios.c_oflag & OPOST) {
345c: 0a000047 beq 3580 <oproc+0x138>
switch (c) {
3460: e5dd2000 ldrb r2, [sp]
3464: e2421008 sub r1, r2, #8
3468: e3510005 cmp r1, #5
346c: 979ff101 ldrls pc, [pc, r1, lsl #2]
3470: ea00002e b 3530 <oproc+0xe8>
3474: 0000351c .word 0x0000351c
3478: 000034f0 .word 0x000034f0
347c: 0000348c .word 0x0000348c
3480: 00003530 .word 0x00003530
3484: 00003530 .word 0x00003530
3488: 000034b8 .word 0x000034b8
case '\n':
if (tty->termios.c_oflag & ONLRET)
348c: e3130020 tst r3, #32
tty->column = 0;
3490: 13a03000 movne r3, #0
3494: 15843028 strne r3, [r4, #40] ; 0x28
if (tty->termios.c_oflag & ONLCR) {
3498: e5943034 ldr r3, [r4, #52] ; 0x34
349c: e3130004 tst r3, #4
34a0: 0a000036 beq 3580 <oproc+0x138>
rtems_termios_puts ("\r", 1, tty);
34a4: e59f00e8 ldr r0, [pc, #232] ; 3594 <oproc+0x14c>
34a8: e3a01001 mov r1, #1
34ac: e1a02004 mov r2, r4
34b0: ebffffa3 bl 3344 <rtems_termios_puts>
34b4: ea00000b b 34e8 <oproc+0xa0>
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
34b8: e3130010 tst r3, #16 <== NOT EXECUTED
34bc: 0a000002 beq 34cc <oproc+0x84> <== NOT EXECUTED
34c0: e5942028 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED
34c4: e3520000 cmp r2, #0 <== NOT EXECUTED
34c8: 0a000030 beq 3590 <oproc+0x148> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
34cc: e2132008 ands r2, r3, #8 <== NOT EXECUTED
c = '\n';
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
break;
}
tty->column = 0;
34d0: 05842028 streq r2, [r4, #40] ; 0x28 <== NOT EXECUTED
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
return;
if (tty->termios.c_oflag & OCRNL) {
34d4: 0a000029 beq 3580 <oproc+0x138> <== NOT EXECUTED
c = '\n';
if (tty->termios.c_oflag & ONLRET)
34d8: 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';
34dc: e3a0300a mov r3, #10 <== NOT EXECUTED
34e0: e5cd3000 strb r3, [sp] <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
34e4: 0a000025 beq 3580 <oproc+0x138> <== NOT EXECUTED
tty->column = 0;
34e8: e3a03000 mov r3, #0
34ec: ea000022 b 357c <oproc+0x134>
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
34f0: e5942028 ldr r2, [r4, #40] ; 0x28
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
34f4: e2033b06 and r3, r3, #6144 ; 0x1800
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
34f8: e2021007 and r1, r2, #7
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
34fc: e3530b06 cmp r3, #6144 ; 0x1800
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
3500: e2611008 rsb r1, r1, #8
3504: e0813002 add r3, r1, r2
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
3508: 1a00001b bne 357c <oproc+0x134>
tty->column += i;
350c: e5843028 str r3, [r4, #40] ; 0x28
rtems_termios_puts ( " ", i, tty);
3510: e1a02004 mov r2, r4
3514: e59f007c ldr r0, [pc, #124] ; 3598 <oproc+0x150>
3518: ea00001b b 358c <oproc+0x144>
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
351c: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
3520: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
3524: c2433001 subgt r3, r3, #1 <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
3528: ca000013 bgt 357c <oproc+0x134> <== NOT EXECUTED
352c: ea000013 b 3580 <oproc+0x138> <== NOT EXECUTED
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
3530: e3130002 tst r3, #2
3534: 0a000007 beq 3558 <oproc+0x110>
c = toupper(c);
3538: e59f305c ldr r3, [pc, #92] ; 359c <oproc+0x154> <== NOT EXECUTED
353c: e5933000 ldr r3, [r3] <== NOT EXECUTED
3540: e0833002 add r3, r3, r2 <== NOT EXECUTED
3544: e5d33001 ldrb r3, [r3, #1] <== NOT EXECUTED
3548: e2033003 and r3, r3, #3 <== NOT EXECUTED
354c: e3530002 cmp r3, #2 <== NOT EXECUTED
3550: 02422020 subeq r2, r2, #32 <== NOT EXECUTED
3554: e5cd2000 strb r2, [sp] <== NOT EXECUTED
if (!iscntrl(c))
3558: e59f303c ldr r3, [pc, #60] ; 359c <oproc+0x154>
355c: e5932000 ldr r2, [r3]
3560: e5dd3000 ldrb r3, [sp]
3564: e0823003 add r3, r2, r3
3568: e5d33001 ldrb r3, [r3, #1]
356c: e3130020 tst r3, #32
3570: 1a000002 bne 3580 <oproc+0x138>
tty->column++;
3574: e5943028 ldr r3, [r4, #40] ; 0x28
3578: e2833001 add r3, r3, #1
357c: e5843028 str r3, [r4, #40] ; 0x28
break;
}
}
rtems_termios_puts (&c, 1, tty);
3580: e1a02004 mov r2, r4
3584: e1a0000d mov r0, sp
3588: e3a01001 mov r1, #1
358c: ebffff6c bl 3344 <rtems_termios_puts>
}
3590: e8bd8018 pop {r3, r4, pc}
0000c590 <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
c590: e92d4070 push {r4, r5, r6, lr}
c594: 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)
c598: e28d5004 add r5, sp, #4
c59c: e3a0c001 mov ip, #1
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
c5a0: e1a04000 mov r4, 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)
c5a4: e3a01003 mov r1, #3
c5a8: e59f0140 ldr r0, [pc, #320] ; c6f0 <pipe_create+0x160>
c5ac: e3a02007 mov r2, #7
c5b0: e1a03005 mov r3, r5
c5b4: e58dc000 str ip, [sp]
c5b8: ebffd626 bl 1e58 <rtems_filesystem_evaluate_path>
c5bc: e3500000 cmp r0, #0
c5c0: 0a000009 beq c5ec <pipe_create+0x5c>
!= 0) {
if (errno != ENOENT)
c5c4: eb00037e bl d3c4 <__errno>
c5c8: e5903000 ldr r3, [r0]
c5cc: e3530002 cmp r3, #2
c5d0: 1a000043 bne c6e4 <pipe_create+0x154>
return -1;
if (mkdir("/tmp", S_IRWXU|S_IRWXG|S_IRWXO|S_ISVTX) != 0)
c5d4: e59f0114 ldr r0, [pc, #276] ; c6f0 <pipe_create+0x160>
c5d8: e59f1114 ldr r1, [pc, #276] ; c6f4 <pipe_create+0x164>
c5dc: ebffd745 bl 22f8 <mkdir>
c5e0: e3500000 cmp r0, #0
c5e4: 0a000008 beq c60c <pipe_create+0x7c>
c5e8: ea00003d b c6e4 <pipe_create+0x154> <== NOT EXECUTED
return -1;
}
else
rtems_filesystem_freenode(&loc);
c5ec: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
c5f0: e3530000 cmp r3, #0 <== NOT EXECUTED
c5f4: 0a000004 beq c60c <pipe_create+0x7c> <== NOT EXECUTED
c5f8: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
c5fc: e3530000 cmp r3, #0 <== NOT EXECUTED
c600: 11a00005 movne r0, r5 <== NOT EXECUTED
c604: 11a0e00f movne lr, pc <== NOT EXECUTED
c608: 112fff13 bxne r3 <== NOT EXECUTED
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
c60c: e28d5018 add r5, sp, #24
c610: e59f10e0 ldr r1, [pc, #224] ; c6f8 <pipe_create+0x168>
c614: e3a0200a mov r2, #10
c618: e1a00005 mov r0, r5
c61c: eb000576 bl dbfc <memcpy>
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
c620: e59f30d4 ldr r3, [pc, #212] ; c6fc <pipe_create+0x16c>
c624: e1d3c0b0 ldrh ip, [r3]
c628: e1a0200c mov r2, ip
c62c: e28cc001 add ip, ip, #1
c630: e59f10c8 ldr r1, [pc, #200] ; c700 <pipe_create+0x170>
c634: e1c3c0b0 strh ip, [r3]
c638: e285000a add r0, r5, #10
c63c: eb000614 bl de94 <sprintf>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
c640: e1a00005 mov r0, r5
c644: e3a01d06 mov r1, #384 ; 0x180
c648: eb000190 bl cc90 <mkfifo>
c64c: e2506000 subs r6, r0, #0
c650: 0a000001 beq c65c <pipe_create+0xcc>
if (errno != EEXIST){
c654: eb00035a bl d3c4 <__errno> <== NOT EXECUTED
c658: ea000021 b c6e4 <pipe_create+0x154> <== NOT EXECUTED
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);
c65c: e1a00005 mov r0, r5
c660: e3a01901 mov r1, #16384 ; 0x4000
c664: ebffd910 bl 2aac <open>
if (filsdes[0] < 0) {
c668: 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);
c66c: e5840000 str r0, [r4]
if (filsdes[0] < 0) {
c670: aa000003 bge c684 <pipe_create+0xf4>
err = errno;
c674: eb000352 bl d3c4 <__errno>
c678: 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);
c67c: e1a00005 mov r0, r5
c680: ea000014 b c6d8 <pipe_create+0x148>
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
c684: e59f3078 ldr r3, [pc, #120] ; c704 <pipe_create+0x174> <== NOT EXECUTED
c688: e5933000 ldr r3, [r3] <== NOT EXECUTED
c68c: e1500003 cmp r0, r3 <== NOT EXECUTED
c690: 359f3070 ldrcc r3, [pc, #112] ; c708 <pipe_create+0x178> <== NOT EXECUTED
c694: 35936000 ldrcc r6, [r3] <== NOT EXECUTED
c698: 30866300 addcc r6, r6, r0, lsl #6 <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
c69c: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED
c6a0: e3c33001 bic r3, r3, #1 <== NOT EXECUTED
c6a4: e5863014 str r3, [r6, #20] <== NOT EXECUTED
filsdes[1] = open(fifopath, O_WRONLY);
c6a8: e28d0018 add r0, sp, #24 <== NOT EXECUTED
c6ac: e3a01001 mov r1, #1 <== NOT EXECUTED
c6b0: ebffd8fd bl 2aac <open> <== NOT EXECUTED
if (filsdes[1] < 0) {
c6b4: 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);
c6b8: e5840004 str r0, [r4, #4] <== NOT EXECUTED
if (filsdes[1] < 0) {
c6bc: a3a06000 movge r6, #0 <== NOT EXECUTED
c6c0: aa000003 bge c6d4 <pipe_create+0x144> <== NOT EXECUTED
err = errno;
c6c4: eb00033e bl d3c4 <__errno> <== NOT EXECUTED
c6c8: e5906000 ldr r6, [r0] <== NOT EXECUTED
close(filsdes[0]);
c6cc: e5940000 ldr r0, [r4] <== NOT EXECUTED
c6d0: ebfff65e bl a050 <close> <== NOT EXECUTED
}
unlink(fifopath);
c6d4: e28d0018 add r0, sp, #24 <== NOT EXECUTED
c6d8: eb000170 bl cca0 <unlink>
}
rtems_set_errno_and_return_minus_one(err);
c6dc: eb000338 bl d3c4 <__errno>
c6e0: e5806000 str r6, [r0]
}
c6e4: e3e00000 mvn r0, #0
c6e8: e28dd028 add sp, sp, #40 ; 0x28
c6ec: e8bd8070 pop {r4, r5, r6, pc}
00008b84 <pipe_free>:
/* Called with rtems_pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
8b84: e92d4010 push {r4, lr} <== NOT EXECUTED
8b88: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_barrier_delete(pipe->readBarrier);
8b8c: e590002c ldr r0, [r0, #44] ; 0x2c <== NOT EXECUTED
8b90: eb000713 bl a7e4 <rtems_barrier_delete> <== NOT EXECUTED
rtems_barrier_delete(pipe->writeBarrier);
8b94: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED
8b98: eb000711 bl a7e4 <rtems_barrier_delete> <== NOT EXECUTED
rtems_semaphore_delete(pipe->Semaphore);
8b9c: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
8ba0: ebfff156 bl 5100 <rtems_semaphore_delete> <== NOT EXECUTED
free(pipe->Buffer);
8ba4: e5940000 ldr r0, [r4] <== NOT EXECUTED
8ba8: ebffe4c8 bl 1ed0 <free> <== NOT EXECUTED
free(pipe);
8bac: e1a00004 mov r0, r4 <== NOT EXECUTED
}
8bb0: e8bd4010 pop {r4, lr} <== NOT EXECUTED
{
rtems_barrier_delete(pipe->readBarrier);
rtems_barrier_delete(pipe->writeBarrier);
rtems_semaphore_delete(pipe->Semaphore);
free(pipe->Buffer);
free(pipe);
8bb4: eaffe4c5 b 1ed0 <free> <== NOT EXECUTED
00008824 <pipe_ioctl>:
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
8824: e59f3054 ldr r3, [pc, #84] ; 8880 <pipe_ioctl+0x5c> <== NOT EXECUTED
8828: e1510003 cmp r1, r3 <== NOT EXECUTED
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
882c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
8830: e1a04000 mov r4, r0 <== NOT EXECUTED
8834: e1a05002 mov r5, r2 <== NOT EXECUTED
if (cmd == FIONREAD) {
8838: 13e00015 mvnne r0, #21 <== NOT EXECUTED
883c: 18bd8070 popne {r4, r5, r6, pc} <== NOT EXECUTED
if (buffer == NULL)
8840: e3520000 cmp r2, #0 <== NOT EXECUTED
8844: 03e0000d mvneq r0, #13 <== NOT EXECUTED
8848: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return -EFAULT;
if (! PIPE_LOCK(pipe))
884c: e3a01000 mov r1, #0 <== NOT EXECUTED
8850: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
8854: e1a02001 mov r2, r1 <== NOT EXECUTED
8858: ebfff24f bl 519c <rtems_semaphore_obtain> <== NOT EXECUTED
885c: e2506000 subs r6, r0, #0 <== NOT EXECUTED
8860: 13e00003 mvnne r0, #3 <== NOT EXECUTED
8864: 18bd8070 popne {r4, r5, r6, pc} <== NOT EXECUTED
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
8868: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
886c: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
8870: e5853000 str r3, [r5] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
8874: ebfff28e bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
8878: e1a00006 mov r0, r6 <== NOT EXECUTED
return 0;
}
return -EINVAL;
}
887c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
000087bc <pipe_lseek>:
rtems_libio_t *iop
)
{
/* Seek on pipe is not supported */
return -ESPIPE;
}
87bc: e3e0001c mvn r0, #28 <== NOT EXECUTED
87c0: e12fff1e bx lr <== NOT EXECUTED
00008a14 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
8a14: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
8a18: e1a09001 mov r9, r1 <== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
8a1c: e3a01000 mov r1, #0 <== NOT EXECUTED
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
8a20: e1a04000 mov r4, r0 <== NOT EXECUTED
8a24: e1a05002 mov r5, r2 <== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
8a28: e5900028 ldr r0, [r0, #40] ; 0x28 <== NOT EXECUTED
8a2c: e1a02001 mov r2, r1 <== NOT EXECUTED
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
8a30: e1a0a003 mov sl, r3 <== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
8a34: ebfff1d8 bl 519c <rtems_semaphore_obtain> <== NOT EXECUTED
8a38: e2506000 subs r6, r0, #0 <== NOT EXECUTED
8a3c: 13e06003 mvnne r6, #3 <== NOT EXECUTED
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
8a40: 01a0b00d moveq fp, sp <== NOT EXECUTED
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
8a44: 0a000045 beq 8b60 <pipe_read+0x14c> <== NOT EXECUTED
8a48: ea00004b b 8b7c <pipe_read+0x168> <== NOT EXECUTED
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
8a4c: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
8a50: e3530000 cmp r3, #0 <== NOT EXECUTED
8a54: 0a000043 beq 8b68 <pipe_read+0x154> <== NOT EXECUTED
goto out_locked;
if (LIBIO_NODELAY(iop)) {
8a58: e59a7014 ldr r7, [sl, #20] <== NOT EXECUTED
8a5c: e2177001 ands r7, r7, #1 <== NOT EXECUTED
8a60: 13e0700a mvnne r7, #10 <== NOT EXECUTED
8a64: 1a000040 bne 8b6c <pipe_read+0x158> <== NOT EXECUTED
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
8a68: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED
8a6c: e2833001 add r3, r3, #1 <== NOT EXECUTED
8a70: e5843018 str r3, [r4, #24] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
8a74: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
8a78: ebfff20d bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_READWAIT(pipe))
8a7c: e1a01007 mov r1, r7 <== NOT EXECUTED
8a80: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED
8a84: eb000784 bl a89c <rtems_barrier_wait> <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
8a88: e1a01007 mov r1, r7 <== NOT EXECUTED
8a8c: 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))
8a90: e2507000 subs r7, r0, #0 <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
8a94: 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))
8a98: 13e07003 mvnne r7, #3 <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
8a9c: ebfff1be bl 519c <rtems_semaphore_obtain> <== NOT EXECUTED
8aa0: e3500000 cmp r0, #0 <== NOT EXECUTED
8aa4: 13e07003 mvnne r7, #3 <== NOT EXECUTED
8aa8: 1a000031 bne 8b74 <pipe_read+0x160> <== NOT EXECUTED
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
8aac: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED
if (ret != 0)
8ab0: e3570000 cmp r7, #0 <== NOT EXECUTED
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
8ab4: e2433001 sub r3, r3, #1 <== NOT EXECUTED
8ab8: e5843018 str r3, [r4, #24] <== NOT EXECUTED
if (ret != 0)
8abc: 1a00002a bne 8b6c <pipe_read+0x158> <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
8ac0: e594200c ldr r2, [r4, #12] <== NOT EXECUTED
8ac4: e3520000 cmp r2, #0 <== NOT EXECUTED
8ac8: 0affffdf beq 8a4c <pipe_read+0x38> <== NOT EXECUTED
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
8acc: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
8ad0: e5948004 ldr r8, [r4, #4] <== NOT EXECUTED
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
8ad4: e0667005 rsb r7, r6, r5 <== NOT EXECUTED
8ad8: e1520007 cmp r2, r7 <== NOT EXECUTED
8adc: 31a07002 movcc r7, r2 <== NOT EXECUTED
chunk1 = pipe->Size - pipe->Start;
8ae0: e0638008 rsb r8, r3, r8 <== NOT EXECUTED
8ae4: e5941000 ldr r1, [r4] <== NOT EXECUTED
if (chunk > chunk1) {
8ae8: e1570008 cmp r7, r8 <== NOT EXECUTED
8aec: e0890006 add r0, r9, r6 <== 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);
8af0: d0811003 addle r1, r1, r3 <== NOT EXECUTED
8af4: d1a02007 movle r2, r7 <== NOT EXECUTED
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
8af8: da000006 ble 8b18 <pipe_read+0x104> <== NOT EXECUTED
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
8afc: e0811003 add r1, r1, r3 <== NOT EXECUTED
8b00: e1a02008 mov r2, r8 <== NOT EXECUTED
8b04: eb00143c bl dbfc <memcpy> <== NOT EXECUTED
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
8b08: e0860008 add r0, r6, r8 <== NOT EXECUTED
8b0c: e5941000 ldr r1, [r4] <== NOT EXECUTED
8b10: e0890000 add r0, r9, r0 <== NOT EXECUTED
8b14: e0682007 rsb r2, r8, r7 <== NOT EXECUTED
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
8b18: eb001437 bl dbfc <memcpy> <== NOT EXECUTED
pipe->Start += chunk;
8b1c: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
8b20: e0870000 add r0, r7, r0 <== NOT EXECUTED
8b24: e5840008 str r0, [r4, #8] <== NOT EXECUTED
pipe->Start %= pipe->Size;
8b28: e5941004 ldr r1, [r4, #4] <== NOT EXECUTED
8b2c: eb003842 bl 16c3c <__umodsi3> <== NOT EXECUTED
pipe->Length -= chunk;
8b30: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
8b34: e0673003 rsb r3, r7, r3 <== NOT EXECUTED
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
8b38: e3530000 cmp r3, #0 <== NOT EXECUTED
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
8b3c: e5840008 str r0, [r4, #8] <== NOT EXECUTED
pipe->Length -= chunk;
8b40: e584300c str r3, [r4, #12] <== NOT EXECUTED
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
8b44: 05843008 streq r3, [r4, #8] <== NOT EXECUTED
if (pipe->waitingWriters > 0)
8b48: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
8b4c: e3530000 cmp r3, #0 <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
8b50: 15940030 ldrne r0, [r4, #48] ; 0x30 <== NOT EXECUTED
8b54: 11a0100d movne r1, sp <== NOT EXECUTED
8b58: 1b000739 blne a844 <rtems_barrier_release> <== NOT EXECUTED
read += chunk;
8b5c: e0866007 add r6, r6, r7 <== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
8b60: e1560005 cmp r6, r5 <== NOT EXECUTED
8b64: 3affffd5 bcc 8ac0 <pipe_read+0xac> <== NOT EXECUTED
8b68: e3a07000 mov r7, #0 <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
8b6c: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
8b70: ebfff1cf bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
out_nolock:
if (read > 0)
8b74: e3560000 cmp r6, #0 <== NOT EXECUTED
8b78: d1a06007 movle r6, r7 <== NOT EXECUTED
return read;
return ret;
}
8b7c: e1a00006 mov r0, r6 <== NOT EXECUTED
8b80: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00008bb8 <pipe_release>:
*/
int pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
8bb8: e92d40f1 push {r0, r4, r5, r6, r7, lr} <== NOT EXECUTED
pipe_control_t *pipe = *pipep;
8bbc: e5904000 ldr r4, [r0] <== NOT EXECUTED
*/
int pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
8bc0: e1a05001 mov r5, r1 <== NOT EXECUTED
pipe_control_t *pipe = *pipep;
uint32_t mode;
rtems_status_code sc;
sc = rtems_semaphore_obtain(pipe->Semaphore,
8bc4: e3a01000 mov r1, #0 <== NOT EXECUTED
*/
int pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
8bc8: e1a06000 mov r6, r0 <== NOT EXECUTED
pipe_control_t *pipe = *pipep;
uint32_t mode;
rtems_status_code sc;
sc = rtems_semaphore_obtain(pipe->Semaphore,
8bcc: e1a02001 mov r2, r1 <== NOT EXECUTED
8bd0: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
8bd4: ebfff170 bl 519c <rtems_semaphore_obtain> <== NOT EXECUTED
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
/* WARN pipe not released! */
if(sc != RTEMS_SUCCESSFUL)
8bd8: e3500000 cmp r0, #0 <== NOT EXECUTED
8bdc: 1a000010 bne 8c24 <pipe_release+0x6c> <== NOT EXECUTED
rtems_fatal_error_occurred(sc);
mode = LIBIO_ACCMODE(iop);
8be0: e5955014 ldr r5, [r5, #20] <== NOT EXECUTED
if (mode & LIBIO_FLAGS_READ)
8be4: e3150002 tst r5, #2 <== NOT EXECUTED
pipe->Readers --;
8be8: 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);
8bec: e2055006 and r5, r5, #6 <== NOT EXECUTED
if (mode & LIBIO_FLAGS_READ)
pipe->Readers --;
8bf0: 12433001 subne r3, r3, #1 <== NOT EXECUTED
8bf4: 15843010 strne r3, [r4, #16] <== NOT EXECUTED
if (mode & LIBIO_FLAGS_WRITE)
8bf8: e3150004 tst r5, #4 <== NOT EXECUTED
pipe->Writers --;
8bfc: 15943014 ldrne r3, [r4, #20] <== NOT EXECUTED
8c00: 12433001 subne r3, r3, #1 <== NOT EXECUTED
8c04: 15843014 strne r3, [r4, #20] <== NOT EXECUTED
sc = rtems_semaphore_obtain(rtems_pipe_semaphore,
8c08: e59f30a0 ldr r3, [pc, #160] ; 8cb0 <pipe_release+0xf8> <== NOT EXECUTED
8c0c: e3a01000 mov r1, #0 <== NOT EXECUTED
8c10: e5930000 ldr r0, [r3] <== NOT EXECUTED
8c14: e1a02001 mov r2, r1 <== NOT EXECUTED
8c18: ebfff15f bl 519c <rtems_semaphore_obtain> <== NOT EXECUTED
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
/* WARN pipe not freed and pipep not set to NULL! */
if(sc != RTEMS_SUCCESSFUL)
8c1c: e3500000 cmp r0, #0 <== NOT EXECUTED
8c20: 0a000000 beq 8c28 <pipe_release+0x70> <== NOT EXECUTED
rtems_fatal_error_occurred(sc);
8c24: ebfff2df bl 57a8 <rtems_fatal_error_occurred> <== NOT EXECUTED
PIPE_UNLOCK(pipe);
8c28: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
8c2c: ebfff1a0 bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
if (pipe->Readers == 0 && pipe->Writers == 0) {
8c30: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
8c34: e3530000 cmp r3, #0 <== NOT EXECUTED
8c38: 1a000006 bne 8c58 <pipe_release+0xa0> <== NOT EXECUTED
8c3c: e5947014 ldr r7, [r4, #20] <== NOT EXECUTED
8c40: e3570000 cmp r7, #0 <== NOT EXECUTED
8c44: 1a000003 bne 8c58 <pipe_release+0xa0> <== NOT EXECUTED
#if 0
/* To delete an anonymous pipe file when all users closed it */
if (pipe->Anonymous)
delfile = TRUE;
#endif
pipe_free(pipe);
8c48: e1a00004 mov r0, r4 <== NOT EXECUTED
8c4c: ebffffcc bl 8b84 <pipe_free> <== NOT EXECUTED
*pipep = NULL;
8c50: e5867000 str r7, [r6] <== NOT EXECUTED
if(sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred(sc);
PIPE_UNLOCK(pipe);
if (pipe->Readers == 0 && pipe->Writers == 0) {
8c54: ea000010 b 8c9c <pipe_release+0xe4> <== NOT EXECUTED
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
8c58: e2552004 subs r2, r5, #4 <== NOT EXECUTED
8c5c: 13a02001 movne r2, #1 <== NOT EXECUTED
8c60: e3530000 cmp r3, #0 <== NOT EXECUTED
8c64: 13a02000 movne r2, #0 <== NOT EXECUTED
8c68: e3520000 cmp r2, #0 <== NOT EXECUTED
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
8c6c: 15940030 ldrne r0, [r4, #48] ; 0x30 <== NOT EXECUTED
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
8c70: 1a000007 bne 8c94 <pipe_release+0xdc> <== NOT EXECUTED
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
8c74: e5942014 ldr r2, [r4, #20] <== NOT EXECUTED
8c78: e2553002 subs r3, r5, #2 <== NOT EXECUTED
8c7c: 13a03001 movne r3, #1 <== NOT EXECUTED
8c80: e3520000 cmp r2, #0 <== NOT EXECUTED
8c84: 13a03000 movne r3, #0 <== NOT EXECUTED
8c88: e3530000 cmp r3, #0 <== NOT EXECUTED
8c8c: 0a000002 beq 8c9c <pipe_release+0xe4> <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
8c90: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED
8c94: e1a0100d mov r1, sp <== NOT EXECUTED
8c98: eb0006e9 bl a844 <rtems_barrier_release> <== NOT EXECUTED
rtems_semaphore_release(rtems_pipe_semaphore);
8c9c: e59f300c ldr r3, [pc, #12] ; 8cb0 <pipe_release+0xf8> <== NOT EXECUTED
8ca0: e5930000 ldr r0, [r3] <== NOT EXECUTED
8ca4: ebfff182 bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return -errno;
#endif
return 0;
}
8ca8: e3a00000 mov r0, #0 <== NOT EXECUTED
8cac: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
00008884 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
8884: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
8888: e2525000 subs r5, r2, #0 <== NOT EXECUTED
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
888c: e1a04000 mov r4, r0 <== NOT EXECUTED
8890: e1a0b001 mov fp, r1 <== NOT EXECUTED
8894: e1a08003 mov r8, r3 <== NOT EXECUTED
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
8898: 01a06005 moveq r6, r5 <== NOT EXECUTED
889c: 0a00005a beq 8a0c <pipe_write+0x188> <== NOT EXECUTED
return 0;
if (! PIPE_LOCK(pipe))
88a0: e3a01000 mov r1, #0 <== NOT EXECUTED
88a4: e5900028 ldr r0, [r0, #40] ; 0x28 <== NOT EXECUTED
88a8: e1a02001 mov r2, r1 <== NOT EXECUTED
88ac: ebfff23a bl 519c <rtems_semaphore_obtain> <== NOT EXECUTED
88b0: e3500000 cmp r0, #0 <== NOT EXECUTED
88b4: 13e06003 mvnne r6, #3 <== NOT EXECUTED
88b8: 1a000053 bne 8a0c <pipe_write+0x188> <== NOT EXECUTED
return -EINTR;
if (pipe->Readers == 0) {
88bc: e5946010 ldr r6, [r4, #16] <== NOT EXECUTED
88c0: e3560000 cmp r6, #0 <== NOT EXECUTED
88c4: 0a000022 beq 8954 <pipe_write+0xd0> <== NOT EXECUTED
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
88c8: e5949004 ldr r9, [r4, #4] <== NOT EXECUTED
88cc: e1550009 cmp r5, r9 <== NOT EXECUTED
88d0: 91a09005 movls r9, r5 <== NOT EXECUTED
88d4: 83a09001 movhi r9, #1 <== NOT EXECUTED
88d8: e1a06000 mov r6, r0 <== NOT EXECUTED
88dc: ea000043 b 89f0 <pipe_write+0x16c> <== NOT EXECUTED
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
88e0: e5987014 ldr r7, [r8, #20] <== NOT EXECUTED
88e4: e2177001 ands r7, r7, #1 <== NOT EXECUTED
88e8: 13e0700a mvnne r7, #10 <== NOT EXECUTED
88ec: 1a000042 bne 89fc <pipe_write+0x178> <== NOT EXECUTED
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
88f0: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
88f4: e2833001 add r3, r3, #1 <== NOT EXECUTED
88f8: e584301c str r3, [r4, #28] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
88fc: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
8900: ebfff26b bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_WRITEWAIT(pipe))
8904: e1a01007 mov r1, r7 <== NOT EXECUTED
8908: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED
890c: eb0007e2 bl a89c <rtems_barrier_wait> <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
8910: e1a01007 mov r1, r7 <== NOT EXECUTED
8914: 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))
8918: e2507000 subs r7, r0, #0 <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
891c: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
8920: 13e07003 mvnne r7, #3 <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
8924: ebfff21c bl 519c <rtems_semaphore_obtain> <== NOT EXECUTED
8928: e3500000 cmp r0, #0 <== NOT EXECUTED
892c: 13e07003 mvnne r7, #3 <== NOT EXECUTED
8930: 1a000033 bne 8a04 <pipe_write+0x180> <== NOT EXECUTED
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
8934: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
if (ret != 0)
8938: e3570000 cmp r7, #0 <== NOT EXECUTED
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
893c: e2433001 sub r3, r3, #1 <== NOT EXECUTED
8940: e584301c str r3, [r4, #28] <== NOT EXECUTED
if (ret != 0)
8944: 1a00002c bne 89fc <pipe_write+0x178> <== NOT EXECUTED
goto out_locked;
if (pipe->Readers == 0) {
8948: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
894c: e3530000 cmp r3, #0 <== NOT EXECUTED
8950: 1a000001 bne 895c <pipe_write+0xd8> <== NOT EXECUTED
8954: e3e0701f mvn r7, #31 <== NOT EXECUTED
8958: ea000027 b 89fc <pipe_write+0x178> <== 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) {
895c: e594a004 ldr sl, [r4, #4] <== NOT EXECUTED
8960: e594200c ldr r2, [r4, #12] <== NOT EXECUTED
8964: e062300a rsb r3, r2, sl <== NOT EXECUTED
8968: e1530009 cmp r3, r9 <== NOT EXECUTED
896c: 3affffdb bcc 88e0 <pipe_write+0x5c> <== NOT EXECUTED
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
8970: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
8974: e1a0100a mov r1, sl <== NOT EXECUTED
8978: e0820000 add r0, r2, r0 <== NOT EXECUTED
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
897c: e0667005 rsb r7, r6, r5 <== NOT EXECUTED
8980: e1530007 cmp r3, r7 <== NOT EXECUTED
8984: 31a07003 movcc r7, r3 <== NOT EXECUTED
chunk1 = pipe->Size - PIPE_WSTART(pipe);
8988: eb0038ab bl 16c3c <__umodsi3> <== NOT EXECUTED
898c: e5943000 ldr r3, [r4] <== NOT EXECUTED
8990: e060a00a rsb sl, r0, sl <== NOT EXECUTED
if (chunk > chunk1) {
8994: e157000a cmp r7, sl <== NOT EXECUTED
8998: e08b1006 add r1, fp, r6 <== NOT EXECUTED
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);
899c: d0830000 addle r0, r3, r0 <== NOT EXECUTED
89a0: d1a02007 movle r2, r7 <== NOT EXECUTED
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
if (chunk > chunk1) {
89a4: da000006 ble 89c4 <pipe_write+0x140> <== NOT EXECUTED
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
89a8: e1a0200a mov r2, sl <== NOT EXECUTED
89ac: e0830000 add r0, r3, r0 <== NOT EXECUTED
89b0: eb001491 bl dbfc <memcpy> <== NOT EXECUTED
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
89b4: e08a1006 add r1, sl, r6 <== NOT EXECUTED
89b8: e5940000 ldr r0, [r4] <== NOT EXECUTED
89bc: e08b1001 add r1, fp, r1 <== NOT EXECUTED
89c0: e06a2007 rsb r2, sl, r7 <== NOT EXECUTED
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
89c4: eb00148c bl dbfc <memcpy> <== NOT EXECUTED
pipe->Length += chunk;
89c8: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
if (pipe->waitingReaders > 0)
89cc: e5942018 ldr r2, [r4, #24] <== NOT EXECUTED
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
89d0: e0833007 add r3, r3, r7 <== NOT EXECUTED
if (pipe->waitingReaders > 0)
89d4: e3520000 cmp r2, #0 <== NOT EXECUTED
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
89d8: e584300c str r3, [r4, #12] <== NOT EXECUTED
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
89dc: 1594002c ldrne r0, [r4, #44] ; 0x2c <== NOT EXECUTED
89e0: 11a0100d movne r1, sp <== NOT EXECUTED
89e4: 1b000796 blne a844 <rtems_barrier_release> <== NOT EXECUTED
written += chunk;
89e8: e0866007 add r6, r6, r7 <== NOT EXECUTED
89ec: e3a09001 mov r9, #1 <== NOT EXECUTED
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
89f0: e1560005 cmp r6, r5 <== NOT EXECUTED
89f4: 3affffd8 bcc 895c <pipe_write+0xd8> <== NOT EXECUTED
89f8: e3a07000 mov r7, #0 <== NOT EXECUTED
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
89fc: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
8a00: ebfff22b bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
8a04: e3560000 cmp r6, #0 <== NOT EXECUTED
8a08: d1a06007 movle r6, r7 <== NOT EXECUTED
return written;
return ret;
}
8a0c: e1a00006 mov r0, r6 <== NOT EXECUTED
8a10: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00009aec <ramdisk_allocate>:
void *area_begin,
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
9aec: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
9af0: e1a04000 mov r4, r0
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
9af4: e3a00010 mov r0, #16
void *area_begin,
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
9af8: e1a05001 mov r5, r1
9afc: e1a08002 mov r8, r2
9b00: e203a0ff and sl, r3, #255 ; 0xff
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
9b04: ebffe578 bl 30ec <malloc>
if (rd == NULL) {
9b08: e3500000 cmp r0, #0
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
9b0c: e1a07000 mov r7, r0
9b10: e1a06000 mov r6, r0
if (rd == NULL) {
9b14: 0a000012 beq 9b64 <ramdisk_allocate+0x78>
return NULL;
}
if (area_begin == NULL) {
9b18: e3540000 cmp r4, #0
return NULL;
}
rd->malloced = true;
} else {
rd->malloced = false;
9b1c: 13a03000 movne r3, #0
if (rd == NULL) {
return NULL;
}
if (area_begin == NULL) {
9b20: 1a000009 bne 9b4c <ramdisk_allocate+0x60>
area_begin = calloc(block_count, block_size);
9b24: e1a00008 mov r0, r8
9b28: e1a01005 mov r1, r5
9b2c: ebffe41a bl 2b9c <calloc>
if (area_begin == NULL) {
9b30: e2504000 subs r4, r0, #0
free(rd);
return NULL;
}
rd->malloced = true;
9b34: 13a03001 movne r3, #1
return NULL;
}
if (area_begin == NULL) {
area_begin = calloc(block_count, block_size);
if (area_begin == NULL) {
9b38: 1a000003 bne 9b4c <ramdisk_allocate+0x60>
free(rd);
9b3c: e1a00007 mov r0, r7 <== NOT EXECUTED
9b40: ebffe49d bl 2dbc <free> <== NOT EXECUTED
9b44: e1a07004 mov r7, r4 <== NOT EXECUTED
return NULL;
9b48: ea000005 b 9b64 <ramdisk_allocate+0x78> <== NOT EXECUTED
}
rd->malloced = true;
} else {
rd->malloced = false;
9b4c: e5c6300d strb r3, [r6, #13]
}
rd->block_size = block_size;
rd->block_num = block_count;
rd->area = area_begin;
rd->trace = trace;
rd->initialized = true;
9b50: e3a03001 mov r3, #1
9b54: e5c6300c strb r3, [r6, #12]
}
rd->malloced = true;
} else {
rd->malloced = false;
}
rd->block_size = block_size;
9b58: e8860120 stm r6, {r5, r8}
rd->block_num = block_count;
rd->area = area_begin;
9b5c: e5864008 str r4, [r6, #8]
rd->trace = trace;
9b60: e5c6a00e strb sl, [r6, #14]
rd->initialized = true;
return rd;
}
9b64: e1a00007 mov r0, r7
9b68: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
0001debc <ramdisk_initialize>:
rtems_device_driver
ramdisk_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *arg __attribute__((unused)))
{
1debc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
1dec0: e24dd02c sub sp, sp, #44 ; 0x2c <== NOT EXECUTED
1dec4: e58d0014 str r0, [sp, #20] <== 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();
1dec8: ebffa07c bl 60c0 <rtems_disk_io_initialize> <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
1decc: e2507000 subs r7, r0, #0 <== NOT EXECUTED
1ded0: 1a00003d bne 1dfcc <ramdisk_initialize+0x110> <== 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));
1ded4: e59fa0fc ldr sl, [pc, #252] ; 1dfd8 <ramdisk_initialize+0x11c><== NOT EXECUTED
1ded8: e3a01010 mov r1, #16 <== NOT EXECUTED
1dedc: e59a0000 ldr r0, [sl] <== NOT EXECUTED
1dee0: ebffa483 bl 70f4 <calloc> <== NOT EXECUTED
r->trace = false;
1dee4: e59f50f0 ldr r5, [pc, #240] ; 1dfdc <ramdisk_initialize+0x120><== 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));
1dee8: e1a04000 mov r4, r0 <== NOT EXECUTED
r->trace = false;
1deec: e5c0700e strb r7, [r0, #14] <== NOT EXECUTED
1def0: e1a06007 mov r6, r7 <== 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";
1def4: e28d9018 add r9, sp, #24 <== NOT EXECUTED
}
}
else
{
r->malloced = false;
r->initialized = true;
1def8: e3a08001 mov r8, #1 <== 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++)
1defc: ea00002f b 1dfc0 <ramdisk_initialize+0x104> <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
1df00: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED
temp.__overlay.minor = _minor;
1df04: e58d6028 str r6, [sp, #40] ; 0x28 <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
1df08: e58d3024 str r3, [sp, #36] ; 0x24 <== NOT EXECUTED
temp.__overlay.minor = _minor;
return temp.device;
1df0c: e28dc024 add ip, sp, #36 ; 0x24 <== NOT EXECUTED
1df10: e89c1800 ldm ip, {fp, ip} <== NOT EXECUTED
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
1df14: e59f10c4 ldr r1, [pc, #196] ; 1dfe0 <ramdisk_initialize+0x124><== NOT EXECUTED
1df18: e3a02009 mov r2, #9 <== NOT EXECUTED
1df1c: e1a00009 mov r0, r9 <== NOT EXECUTED
1df20: e58db00c str fp, [sp, #12] <== NOT EXECUTED
1df24: e58dc010 str ip, [sp, #16] <== NOT EXECUTED
1df28: eb0088a4 bl 401c0 <memcpy> <== 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)
1df2c: e5953000 ldr r3, [r5] <== 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;
1df30: e5dd1020 ldrb r1, [sp, #32] <== NOT EXECUTED
r->block_size = c->block_size;
r->block_num = c->block_num;
if (c->location == NULL)
1df34: e3530000 cmp r3, #0 <== 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;
1df38: e9150005 ldmdb r5, {r0, r2} <== 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;
1df3c: e0861001 add r1, r6, r1 <== NOT EXECUTED
r->initialized = true;
}
}
else
{
r->malloced = false;
1df40: 13a0c000 movne ip, #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;
1df44: e5cd1020 strb r1, [sp, #32] <== NOT EXECUTED
r->block_size = c->block_size;
1df48: e8840005 stm r4, {r0, r2} <== NOT EXECUTED
}
else
{
r->malloced = false;
r->initialized = true;
r->area = c->location;
1df4c: 15843008 strne r3, [r4, #8] <== NOT EXECUTED
r->initialized = true;
}
}
else
{
r->malloced = false;
1df50: 15c4c00d strbne ip, [r4, #13] <== NOT EXECUTED
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;
r->block_num = c->block_num;
if (c->location == NULL)
1df54: 1a000006 bne 1df74 <ramdisk_initialize+0xb8> <== NOT EXECUTED
{
r->malloced = true;
r->area = malloc(r->block_size * r->block_num);
1df58: e0000092 mul r0, r2, r0 <== 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;
1df5c: e5c4800d strb r8, [r4, #13] <== NOT EXECUTED
r->area = malloc(r->block_size * r->block_num);
1df60: ebffa77a bl 7d50 <malloc> <== NOT EXECUTED
if (r->area == NULL) /* No enough memory for this disk */
1df64: 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);
1df68: e5840008 str r0, [r4, #8] <== NOT EXECUTED
if (r->area == NULL) /* No enough memory for this disk */
{
r->initialized = false;
1df6c: 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 */
1df70: 0a00000f beq 1dfb4 <ramdisk_initialize+0xf8> <== NOT EXECUTED
{
r->malloced = false;
r->initialized = true;
r->area = c->location;
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
1df74: e59fb068 ldr fp, [pc, #104] ; 1dfe4 <ramdisk_initialize+0x128><== NOT EXECUTED
1df78: e28d100c add r1, sp, #12 <== NOT EXECUTED
1df7c: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
1df80: e915000c ldmdb r5, {r2, r3} <== NOT EXECUTED
}
}
else
{
r->malloced = false;
r->initialized = true;
1df84: e5c4800c strb r8, [r4, #12] <== NOT EXECUTED
r->area = c->location;
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
1df88: e58db000 str fp, [sp] <== NOT EXECUTED
1df8c: e98d0210 stmib sp, {r4, r9} <== NOT EXECUTED
1df90: ebffa1f7 bl 6774 <rtems_disk_create_phys> <== NOT EXECUTED
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
1df94: e3500000 cmp r0, #0 <== NOT EXECUTED
1df98: 0a000005 beq 1dfb4 <ramdisk_initialize+0xf8> <== NOT EXECUTED
{
if (r->malloced)
1df9c: e5d4300d ldrb r3, [r4, #13] <== NOT EXECUTED
1dfa0: e3530000 cmp r3, #0 <== NOT EXECUTED
{
free(r->area);
1dfa4: 15940008 ldrne r0, [r4, #8] <== NOT EXECUTED
1dfa8: 1bffa5c1 blne 76b4 <free> <== NOT EXECUTED
}
r->initialized = false;
1dfac: e3a0c000 mov ip, #0 <== NOT EXECUTED
1dfb0: e5c4c00c strb ip, [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++)
1dfb4: e2866001 add r6, r6, #1 <== NOT EXECUTED
1dfb8: e2844010 add r4, r4, #16 <== NOT EXECUTED
1dfbc: e285500c add r5, r5, #12 <== NOT EXECUTED
1dfc0: e59a3000 ldr r3, [sl] <== NOT EXECUTED
1dfc4: e1560003 cmp r6, r3 <== NOT EXECUTED
1dfc8: 3affffcc bcc 1df00 <ramdisk_initialize+0x44> <== NOT EXECUTED
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
}
1dfcc: e1a00007 mov r0, r7 <== NOT EXECUTED
1dfd0: e28dd02c add sp, sp, #44 ; 0x2c <== NOT EXECUTED
1dfd4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
000099dc <ramdisk_ioctl>:
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
switch (req)
99dc: e59f30dc ldr r3, [pc, #220] ; 9ac0 <ramdisk_ioctl+0xe4>
99e0: e1510003 cmp r1, r3
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
99e4: e92d41f0 push {r4, r5, r6, r7, r8, lr}
99e8: e1a04002 mov r4, r2
switch (req)
99ec: 1a00002f bne 9ab0 <ramdisk_ioctl+0xd4>
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (r->req)
99f0: e5927000 ldr r7, [r2]
switch (req)
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
99f4: e590602c ldr r6, [r0, #44] ; 0x2c
switch (r->req)
99f8: e3570000 cmp r7, #0
#endif
static int
ramdisk_read(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *from = rd->area;
99fc: 05968008 ldreq r8, [r6, #8]
9a00: 02825018 addeq r5, r2, #24
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (r->req)
9a04: 0a000009 beq 9a30 <ramdisk_ioctl+0x54>
9a08: e3570001 cmp r7, #1
9a0c: 1a000022 bne 9a9c <ramdisk_ioctl+0xc0>
9a10: ea00000b b 9a44 <ramdisk_ioctl+0x68>
#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);
9a14: e5963000 ldr r3, [r6] <== NOT EXECUTED
9a18: e5151010 ldr r1, [r5, #-16] <== NOT EXECUTED
9a1c: e5150008 ldr r0, [r5, #-8] <== NOT EXECUTED
9a20: e0218193 mla r1, r3, r1, r8 <== NOT EXECUTED
9a24: e515200c ldr r2, [r5, #-12] <== NOT EXECUTED
9a28: eb001f56 bl 11788 <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++)
9a2c: e2877001 add r7, r7, #1 <== NOT EXECUTED
9a30: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
9a34: e1570003 cmp r7, r3 <== NOT EXECUTED
9a38: e2855010 add r5, r5, #16 <== NOT EXECUTED
9a3c: 3afffff4 bcc 9a14 <ramdisk_ioctl+0x38> <== NOT EXECUTED
9a40: ea00000e b 9a80 <ramdisk_ioctl+0xa4> <== NOT EXECUTED
}
static int
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *to = rd->area;
9a44: e5968008 ldr r8, [r6, #8]
9a48: e2825018 add r5, r2, #24
9a4c: e3a07000 mov r7, #0
9a50: ea000006 b 9a70 <ramdisk_ioctl+0x94>
#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);
9a54: e5963000 ldr r3, [r6]
9a58: e5150010 ldr r0, [r5, #-16]
9a5c: e5151008 ldr r1, [r5, #-8]
9a60: e0208093 mla r0, r3, r0, r8
9a64: e515200c ldr r2, [r5, #-12]
9a68: eb001f46 bl 11788 <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++)
9a6c: e2877001 add r7, r7, #1
9a70: e5943010 ldr r3, [r4, #16]
9a74: e1570003 cmp r7, r3
9a78: e2855010 add r5, r5, #16
9a7c: 3afffff4 bcc 9a54 <ramdisk_ioctl+0x78>
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;
9a80: e3a05000 mov r5, #0
9a84: e584500c str r5, [r4, #12]
req->req_done(req->done_arg, RTEMS_SUCCESSFUL);
9a88: e5940008 ldr r0, [r4, #8]
9a8c: e1a01005 mov r1, r5
9a90: e1a0e00f mov lr, pc
9a94: e594f004 ldr pc, [r4, #4]
{
case RTEMS_BLKDEV_REQ_READ:
return ramdisk_read(rd, r);
case RTEMS_BLKDEV_REQ_WRITE:
return ramdisk_write(rd, r);
9a98: ea000006 b 9ab8 <ramdisk_ioctl+0xdc>
default:
errno = EINVAL;
9a9c: eb001d2b bl 10f50 <__errno> <== NOT EXECUTED
9aa0: e3a03016 mov r3, #22 <== NOT EXECUTED
9aa4: e5803000 str r3, [r0] <== NOT EXECUTED
9aa8: e3e05000 mvn r5, #0 <== NOT EXECUTED
return -1;
9aac: ea000001 b 9ab8 <ramdisk_ioctl+0xdc> <== NOT EXECUTED
break;
}
errno = EINVAL;
return -1;
}
9ab0: e8bd41f0 pop {r4, r5, r6, r7, r8, lr}
}
break;
}
default:
return rtems_blkdev_ioctl (dd, req, argp);
9ab4: ea000931 b bf80 <rtems_blkdev_ioctl>
break;
}
errno = EINVAL;
return -1;
}
9ab8: e1a00005 mov r0, r5
9abc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
00009b6c <ramdisk_register>:
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
9b6c: e92d47ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
9b70: e3a0e000 mov lr, #0
9b74: e28dc010 add ip, sp, #16
9b78: e52ce004 str lr, [ip, #-4]!
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
9b7c: e1a04002 mov r4, r2
9b80: e1a07000 mov r7, r0
9b84: e1a06001 mov r6, 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);
9b88: e1a0000e mov r0, lr
9b8c: e1a0200c mov r2, ip
9b90: e59f1084 ldr r1, [pc, #132] ; 9c1c <ramdisk_register+0xb0>
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
9b94: e1a0a003 mov sl, r3
9b98: 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);
9b9c: ebfff39d bl 6a18 <rtems_io_register_driver>
if (sc != RTEMS_SUCCESSFUL) {
9ba0: e2508000 subs r8, r0, #0
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
9ba4: e20440ff and r4, r4, #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) {
9ba8: 1a000007 bne 9bcc <ramdisk_register+0x60>
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, block_size, block_count, trace);
9bac: e1a03004 mov r3, r4
9bb0: e1a01007 mov r1, r7
9bb4: e1a02006 mov r2, r6
9bb8: ebffffcb bl 9aec <ramdisk_allocate>
if (rd == NULL) {
9bbc: e2505000 subs r5, r0, #0
9bc0: 1a000003 bne 9bd4 <ramdisk_register+0x68>
rtems_io_unregister_driver(major);
9bc4: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED
9bc8: ebfff3ef bl 6b8c <rtems_io_unregister_driver> <== NOT EXECUTED
9bcc: e3a0000d mov r0, #13 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
9bd0: ea00000f b 9c14 <ramdisk_register+0xa8> <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
9bd4: e59d400c ldr r4, [sp, #12]
}
dev = rtems_filesystem_make_dev_t(major, 0);
sc = rtems_disk_create_phys(
9bd8: e59fc040 ldr ip, [pc, #64] ; 9c20 <ramdisk_register+0xb4>
9bdc: e1a01008 mov r1, r8
9be0: e1a02007 mov r2, r7
9be4: e1a03006 mov r3, r6
9be8: e1a00004 mov r0, r4
9bec: e58dc000 str ip, [sp]
9bf0: e98d0420 stmib sp, {r5, sl}
9bf4: ebffe1da bl 2364 <rtems_disk_create_phys>
block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
9bf8: e3500000 cmp r0, #0
rtems_io_unregister_driver(major);
return RTEMS_UNSATISFIED;
}
*dev_ptr = dev;
9bfc: 05894000 streq r4, [r9]
9c00: 05890004 streq r0, [r9, #4]
block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
9c04: 0a000002 beq 9c14 <ramdisk_register+0xa8>
ramdisk_free(rd);
9c08: e1a00005 mov r0, r5 <== NOT EXECUTED
9c0c: ebffffac bl 9ac4 <ramdisk_free> <== NOT EXECUTED
9c10: eaffffeb b 9bc4 <ramdisk_register+0x58> <== NOT EXECUTED
}
*dev_ptr = dev;
return RTEMS_SUCCESSFUL;
}
9c14: e28dd010 add sp, sp, #16
9c18: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
00018f38 <read>:
)
{
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
18f38: e59f30b0 ldr r3, [pc, #176] ; 18ff0 <read+0xb8>
18f3c: e5933000 ldr r3, [r3]
18f40: e1500003 cmp r0, r3
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
18f44: e92d4070 push {r4, r5, r6, lr}
18f48: e1a05001 mov r5, r1
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
18f4c: 2a00000f bcs 18f90 <read+0x58>
iop = rtems_libio_iop( fd );
18f50: e59f309c ldr r3, [pc, #156] ; 18ff4 <read+0xbc>
18f54: e5934000 ldr r4, [r3]
18f58: e0844300 add r4, r4, r0, lsl #6
rtems_libio_check_is_open( iop );
18f5c: e5943014 ldr r3, [r4, #20]
18f60: e3130c01 tst r3, #256 ; 0x100
18f64: 0a000009 beq 18f90 <read+0x58>
rtems_libio_check_buffer( buffer );
18f68: e3510000 cmp r1, #0
18f6c: 1a000002 bne 18f7c <read+0x44>
18f70: ebffd113 bl d3c4 <__errno> <== NOT EXECUTED
18f74: e3a03016 mov r3, #22 <== NOT EXECUTED
18f78: ea00000d b 18fb4 <read+0x7c> <== NOT EXECUTED
rtems_libio_check_count( count );
18f7c: e3520000 cmp r2, #0
18f80: 01a00002 moveq r0, r2
18f84: 08bd8070 popeq {r4, r5, r6, pc}
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
18f88: e3130002 tst r3, #2
18f8c: 1a000002 bne 18f9c <read+0x64>
18f90: ebffd10b bl d3c4 <__errno>
18f94: e3a03009 mov r3, #9
18f98: ea000005 b 18fb4 <read+0x7c>
/*
* Now process the read().
*/
if ( !iop->handlers->read_h )
18f9c: e594303c ldr r3, [r4, #60] ; 0x3c
18fa0: e5933008 ldr r3, [r3, #8]
18fa4: e3530000 cmp r3, #0
18fa8: 1a000004 bne 18fc0 <read+0x88>
rtems_set_errno_and_return_minus_one( ENOTSUP );
18fac: ebffd104 bl d3c4 <__errno> <== NOT EXECUTED
18fb0: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
18fb4: e5803000 str r3, [r0]
18fb8: e3e00000 mvn r0, #0
18fbc: e8bd8070 pop {r4, r5, r6, pc}
rc = (*iop->handlers->read_h)( iop, buffer, count );
18fc0: e1a00004 mov r0, r4
18fc4: e1a0e00f mov lr, pc
18fc8: e12fff13 bx r3
if ( rc > 0 )
18fcc: e3500000 cmp r0, #0
18fd0: d8bd8070 pople {r4, r5, r6, pc}
iop->offset += rc;
18fd4: e284600c add r6, r4, #12
18fd8: e8960060 ldm r6, {r5, r6}
18fdc: e0952000 adds r2, r5, r0
18fe0: e0a63fc0 adc r3, r6, r0, asr #31
18fe4: e584200c str r2, [r4, #12]
18fe8: e5843010 str r3, [r4, #16]
return rc;
}
18fec: e8bd8070 pop {r4, r5, r6, pc}
0002670c <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
2670c: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
26710: e2516000 subs r6, r1, #0
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
26714: e24dd018 sub sp, sp, #24
26718: e1a05002 mov r5, r2
2671c: e1a07000 mov r7, r0
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
26720: 1a000002 bne 26730 <readlink+0x24>
rtems_set_errno_and_return_minus_one( EFAULT );
26724: eb0059f5 bl 3cf00 <__errno> <== NOT EXECUTED
26728: e3a0300e mov r3, #14 <== NOT EXECUTED
2672c: ea000028 b 267d4 <readlink+0xc8> <== NOT EXECUTED
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
26730: eb0074ef bl 43af4 <strlen>
26734: e28d4004 add r4, sp, #4
26738: e3a0c000 mov ip, #0
2673c: e1a01000 mov r1, r0
26740: e1a0200c mov r2, ip
26744: e1a00007 mov r0, r7
26748: e1a03004 mov r3, r4
2674c: e58dc000 str ip, [sp]
26750: ebff83b9 bl 763c <rtems_filesystem_evaluate_path>
0, &loc, false );
if ( result != 0 )
26754: e3500000 cmp r0, #0
26758: 1a00001e bne 267d8 <readlink+0xcc>
return -1;
if ( !loc.ops->node_type_h ){
2675c: e59d2010 ldr r2, [sp, #16]
26760: e5923010 ldr r3, [r2, #16]
26764: e3530000 cmp r3, #0
26768: 0a000012 beq 267b8 <readlink+0xac>
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
2676c: e1a00004 mov r0, r4
26770: e1a0e00f mov lr, pc
26774: e12fff13 bx r3
26778: e3500004 cmp r0, #4
2677c: e59d2010 ldr r2, [sp, #16]
26780: 0a000009 beq 267ac <readlink+0xa0>
rtems_filesystem_freenode( &loc );
26784: e3520000 cmp r2, #0
26788: 0a000004 beq 267a0 <readlink+0x94>
2678c: e592301c ldr r3, [r2, #28]
26790: e3530000 cmp r3, #0
26794: 11a00004 movne r0, r4
26798: 11a0e00f movne lr, pc
2679c: 112fff13 bxne r3
rtems_set_errno_and_return_minus_one( EINVAL );
267a0: eb0059d6 bl 3cf00 <__errno>
267a4: e3a03016 mov r3, #22
267a8: ea000009 b 267d4 <readlink+0xc8>
}
if ( !loc.ops->readlink_h ){
267ac: e592303c ldr r3, [r2, #60] ; 0x3c
267b0: e3530000 cmp r3, #0
267b4: 1a000009 bne 267e0 <readlink+0xd4>
rtems_filesystem_freenode( &loc );
267b8: e592301c ldr r3, [r2, #28] <== NOT EXECUTED
267bc: e3530000 cmp r3, #0 <== NOT EXECUTED
267c0: 11a00004 movne r0, r4 <== NOT EXECUTED
267c4: 11a0e00f movne lr, pc <== NOT EXECUTED
267c8: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
267cc: eb0059cb bl 3cf00 <__errno> <== NOT EXECUTED
267d0: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
267d4: e5803000 str r3, [r0]
267d8: e3e05000 mvn r5, #0
267dc: ea00000d b 26818 <readlink+0x10c>
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
267e0: e1a02005 mov r2, r5
267e4: e1a01006 mov r1, r6
267e8: e1a00004 mov r0, r4
267ec: e1a0e00f mov lr, pc
267f0: e12fff13 bx r3
rtems_filesystem_freenode( &loc );
267f4: e59d3010 ldr r3, [sp, #16]
267f8: 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 );
267fc: e1a05000 mov r5, r0
rtems_filesystem_freenode( &loc );
26800: 0a000004 beq 26818 <readlink+0x10c>
26804: e593301c ldr r3, [r3, #28]
26808: e3530000 cmp r3, #0
2680c: 11a00004 movne r0, r4
26810: 11a0e00f movne lr, pc
26814: 112fff13 bxne r3
return result;
}
26818: e1a00005 mov r0, r5
2681c: e28dd018 add sp, sp, #24
26820: e8bd80f0 pop {r4, r5, r6, r7, pc}
000039dc <readv>:
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
39dc: e59f3144 ldr r3, [pc, #324] ; 3b28 <readv+0x14c>
39e0: e5933000 ldr r3, [r3]
39e4: e1500003 cmp r0, r3
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
39e8: e92d49f0 push {r4, r5, r6, r7, r8, fp, lr}
39ec: e1a08002 mov r8, r2
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
39f0: 2a000007 bcs 3a14 <readv+0x38>
iop = rtems_libio_iop( fd );
39f4: e59f3130 ldr r3, [pc, #304] ; 3b2c <readv+0x150>
39f8: e5936000 ldr r6, [r3]
39fc: e0866300 add r6, r6, r0, lsl #6
rtems_libio_check_is_open( iop );
3a00: e5963014 ldr r3, [r6, #20]
3a04: e3130c01 tst r3, #256 ; 0x100
3a08: 0a000001 beq 3a14 <readv+0x38>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
3a0c: e3130002 tst r3, #2
3a10: 1a000002 bne 3a20 <readv+0x44>
3a14: eb002a90 bl e45c <__errno> <== NOT EXECUTED
3a18: e3a03009 mov r3, #9 <== NOT EXECUTED
3a1c: ea00001b b 3a90 <readv+0xb4> <== NOT EXECUTED
/*
* Argument validation on IO vector
*/
if ( !iov )
3a20: e3510000 cmp r1, #0
3a24: 0a000017 beq 3a88 <readv+0xac>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
3a28: e3520000 cmp r2, #0
3a2c: da000015 ble 3a88 <readv+0xac>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
3a30: e3520b01 cmp r2, #1024 ; 0x400
3a34: ca000013 bgt 3a88 <readv+0xac>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !iop->handlers->read_h )
3a38: e596303c ldr r3, [r6, #60] ; 0x3c
3a3c: e5933008 ldr r3, [r3, #8]
3a40: e3530000 cmp r3, #0
3a44: 1a000002 bne 3a54 <readv+0x78>
rtems_set_errno_and_return_minus_one( ENOTSUP );
3a48: eb002a83 bl e45c <__errno> <== NOT EXECUTED
3a4c: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
3a50: ea00000e b 3a90 <readv+0xb4> <== NOT EXECUTED
3a54: e3a03000 mov r3, #0
3a58: e1a05001 mov r5, r1
3a5c: e1a02001 mov r2, r1
3a60: e3a07001 mov r7, #1
3a64: e1a01003 mov r1, r3
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
ssize_t old;
if ( !iov[v].iov_base )
3a68: e5920000 ldr r0, [r2]
3a6c: e3500000 cmp r0, #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++ ) {
3a70: e2833001 add r3, r3, #1
ssize_t old;
if ( !iov[v].iov_base )
3a74: 0a000003 beq 3a88 <readv+0xac>
if ( iov[v].iov_len < 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
3a78: e592c004 ldr ip, [r2, #4]
3a7c: e081000c add r0, r1, ip
if ( total < old )
3a80: e1500001 cmp r0, r1
3a84: aa000003 bge 3a98 <readv+0xbc>
rtems_set_errno_and_return_minus_one( EINVAL );
3a88: eb002a73 bl e45c <__errno>
3a8c: e3a03016 mov r3, #22
3a90: e5803000 str r3, [r0]
3a94: ea000011 b 3ae0 <readv+0x104>
if ( iov[v].iov_len )
3a98: e35c0000 cmp ip, #0
3a9c: 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++ ) {
3aa0: e1530008 cmp r3, r8
3aa4: e2822008 add r2, r2, #8
3aa8: b1a01000 movlt r1, r0
3aac: baffffed blt 3a68 <readv+0x8c>
/*
* 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 ) {
3ab0: e3570000 cmp r7, #0
3ab4: 13a04000 movne r4, #0
3ab8: 1a000018 bne 3b20 <readv+0x144>
3abc: e1a04007 mov r4, r7
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->handlers->read_h)( iop, iov[v].iov_base, iov[v].iov_len );
3ac0: e8950006 ldm r5, {r1, r2}
3ac4: e596303c ldr r3, [r6, #60] ; 0x3c
3ac8: e1a00006 mov r0, r6
3acc: e1a0e00f mov lr, pc
3ad0: e593f008 ldr pc, [r3, #8]
if ( bytes < 0 )
3ad4: e3500000 cmp r0, #0
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
3ad8: e2877001 add r7, r7, #1
bytes = (*iop->handlers->read_h)( iop, iov[v].iov_base, iov[v].iov_len );
if ( bytes < 0 )
3adc: aa000001 bge 3ae8 <readv+0x10c>
3ae0: e3e04000 mvn r4, #0
3ae4: ea00000d b 3b20 <readv+0x144>
return -1;
if ( bytes > 0 ) {
3ae8: 0a000006 beq 3b08 <readv+0x12c>
iop->offset += bytes;
3aec: e286c00c add ip, r6, #12
3af0: e89c1800 ldm ip, {fp, ip}
3af4: e09b2000 adds r2, fp, r0
3af8: e0ac3fc0 adc r3, ip, r0, asr #31
3afc: e586200c str r2, [r6, #12]
3b00: e5863010 str r3, [r6, #16]
total += bytes;
3b04: e0844000 add r4, r4, r0
}
if (bytes != iov[ v ].iov_len)
3b08: e5953004 ldr r3, [r5, #4]
3b0c: e1500003 cmp r0, r3
3b10: 1a000002 bne 3b20 <readv+0x144>
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
3b14: e1570008 cmp r7, r8
3b18: e2855008 add r5, r5, #8
3b1c: baffffe7 blt 3ac0 <readv+0xe4>
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
3b20: e1a00004 mov r0, r4
3b24: e8bd89f0 pop {r4, r5, r6, r7, r8, fp, pc}
00019050 <realloc>:
{
uintptr_t old_size;
char *new_area;
uintptr_t resize;
MSBUMP(realloc_calls, 1);
19050: e59f310c ldr r3, [pc, #268] ; 19164 <realloc+0x114>
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
19054: e59f210c ldr r2, [pc, #268] ; 19168 <realloc+0x118>
19058: e592c000 ldr ip, [r2]
{
uintptr_t old_size;
char *new_area;
uintptr_t resize;
MSBUMP(realloc_calls, 1);
1905c: e5932010 ldr r2, [r3, #16]
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
19060: e35c0003 cmp ip, #3
{
uintptr_t old_size;
char *new_area;
uintptr_t resize;
MSBUMP(realloc_calls, 1);
19064: e2822001 add r2, r2, #1
19068: e92d40f1 push {r0, r4, r5, r6, r7, lr}
1906c: e5832010 str r2, [r3, #16]
19070: e1a04000 mov r4, r0
19074: e1a05001 mov r5, r1
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
19078: 1a000007 bne 1909c <realloc+0x4c>
if (_Thread_Dispatch_disable_level > 0)
1907c: e59f30e8 ldr r3, [pc, #232] ; 1916c <realloc+0x11c>
19080: e5933000 ldr r3, [r3]
19084: e3530000 cmp r3, #0
19088: 1a000032 bne 19158 <realloc+0x108>
return (void *) 0;
if (_ISR_Nest_level > 0)
1908c: e59f30dc ldr r3, [pc, #220] ; 19170 <realloc+0x120>
19090: e5933000 ldr r3, [r3]
19094: e3530000 cmp r3, #0
19098: 1a00002e bne 19158 <realloc+0x108>
}
/*
* Continue with realloc().
*/
if ( !ptr )
1909c: e3540000 cmp r4, #0
190a0: 1a000003 bne 190b4 <realloc+0x64>
return malloc( size );
190a4: e1a00005 mov r0, r5
190a8: ebffa454 bl 2200 <malloc>
190ac: e1a04000 mov r4, r0
190b0: ea000029 b 1915c <realloc+0x10c>
if ( !size ) {
190b4: e3550000 cmp r5, #0
190b8: 1a000003 bne 190cc <realloc+0x7c>
free( ptr );
190bc: e1a00004 mov r0, r4 <== NOT EXECUTED
190c0: ebffa382 bl 1ed0 <free> <== NOT EXECUTED
190c4: e1a04005 mov r4, r5 <== NOT EXECUTED
return (void *) 0;
190c8: ea000023 b 1915c <realloc+0x10c> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
190cc: e59f60a0 ldr r6, [pc, #160] ; 19174 <realloc+0x124>
190d0: e1a01004 mov r1, r4
190d4: e5960000 ldr r0, [r6]
190d8: e1a0200d mov r2, sp
190dc: eb000055 bl 19238 <_Protected_heap_Get_block_size>
190e0: e2507000 subs r7, r0, #0
190e4: 1a000004 bne 190fc <realloc+0xac>
errno = EINVAL;
190e8: ebffd0b5 bl d3c4 <__errno>
190ec: e3a03016 mov r3, #22
190f0: e5803000 str r3, [r0]
190f4: e1a04007 mov r4, r7
return (void *) 0;
190f8: ea000017 b 1915c <realloc+0x10c>
#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 ) ) {
190fc: e5960000 ldr r0, [r6]
19100: e1a01004 mov r1, r4
19104: e1a02005 mov r2, r5
19108: eb00005b bl 1927c <_Protected_heap_Resize_block>
1910c: e3500000 cmp r0, #0
19110: 1a000011 bne 1915c <realloc+0x10c>
* 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 );
19114: e1a00005 mov r0, r5
19118: ebffa438 bl 2200 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
1911c: e59f3040 ldr r3, [pc, #64] ; 19164 <realloc+0x114>
19120: e5932004 ldr r2, [r3, #4]
if ( !new_area ) {
19124: e2506000 subs r6, r0, #0
* and the C Standard.
*/
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
19128: e2422001 sub r2, r2, #1
1912c: e5832004 str r2, [r3, #4]
if ( !new_area ) {
19130: 0a000008 beq 19158 <realloc+0x108>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
19134: e59d2000 ldr r2, [sp]
19138: e1a01004 mov r1, r4
1913c: e1550002 cmp r5, r2
19140: 31a02005 movcc r2, r5
19144: ebffd2ac bl dbfc <memcpy>
free( ptr );
19148: e1a00004 mov r0, r4
1914c: ebffa35f bl 1ed0 <free>
19150: e1a04006 mov r4, r6
return new_area;
19154: ea000000 b 1915c <realloc+0x10c>
19158: e3a04000 mov r4, #0
}
1915c: e1a00004 mov r0, r4
19160: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
00026824 <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
26824: e92d4070 push {r4, r5, r6, lr}
26828: e24dd030 sub sp, sp, #48 ; 0x30
2682c: e1a06000 mov r6, r0
/*
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
26830: ebff833a bl 7520 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
26834: e2504000 subs r4, r0, #0
26838: e28d3018 add r3, sp, #24
2683c: 1a000005 bne 26858 <rmdir+0x34>
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
26840: e1a02003 mov r2, r3
26844: e1a00006 mov r0, r6
26848: e28d102c add r1, sp, #44 ; 0x2c
2684c: ebff89b3 bl 8f20 <rtems_filesystem_get_start_loc>
26850: e1a05004 mov r5, r4
26854: ea000008 b 2687c <rmdir+0x58>
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
26858: e3a0c000 mov ip, #0
2685c: e1a00006 mov r0, r6
26860: e1a01004 mov r1, r4
26864: e3a02002 mov r2, #2
26868: e58dc000 str ip, [sp]
2686c: ebff8372 bl 763c <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
26870: e3500000 cmp r0, #0
26874: 1a000077 bne 26a58 <rmdir+0x234>
26878: e3a05001 mov r5, #1
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
2687c: e28de018 add lr, sp, #24
26880: e8be000f ldm lr!, {r0, r1, r2, r3}
26884: e28dc004 add ip, sp, #4
26888: e8ac000f stmia ip!, {r0, r1, r2, r3}
2688c: e59e3000 ldr r3, [lr]
name = pathname + parentpathlen;
26890: e0864004 add r4, r6, r4
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
26894: e58c3000 str r3, [ip]
name = pathname + parentpathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
26898: e1a00004 mov r0, r4
2689c: eb007494 bl 43af4 <strlen>
268a0: e1a01000 mov r1, r0
268a4: e1a00004 mov r0, r4
268a8: ebff830c bl 74e0 <rtems_filesystem_prefix_separators>
268ac: e0846000 add r6, r4, r0
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
268b0: e1a00006 mov r0, r6
268b4: eb00748e bl 43af4 <strlen>
268b8: e28d4004 add r4, sp, #4
268bc: e3a0c000 mov ip, #0
268c0: e1a01000 mov r1, r0
268c4: e1a0200c mov r2, ip
268c8: e1a00006 mov r0, r6
268cc: e1a03004 mov r3, r4
268d0: e58dc000 str ip, [sp]
268d4: ebff8320 bl 755c <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
268d8: e3500000 cmp r0, #0
268dc: 0a00000b beq 26910 <rmdir+0xec>
if ( free_parentloc )
268e0: e3550000 cmp r5, #0
268e4: 0a00005b beq 26a58 <rmdir+0x234>
rtems_filesystem_freenode( &parentloc );
268e8: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
268ec: e3530000 cmp r3, #0 <== NOT EXECUTED
268f0: 0a000058 beq 26a58 <rmdir+0x234> <== NOT EXECUTED
268f4: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
268f8: e3530000 cmp r3, #0 <== NOT EXECUTED
268fc: 0a000055 beq 26a58 <rmdir+0x234> <== NOT EXECUTED
26900: e28d0018 add r0, sp, #24 <== NOT EXECUTED
26904: e1a0e00f mov lr, pc <== NOT EXECUTED
26908: e12fff13 bx r3 <== NOT EXECUTED
2690c: ea000051 b 26a58 <rmdir+0x234> <== NOT EXECUTED
/*
* Verify you can remove this node as a directory.
*/
if ( !loc.ops->node_type_h ){
26910: e59d2010 ldr r2, [sp, #16]
26914: e5923010 ldr r3, [r2, #16]
26918: e3530000 cmp r3, #0
rtems_filesystem_freenode( &loc );
2691c: 0592301c ldreq r3, [r2, #28]
/*
* Verify you can remove this node as a directory.
*/
if ( !loc.ops->node_type_h ){
26920: 0a000021 beq 269ac <rmdir+0x188>
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 ){
26924: e1a00004 mov r0, r4
26928: e1a0e00f mov lr, pc
2692c: e12fff13 bx r3
26930: e3500001 cmp r0, #1
26934: 0a000014 beq 2698c <rmdir+0x168>
rtems_filesystem_freenode( &loc );
26938: e59d3010 ldr r3, [sp, #16]
2693c: e3530000 cmp r3, #0
26940: 0a000004 beq 26958 <rmdir+0x134>
26944: e593301c ldr r3, [r3, #28]
26948: e3530000 cmp r3, #0
2694c: 11a00004 movne r0, r4
26950: 11a0e00f movne lr, pc
26954: 112fff13 bxne r3
if ( free_parentloc )
26958: e3550000 cmp r5, #0
2695c: 0a000007 beq 26980 <rmdir+0x15c>
rtems_filesystem_freenode( &parentloc );
26960: e59d3024 ldr r3, [sp, #36] ; 0x24
26964: e3530000 cmp r3, #0
26968: 0a000004 beq 26980 <rmdir+0x15c>
2696c: e593301c ldr r3, [r3, #28]
26970: e3530000 cmp r3, #0
26974: 128d0018 addne r0, sp, #24
26978: 11a0e00f movne lr, pc
2697c: 112fff13 bxne r3
rtems_set_errno_and_return_minus_one( ENOTDIR );
26980: eb00595e bl 3cf00 <__errno>
26984: e3a03014 mov r3, #20
26988: ea000017 b 269ec <rmdir+0x1c8>
/*
* Use the filesystems rmnod to remove the node.
*/
if ( !loc.handlers->rmnod_h ){
2698c: e59d300c ldr r3, [sp, #12]
26990: e5933034 ldr r3, [r3, #52] ; 0x34
26994: e3530000 cmp r3, #0
26998: 1a000015 bne 269f4 <rmdir+0x1d0>
rtems_filesystem_freenode( &loc );
2699c: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
269a0: e3530000 cmp r3, #0 <== NOT EXECUTED
269a4: 0a000004 beq 269bc <rmdir+0x198> <== NOT EXECUTED
269a8: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
269ac: e3530000 cmp r3, #0 <== NOT EXECUTED
269b0: 11a00004 movne r0, r4 <== NOT EXECUTED
269b4: 11a0e00f movne lr, pc <== NOT EXECUTED
269b8: 112fff13 bxne r3 <== NOT EXECUTED
if ( free_parentloc )
269bc: e3550000 cmp r5, #0 <== NOT EXECUTED
269c0: 0a000007 beq 269e4 <rmdir+0x1c0> <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
269c4: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
269c8: e3530000 cmp r3, #0 <== NOT EXECUTED
269cc: 0a000004 beq 269e4 <rmdir+0x1c0> <== NOT EXECUTED
269d0: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
269d4: e3530000 cmp r3, #0 <== NOT EXECUTED
269d8: 128d0018 addne r0, sp, #24 <== NOT EXECUTED
269dc: 11a0e00f movne lr, pc <== NOT EXECUTED
269e0: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
269e4: eb005945 bl 3cf00 <__errno> <== NOT EXECUTED
269e8: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
269ec: e5803000 str r3, [r0]
269f0: ea000018 b 26a58 <rmdir+0x234>
}
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
269f4: e28d0018 add r0, sp, #24
269f8: e1a01004 mov r1, r4
269fc: e1a0e00f mov lr, pc
26a00: e12fff13 bx r3
rtems_filesystem_freenode( &loc );
26a04: e59d3010 ldr r3, [sp, #16]
26a08: 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 );
26a0c: e1a06000 mov r6, r0
rtems_filesystem_freenode( &loc );
26a10: 0a000004 beq 26a28 <rmdir+0x204>
26a14: e593301c ldr r3, [r3, #28]
26a18: e3530000 cmp r3, #0
26a1c: 11a00004 movne r0, r4
26a20: 11a0e00f movne lr, pc
26a24: 112fff13 bxne r3
if ( free_parentloc )
26a28: e3550000 cmp r5, #0
26a2c: 0a00000a beq 26a5c <rmdir+0x238>
rtems_filesystem_freenode( &parentloc );
26a30: e59d3024 ldr r3, [sp, #36] ; 0x24
26a34: e3530000 cmp r3, #0
26a38: 0a000007 beq 26a5c <rmdir+0x238>
26a3c: e593301c ldr r3, [r3, #28]
26a40: e3530000 cmp r3, #0
26a44: 0a000004 beq 26a5c <rmdir+0x238>
26a48: e28d0018 add r0, sp, #24
26a4c: e1a0e00f mov lr, pc
26a50: e12fff13 bx r3
26a54: ea000000 b 26a5c <rmdir+0x238>
26a58: e3e06000 mvn r6, #0
return result;
}
26a5c: e1a00006 mov r0, r6
26a60: e28dd030 add sp, sp, #48 ; 0x30
26a64: e8bd8070 pop {r4, r5, r6, pc}
00012124 <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;
}
12124: e59f0000 ldr r0, [pc, #0] ; 1212c <rtems_assoc_name_bad+0x8><== NOT EXECUTED
12128: e12fff1e bx lr <== NOT EXECUTED
0000f2dc <rtems_assoc_name_by_local>:
const char *rtems_assoc_name_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
f2dc: e92d4010 push {r4, lr}
f2e0: e1a04001 mov r4, r1
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
f2e4: eb000006 bl f304 <rtems_assoc_ptr_by_local>
if (nap)
f2e8: e3500000 cmp r0, #0
f2ec: 0a000001 beq f2f8 <rtems_assoc_name_by_local+0x1c>
return nap->name;
return rtems_assoc_name_bad(local_value);
}
f2f0: e5900000 ldr r0, [r0]
f2f4: 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);
f2f8: e1a00004 mov r0, r4 <== NOT EXECUTED
}
f2fc: 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);
f300: ea000b87 b 12124 <rtems_assoc_name_bad> <== NOT EXECUTED
0000d33c <rtems_assoc_remote_by_local>:
uint32_t rtems_assoc_remote_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
d33c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
d340: eb000002 bl d350 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if (nap)
d344: e3500000 cmp r0, #0 <== NOT EXECUTED
return nap->remote_value;
d348: 15900008 ldrne r0, [r0, #8] <== NOT EXECUTED
return 0;
}
d34c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00009fec <rtems_bdbuf_add_to_modified_list_after_access>:
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
9fec: e92d4030 push {r4, r5, lr}
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)
9ff0: e59f50ac ldr r5, [pc, #172] ; a0a4 <rtems_bdbuf_add_to_modified_list_after_access+0xb8>
9ff4: e5d53030 ldrb r3, [r5, #48] ; 0x30
9ff8: e3530000 cmp r3, #0
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
9ffc: e1a04000 mov r4, r0
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)
a000: 0a00000d beq a03c <rtems_bdbuf_add_to_modified_list_after_access+0x50>
a004: e2853038 add r3, r5, #56 ; 0x38 <== NOT EXECUTED
a008: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
a00c: e5901014 ldr r1, [r0, #20] <== NOT EXECUTED
a010: e1510002 cmp r1, r2 <== NOT EXECUTED
a014: 1a000008 bne a03c <rtems_bdbuf_add_to_modified_list_after_access+0x50><== NOT EXECUTED
a018: e5901018 ldr r1, [r0, #24] <== NOT EXECUTED
a01c: e1510003 cmp r1, r3 <== NOT EXECUTED
a020: 1a000005 bne a03c <rtems_bdbuf_add_to_modified_list_after_access+0x50><== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
a024: ebffff8d bl 9e60 <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);
a028: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED
a02c: e59f1074 ldr r1, [pc, #116] ; a0a8 <rtems_bdbuf_add_to_modified_list_after_access+0xbc><== NOT EXECUTED
a030: ebffff08 bl 9c58 <rtems_bdbuf_lock> <== NOT EXECUTED
/*
* Wait for the sync lock.
*/
rtems_bdbuf_lock_sync ();
rtems_bdbuf_unlock_sync ();
a034: ebffff93 bl 9e88 <rtems_bdbuf_unlock_sync> <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
a038: ebffff0f bl 9c7c <rtems_bdbuf_lock_cache> <== 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)
a03c: 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
a040: e3530003 cmp r3, #3
a044: 0a000002 beq a054 <rtems_bdbuf_add_to_modified_list_after_access+0x68>
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
a048: 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
a04c: e3530005 cmp r3, #5
a050: 1a000002 bne a060 <rtems_bdbuf_add_to_modified_list_after_access+0x74>
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
bd->hold_timer = bdbuf_config.swap_block_hold;
a054: e59f3050 ldr r3, [pc, #80] ; a0ac <rtems_bdbuf_add_to_modified_list_after_access+0xc0>
a058: e5933010 ldr r3, [r3, #16]
a05c: e5843030 str r3, [r4, #48] ; 0x30
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
a060: e59f503c ldr r5, [pc, #60] ; a0a4 <rtems_bdbuf_add_to_modified_list_after_access+0xb8>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
a064: e3a03007 mov r3, #7
a068: e5843024 str r3, [r4, #36] ; 0x24
a06c: e2850050 add r0, r5, #80 ; 0x50
a070: e1a01004 mov r1, r4
a074: ebfff351 bl 6dc0 <_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)
a078: e5943028 ldr r3, [r4, #40] ; 0x28
a07c: e3530000 cmp r3, #0
a080: 0a000002 beq a090 <rtems_bdbuf_add_to_modified_list_after_access+0xa4>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
a084: e2850068 add r0, r5, #104 ; 0x68
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
}
a088: 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);
a08c: eaffff00 b 9c94 <rtems_bdbuf_wake>
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
a090: 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 ())
a094: e3530000 cmp r3, #0
a098: 08bd8030 popeq {r4, r5, pc}
rtems_bdbuf_wake_swapper ();
}
a09c: 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 ();
a0a0: eaffffc6 b 9fc0 <rtems_bdbuf_wake_swapper>
0000a1f4 <rtems_bdbuf_anonymous_wait>:
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
a1f4: e5903000 ldr r3, [r0]
a1f8: 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)
{
a1fc: e92d4030 push {r4, r5, lr}
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
a200: 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)
{
a204: 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 ();
a208: ebffffdf bl a18c <rtems_bdbuf_disable_preemption>
a20c: e1a05000 mov r5, r0
/*
* Unlock the cache, wait, and lock the cache when we return.
*/
rtems_bdbuf_unlock_cache ();
a210: ebffff12 bl 9e60 <rtems_bdbuf_unlock_cache>
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
a214: e3a01000 mov r1, #0
a218: e5940004 ldr r0, [r4, #4]
a21c: e1a02001 mov r2, r1
a220: ebfff057 bl 6384 <rtems_semaphore_obtain>
if (sc == RTEMS_TIMEOUT)
a224: e3500006 cmp r0, #6
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_TO);
a228: 059f002c ldreq r0, [pc, #44] ; a25c <rtems_bdbuf_anonymous_wait+0x68>
*/
rtems_bdbuf_unlock_cache ();
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
if (sc == RTEMS_TIMEOUT)
a22c: 0a000002 beq a23c <rtems_bdbuf_anonymous_wait+0x48>
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_TO);
if (sc != RTEMS_UNSATISFIED)
a230: e350000d cmp r0, #13
a234: 0a000001 beq a240 <rtems_bdbuf_anonymous_wait+0x4c>
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_2);
a238: e59f0020 ldr r0, [pc, #32] ; a260 <rtems_bdbuf_anonymous_wait+0x6c><== NOT EXECUTED
a23c: ebfff1be bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
a240: ebfffe8d bl 9c7c <rtems_bdbuf_lock_cache>
rtems_bdbuf_restore_preemption (prev_mode);
a244: e1a00005 mov r0, r5
a248: ebffffdd bl a1c4 <rtems_bdbuf_restore_preemption>
--waiters->count;
a24c: e5943000 ldr r3, [r4]
a250: e2433001 sub r3, r3, #1
a254: e5843000 str r3, [r4]
}
a258: e8bd8030 pop {r4, r5, pc}
0000bbc0 <rtems_bdbuf_get>:
rtems_status_code
rtems_bdbuf_get (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
bbc0: e92d40f0 push {r4, r5, r6, r7, lr}
bbc4: 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);
bbc8: 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;
bbcc: 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);
bbd0: e58de000 str lr, [sp]
rtems_status_code
rtems_bdbuf_get (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
bbd4: e1a05003 mov r5, 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);
bbd8: e28de008 add lr, sp, #8
bbdc: 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;
bbe0: e58dc008 str ip, [sp, #8]
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
bbe4: 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;
bbe8: e58dc010 str ip, [sp, #16]
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
bbec: e58dc00c str ip, [sp, #12]
rtems_status_code
rtems_bdbuf_get (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
bbf0: e1a06000 mov r6, r0
bbf4: e1a07001 mov r7, 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);
bbf8: ebfff8ac bl 9eb0 <rtems_bdbuf_obtain_disk>
if (sc != RTEMS_SUCCESSFUL)
bbfc: e2504000 subs r4, r0, #0
bc00: 1a00001e bne bc80 <rtems_bdbuf_get+0xc0>
return sc;
rtems_bdbuf_lock_cache ();
bc04: ebfff81c bl 9c7c <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);
bc08: e1a00006 mov r0, r6
bc0c: e59d3008 ldr r3, [sp, #8]
bc10: e1a01007 mov r1, r7
bc14: e59d200c ldr r2, [sp, #12]
bc18: ebffff56 bl b978 <rtems_bdbuf_get_buffer_for_access>
switch (bd->state)
bc1c: e5903024 ldr r3, [r0, #36] ; 0x24
bc20: 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);
bc24: e1a06000 mov r6, r0
switch (bd->state)
bc28: 0a000004 beq bc40 <rtems_bdbuf_get+0x80>
bc2c: e3530007 cmp r3, #7
bc30: 0a000006 beq bc50 <rtems_bdbuf_get+0x90>
bc34: e3530001 cmp r3, #1
bc38: 1a00000b bne bc6c <rtems_bdbuf_get+0xac>
bc3c: ea000001 b bc48 <rtems_bdbuf_get+0x88>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
bc40: e3a03003 mov r3, #3
bc44: ea000002 b bc54 <rtems_bdbuf_get+0x94>
bc48: e3a03005 mov r3, #5
bc4c: ea000000 b bc54 <rtems_bdbuf_get+0x94>
bc50: e3a03004 mov r3, #4
bc54: e5863024 str r3, [r6, #36] ; 0x24
{
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
rtems_bdbuf_unlock_cache ();
bc58: ebfff880 bl 9e60 <rtems_bdbuf_unlock_cache>
rtems_bdbuf_release_disk (dd);
bc5c: e59d0010 ldr r0, [sp, #16]
bc60: ebfff8cf bl 9fa4 <rtems_bdbuf_release_disk>
*bd_ptr = bd;
bc64: e5856000 str r6, [r5]
return RTEMS_SUCCESSFUL;
bc68: ea000004 b bc80 <rtems_bdbuf_get+0xc0>
* 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);
bc6c: 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);
bc70: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
bc74: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
bc78: e380001e orr r0, r0, #30 <== NOT EXECUTED
bc7c: ebffeb2e bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_bdbuf_release_disk (dd);
*bd_ptr = bd;
return RTEMS_SUCCESSFUL;
}
bc80: e1a00004 mov r0, r4
bc84: e28dd014 add sp, sp, #20
bc88: e8bd80f0 pop {r4, r5, r6, r7, pc}
0000b978 <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)
{
b978: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
static rtems_bdbuf_buffer *
rtems_bdbuf_avl_search (rtems_bdbuf_buffer** root,
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
b97c: e59f4224 ldr r4, [pc, #548] ; bba8 <rtems_bdbuf_get_buffer_for_access+0x230>
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
b980: e1a06000 mov r6, r0
b984: e1a05001 mov r5, r1
b988: e1a07002 mov r7, r2
b98c: e1a08003 mov r8, r3
b990: e284a054 add sl, r4, #84 ; 0x54
static rtems_bdbuf_buffer *
rtems_bdbuf_avl_search (rtems_bdbuf_buffer** root,
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
b994: e5949040 ldr r9, [r4, #64] ; 0x40
b998: ea000009 b b9c4 <rtems_bdbuf_get_buffer_for_access+0x4c>
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
{
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
b99c: e1550003 cmp r5, r3
b9a0: 8a000004 bhi b9b8 <rtems_bdbuf_get_buffer_for_access+0x40>
b9a4: 1a000005 bne b9c0 <rtems_bdbuf_get_buffer_for_access+0x48>
b9a8: e1560002 cmp r6, r2
b9ac: 8a000001 bhi b9b8 <rtems_bdbuf_get_buffer_for_access+0x40>
b9b0: ea000002 b b9c0 <rtems_bdbuf_get_buffer_for_access+0x48>
b9b4: 2a000001 bcs b9c0 <rtems_bdbuf_get_buffer_for_access+0x48>
{
p = p->avl.right;
b9b8: e599900c ldr r9, [r9, #12]
b9bc: ea000000 b b9c4 <rtems_bdbuf_get_buffer_for_access+0x4c>
}
else
{
p = p->avl.left;
b9c0: e5999008 ldr r9, [r9, #8]
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
b9c4: e3590000 cmp r9, #0
b9c8: 0a000009 beq b9f4 <rtems_bdbuf_get_buffer_for_access+0x7c>
b9cc: e5992014 ldr r2, [r9, #20]
b9d0: e1520006 cmp r2, r6
b9d4: e5993018 ldr r3, [r9, #24]
b9d8: 1affffef bne b99c <rtems_bdbuf_get_buffer_for_access+0x24>
b9dc: e1530005 cmp r3, r5
b9e0: 1affffed bne b99c <rtems_bdbuf_get_buffer_for_access+0x24>
b9e4: e599301c ldr r3, [r9, #28]
b9e8: e1530007 cmp r3, r7
b9ec: 1afffff0 bne b9b4 <rtems_bdbuf_get_buffer_for_access+0x3c>
b9f0: ea000067 b bb94 <rtems_bdbuf_get_buffer_for_access+0x21c>
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
b9f4: e1a00006 mov r0, r6
b9f8: e1a01005 mov r1, r5
b9fc: e1a02007 mov r2, r7
ba00: e1a03008 mov r3, r8
ba04: ebfffeef bl b5c8 <rtems_bdbuf_get_buffer_from_lru_list>
if (bd == NULL)
ba08: e2509000 subs r9, r0, #0
ba0c: 1a000038 bne baf4 <rtems_bdbuf_get_buffer_for_access+0x17c>
ba10: ea000031 b badc <rtems_bdbuf_get_buffer_for_access+0x164>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ba14: e3a0b008 mov fp, #8
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
ba18: e5993024 ldr r3, [r9, #36] ; 0x24
ba1c: e353000a cmp r3, #10
ba20: 979ff103 ldrls pc, [pc, r3, lsl #2]
ba24: ea00001d b baa0 <rtems_bdbuf_get_buffer_for_access+0x128> <== NOT EXECUTED
ba28: 0000bab4 .word 0x0000bab4 <== NOT EXECUTED
ba2c: 0000ba74 .word 0x0000ba74 <== NOT EXECUTED
ba30: 0000ba74 .word 0x0000ba74 <== NOT EXECUTED
ba34: 0000ba84 .word 0x0000ba84 <== NOT EXECUTED
ba38: 0000ba84 .word 0x0000ba84 <== NOT EXECUTED
ba3c: 0000ba84 .word 0x0000ba84 <== NOT EXECUTED
ba40: 0000ba84 .word 0x0000ba84 <== NOT EXECUTED
ba44: 0000ba54 .word 0x0000ba54 <== NOT EXECUTED
ba48: 0000ba90 .word 0x0000ba90 <== NOT EXECUTED
ba4c: 0000ba90 .word 0x0000ba90 <== NOT EXECUTED
ba50: 0000ba90 .word 0x0000ba90 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ba54: e1a00009 mov r0, r9 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ba58: e589b024 str fp, [r9, #36] ; 0x24 <== NOT EXECUTED
ba5c: ebffece2 bl 6dec <_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 );
ba60: e59f0144 ldr r0, [pc, #324] ; bbac <rtems_bdbuf_get_buffer_for_access+0x234><== NOT EXECUTED
ba64: e1a01009 mov r1, r9 <== NOT EXECUTED
ba68: ebffecd4 bl 6dc0 <_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 ();
ba6c: ebfff953 bl 9fc0 <rtems_bdbuf_wake_swapper> <== NOT EXECUTED
ba70: eaffffe8 b ba18 <rtems_bdbuf_get_buffer_for_access+0xa0> <== NOT EXECUTED
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)
ba74: e5993028 ldr r3, [r9, #40] ; 0x28
ba78: e3530000 cmp r3, #0
ba7c: 0a00000c beq bab4 <rtems_bdbuf_get_buffer_for_access+0x13c>
ba80: ea000018 b bae8 <rtems_bdbuf_get_buffer_for_access+0x170>
}
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);
ba84: e1a00009 mov r0, r9
ba88: e59f1120 ldr r1, [pc, #288] ; bbb0 <rtems_bdbuf_get_buffer_for_access+0x238>
ba8c: ea000001 b ba98 <rtems_bdbuf_get_buffer_for_access+0x120>
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);
ba90: e59f111c ldr r1, [pc, #284] ; bbb4 <rtems_bdbuf_get_buffer_for_access+0x23c><== NOT EXECUTED
ba94: e1a00009 mov r0, r9 <== NOT EXECUTED
ba98: ebfff9f1 bl a264 <rtems_bdbuf_wait>
ba9c: eaffffdd b ba18 <rtems_bdbuf_get_buffer_for_access+0xa0>
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_8);
baa0: e5990024 ldr r0, [r9, #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);
baa4: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
baa8: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
baac: e3800006 orr r0, r0, #6 <== NOT EXECUTED
bab0: ea000030 b bb78 <rtems_bdbuf_get_buffer_for_access+0x200> <== NOT EXECUTED
{
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);
bab4: e1a00009 mov r0, r9 <== NOT EXECUTED
bab8: ebfffbe3 bl aa4c <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;
babc: e3a03000 mov r3, #0 <== NOT EXECUTED
bac0: e5893024 str r3, [r9, #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);
bac4: e1a01009 mov r1, r9 <== NOT EXECUTED
bac8: e59f00e8 ldr r0, [pc, #232] ; bbb8 <rtems_bdbuf_get_buffer_for_access+0x240><== NOT EXECUTED
bacc: eb000bd3 bl ea20 <_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);
bad0: e59f00e4 ldr r0, [pc, #228] ; bbbc <rtems_bdbuf_get_buffer_for_access+0x244><== NOT EXECUTED
bad4: ebfff86e bl 9c94 <rtems_bdbuf_wake> <== NOT EXECUTED
bad8: eaffffad b b994 <rtems_bdbuf_get_buffer_for_access+0x1c> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
badc: e5943050 ldr r3, [r4, #80] ; 0x50
bae0: e153000a cmp r3, sl
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
rtems_bdbuf_wake_swapper ();
bae4: 1bfff935 blne 9fc0 <rtems_bdbuf_wake_swapper>
rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);
bae8: e59f00cc ldr r0, [pc, #204] ; bbbc <rtems_bdbuf_get_buffer_for_access+0x244>
baec: ebfff9c0 bl a1f4 <rtems_bdbuf_anonymous_wait>
baf0: eaffffa7 b b994 <rtems_bdbuf_get_buffer_for_access+0x1c>
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
baf4: e5993024 ldr r3, [r9, #36] ; 0x24
baf8: e2433001 sub r3, r3, #1
bafc: e3530009 cmp r3, #9
bb00: 979ff103 ldrls pc, [pc, r3, lsl #2]
bb04: ea000017 b bb68 <rtems_bdbuf_get_buffer_for_access+0x1f0> <== NOT EXECUTED
bb08: 0000bb7c .word 0x0000bb7c <== NOT EXECUTED
bb0c: 0000bb40 .word 0x0000bb40 <== NOT EXECUTED
bb10: 0000bb4c .word 0x0000bb4c <== NOT EXECUTED
bb14: 0000bb4c .word 0x0000bb4c <== NOT EXECUTED
bb18: 0000bb4c .word 0x0000bb4c <== NOT EXECUTED
bb1c: 0000bb4c .word 0x0000bb4c <== NOT EXECUTED
bb20: 0000bb30 .word 0x0000bb30 <== NOT EXECUTED
bb24: 0000bb58 .word 0x0000bb58 <== NOT EXECUTED
bb28: 0000bb58 .word 0x0000bb58 <== NOT EXECUTED
bb2c: 0000bb58 .word 0x0000bb58 <== NOT EXECUTED
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
bb30: e599302c ldr r3, [r9, #44] ; 0x2c
bb34: e593200c ldr r2, [r3, #12]
bb38: e2422001 sub r2, r2, #1
bb3c: e583200c str r2, [r3, #12]
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
bb40: e1a00009 mov r0, r9
bb44: ebffeca8 bl 6dec <_Chain_Extract>
bb48: ea00000b b bb7c <rtems_bdbuf_get_buffer_for_access+0x204>
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);
bb4c: e1a00009 mov r0, r9
bb50: e59f1058 ldr r1, [pc, #88] ; bbb0 <rtems_bdbuf_get_buffer_for_access+0x238>
bb54: ea000001 b bb60 <rtems_bdbuf_get_buffer_for_access+0x1e8>
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);
bb58: e59f1054 ldr r1, [pc, #84] ; bbb4 <rtems_bdbuf_get_buffer_for_access+0x23c>
bb5c: e1a00009 mov r0, r9
bb60: ebfff9bf bl a264 <rtems_bdbuf_wait>
bb64: eaffffe2 b baf4 <rtems_bdbuf_get_buffer_for_access+0x17c>
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_7);
bb68: e5990024 ldr r0, [r9, #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);
bb6c: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
bb70: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
bb74: e3800005 orr r0, r0, #5 <== NOT EXECUTED
bb78: ebffeb6f bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
bb7c: e599302c ldr r3, [r9, #44] ; 0x2c
bb80: e593200c ldr r2, [r3, #12]
bb84: e2822001 add r2, r2, #1
bb88: e583200c str r2, [r3, #12]
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
return bd;
}
bb8c: e1a00009 mov r0, r9
bb90: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
if (bd != NULL)
{
if (bd->group->bds_per_group != bds_per_group)
bb94: e599302c ldr r3, [r9, #44] ; 0x2c
bb98: e5933008 ldr r3, [r3, #8]
bb9c: e1530008 cmp r3, r8
bba0: 0affffd3 beq baf4 <rtems_bdbuf_get_buffer_for_access+0x17c>
bba4: eaffff9a b ba14 <rtems_bdbuf_get_buffer_for_access+0x9c>
0000b5c8 <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)
{
b5c8: 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;
b5cc: e59fc390 ldr ip, [pc, #912] ; b964 <rtems_bdbuf_get_buffer_from_lru_list+0x39c>
b5d0: e24dd088 sub sp, sp, #136 ; 0x88
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
b5d4: e1a0600c mov r6, ip
b5d8: e1a04000 mov r4, r0
b5dc: e1a05001 mov r5, r1
b5e0: e58d2004 str r2, [sp, #4]
b5e4: e1a09003 mov r9, r3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return the_chain->first;
b5e8: e59c8044 ldr r8, [ip, #68] ; 0x44
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
b5ec: ea0000d4 b b944 <rtems_bdbuf_get_buffer_from_lru_list+0x37c>
bd->group->bds_per_group, bds_per_group);
/*
* If nobody waits for this BD, we may recycle it.
*/
if (bd->waiters == 0)
b5f0: e5983028 ldr r3, [r8, #40] ; 0x28
b5f4: e3530000 cmp r3, #0
b5f8: 1a0000d0 bne b940 <rtems_bdbuf_get_buffer_from_lru_list+0x378>
{
if (bd->group->bds_per_group == bds_per_group)
b5fc: e598702c ldr r7, [r8, #44] ; 0x2c
b600: e5971008 ldr r1, [r7, #8]
b604: e1510009 cmp r1, r9
b608: 1a000003 bne b61c <rtems_bdbuf_get_buffer_from_lru_list+0x54>
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
b60c: e1a00008 mov r0, r8
b610: ebfffd0d bl aa4c <rtems_bdbuf_remove_from_tree_and_lru_list>
b614: e1a00008 mov r0, r8
b618: ea000033 b b6ec <rtems_bdbuf_get_buffer_from_lru_list+0x124>
empty_bd = bd;
}
else if (bd->group->users == 0)
b61c: e597a00c ldr sl, [r7, #12]
b620: e35a0000 cmp sl, #0
b624: 1a0000c5 bne b940 <rtems_bdbuf_get_buffer_from_lru_list+0x378>
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
b628: e5960020 ldr r0, [r6, #32]
b62c: eb003b67 bl 1a3d0 <__aeabi_uidiv>
b630: e3a0303c mov r3, #60 ; 0x3c
b634: e0030390 mul r3, r0, r3
b638: e1a01005 mov r1, r5
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;
b63c: e597b010 ldr fp, [r7, #16]
b640: e1a05004 mov r5, r4
b644: e1a04003 mov r4, r3
b648: ea000005 b b664 <rtems_bdbuf_get_buffer_from_lru_list+0x9c>
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
b64c: e1a0000b mov r0, fp
b650: e58d1000 str r1, [sp]
b654: ebfffcfc bl aa4c <rtems_bdbuf_remove_from_tree_and_lru_list>
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
b658: e59d1000 ldr r1, [sp]
b65c: e28aa001 add sl, sl, #1
b660: e08bb004 add fp, fp, r4
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;
b664: e5972008 ldr r2, [r7, #8]
b668: e15a0002 cmp sl, r2
b66c: 3afffff6 bcc b64c <rtems_bdbuf_get_buffer_from_lru_list+0x84>
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;
b670: e5879008 str r9, [r7, #8]
b674: e1a04005 mov r4, r5
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
b678: e5960020 ldr r0, [r6, #32]
b67c: e1a05001 mov r5, r1
b680: e1a01009 mov r1, r9
b684: eb003b51 bl 1a3d0 <__aeabi_uidiv>
b688: e3a0303c mov r3, #60 ; 0x3c
b68c: e0030390 mul r3, r0, r3
b690: e597b010 ldr fp, [r7, #16]
b694: e1a0c008 mov ip, r8
b698: e08bb003 add fp, fp, r3
b69c: e3a0a001 mov sl, #1
b6a0: e1a08003 mov r8, r3
b6a4: ea000008 b b6cc <rtems_bdbuf_get_buffer_from_lru_list+0x104>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
b6a8: e3a01000 mov r1, #0
b6ac: e58b1024 str r1, [fp, #36] ; 0x24
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
b6b0: e59f02b0 ldr r0, [pc, #688] ; b968 <rtems_bdbuf_get_buffer_from_lru_list+0x3a0>
b6b4: e1a0100b mov r1, fp
b6b8: e58dc000 str ip, [sp]
b6bc: eb000cd7 bl ea20 <_Chain_Insert>
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;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
b6c0: e59dc000 ldr ip, [sp]
b6c4: e28aa001 add sl, sl, #1
b6c8: e08bb008 add fp, fp, r8
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;
b6cc: e5972008 ldr r2, [r7, #8]
b6d0: e15a0002 cmp sl, r2
b6d4: 3afffff3 bcc b6a8 <rtems_bdbuf_get_buffer_from_lru_list+0xe0>
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
if (b > 1)
b6d8: e35a0001 cmp sl, #1
b6dc: e1a0800c mov r8, ip
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
b6e0: 859f0284 ldrhi r0, [pc, #644] ; b96c <rtems_bdbuf_get_buffer_from_lru_list+0x3a4>
b6e4: 8bfff96a blhi 9c94 <rtems_bdbuf_wake>
return group->bdbuf;
b6e8: e5970010 ldr r0, [r7, #16]
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, bds_per_group);
}
if (empty_bd != NULL)
b6ec: e3500000 cmp r0, #0
b6f0: 0a000092 beq b940 <rtems_bdbuf_get_buffer_from_lru_list+0x378>
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
bd->block = block;
bd->avl.left = NULL;
b6f4: e3a02000 mov r2, #0
b6f8: e5802008 str r2, [r0, #8]
bd->avl.right = NULL;
b6fc: e580200c str r2, [r0, #12]
rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
b700: e59f125c ldr r1, [pc, #604] ; b964 <rtems_bdbuf_get_buffer_from_lru_list+0x39c>
b704: e5913040 ldr r3, [r1, #64] ; 0x40
{
bd->dev = dev;
bd->block = block;
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
b708: e5802028 str r2, [r0, #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)
b70c: e1530002 cmp r3, r2
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
bd->block = block;
b710: e59d2004 ldr r2, [sp, #4]
static void
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
b714: e5804014 str r4, [r0, #20]
b718: e5805018 str r5, [r0, #24]
bd->block = block;
b71c: e580201c str r2, [r0, #28]
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
b720: 128dc008 addne ip, sp, #8
break;
}
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
b724: 13e07000 mvnne r7, #0
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
{
p->avl.cache = 1;
b728: 13a06001 movne r6, #1
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
b72c: 1a000019 bne b798 <rtems_bdbuf_get_buffer_from_lru_list+0x1d0>
{
*root = node;
b730: e5810040 str r0, [r1, #64] ; 0x40
node->avl.left = NULL;
node->avl.right = NULL;
node->avl.bal = 0;
b734: e5c03011 strb r3, [r0, #17]
bool modified = false;
if (p == NULL)
{
*root = node;
node->avl.left = NULL;
b738: e5803008 str r3, [r0, #8]
node->avl.right = NULL;
b73c: e580300c str r3, [r0, #12]
b740: ea00007b b b934 <rtems_bdbuf_get_buffer_from_lru_list+0x36c>
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
b744: e1520004 cmp r2, r4
b748: 1a00000c bne b780 <rtems_bdbuf_get_buffer_from_lru_list+0x1b8>
b74c: e1510005 cmp r1, r5
b750: 1a00000a bne b780 <rtems_bdbuf_get_buffer_from_lru_list+0x1b8>
b754: e593201c ldr r2, [r3, #28]
b758: e59d1004 ldr r1, [sp, #4]
b75c: e1520001 cmp r2, r1
b760: 2a000005 bcs b77c <rtems_bdbuf_get_buffer_from_lru_list+0x1b4>
{
p->avl.cache = 1;
q = p->avl.right;
b764: e593200c ldr r2, [r3, #12]
if (q == NULL)
b768: e3520000 cmp r2, #0
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
{
p->avl.cache = 1;
b76c: e5c36010 strb r6, [r3, #16]
q = p->avl.right;
if (q == NULL)
b770: 1a000007 bne b794 <rtems_bdbuf_get_buffer_from_lru_list+0x1cc>
{
q = node;
p->avl.right = q = node;
b774: e583000c str r0, [r3, #12]
b778: ea00000f b b7bc <rtems_bdbuf_get_buffer_from_lru_list+0x1f4>
break;
}
}
else if ((p->dev != dev) || (p->block != block))
b77c: 0a000076 beq b95c <rtems_bdbuf_get_buffer_from_lru_list+0x394>
{
p->avl.cache = -1;
q = p->avl.left;
b780: e5932008 ldr r2, [r3, #8]
if (q == NULL)
b784: e3520000 cmp r2, #0
break;
}
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
b788: e5c37010 strb r7, [r3, #16]
q = p->avl.left;
if (q == NULL)
{
q = node;
p->avl.left = q;
b78c: 05830008 streq r0, [r3, #8]
b790: 0a000009 beq b7bc <rtems_bdbuf_get_buffer_from_lru_list+0x1f4>
b794: e1a03002 mov r3, r2 <== NOT EXECUTED
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
b798: e5931018 ldr r1, [r3, #24]
b79c: e1550001 cmp r5, r1
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
b7a0: e48c3004 str r3, [ip], #4
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
b7a4: e5932014 ldr r2, [r3, #20]
b7a8: 8affffed bhi b764 <rtems_bdbuf_get_buffer_from_lru_list+0x19c>
b7ac: 1affffe4 bne b744 <rtems_bdbuf_get_buffer_from_lru_list+0x17c>
b7b0: e1540002 cmp r4, r2
b7b4: 8affffea bhi b764 <rtems_bdbuf_get_buffer_from_lru_list+0x19c>
b7b8: eaffffe1 b b744 <rtems_bdbuf_get_buffer_from_lru_list+0x17c>
}
p = q;
}
q->avl.left = q->avl.right = NULL;
b7bc: e3a01000 mov r1, #0
b7c0: e580100c str r1, [r0, #12]
b7c4: e5801008 str r1, [r0, #8]
q->avl.bal = 0;
b7c8: e5c01011 strb r1, [r0, #17]
b7cc: e24c4004 sub r4, ip, #4
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;
b7d0: e3a05001 mov r5, #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;
b7d4: e3e06000 mvn r6, #0
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
b7d8: e28d7008 add r7, sp, #8
modified = true;
buf_prev--;
while (modified)
{
if (p->avl.cache == -1)
b7dc: e1d3c1d0 ldrsb ip, [r3, #16]
b7e0: e37c0001 cmn ip, #1
b7e4: e1d321d1 ldrsb r2, [r3, #17]
b7e8: 1a00001d bne b864 <rtems_bdbuf_get_buffer_from_lru_list+0x29c>
{
switch (p->avl.bal)
b7ec: e3520000 cmp r2, #0
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = -1;
b7f0: 05c3c011 strbeq ip, [r3, #17]
while (modified)
{
if (p->avl.cache == -1)
{
switch (p->avl.bal)
b7f4: 0a00003f beq b8f8 <rtems_bdbuf_get_buffer_from_lru_list+0x330>
b7f8: e3520001 cmp r2, #1 <== NOT EXECUTED
b7fc: 0a00001f beq b880 <rtems_bdbuf_get_buffer_from_lru_list+0x2b8><== NOT EXECUTED
b800: e3720001 cmn r2, #1 <== NOT EXECUTED
b804: 1a00003b bne b8f8 <rtems_bdbuf_get_buffer_from_lru_list+0x330><== NOT EXECUTED
case 0:
p->avl.bal = -1;
break;
case -1:
p1 = p->avl.left;
b808: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED
if (p1->avl.bal == -1) /* simple LL-turn */
b80c: e1d2c1d1 ldrsb ip, [r2, #17] <== NOT EXECUTED
b810: e37c0001 cmn ip, #1 <== NOT EXECUTED
b814: e592c00c ldr ip, [r2, #12] <== NOT EXECUTED
{
p->avl.left = p1->avl.right;
p1->avl.right = p;
p->avl.bal = 0;
b818: 05c31011 strbeq r1, [r3, #17] <== NOT EXECUTED
case -1:
p1 = p->avl.left;
if (p1->avl.bal == -1) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
b81c: 0583c008 streq ip, [r3, #8] <== NOT EXECUTED
p1->avl.right = p;
b820: 0582300c streq r3, [r2, #12] <== NOT EXECUTED
p->avl.bal = -1;
break;
case -1:
p1 = p->avl.left;
if (p1->avl.bal == -1) /* simple LL-turn */
b824: 0a000030 beq b8ec <rtems_bdbuf_get_buffer_from_lru_list+0x324><== NOT EXECUTED
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
b828: e59c8008 ldr r8, [ip, #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;
b82c: e1dca1d1 ldrsb sl, [ip, #17] <== NOT EXECUTED
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
b830: e582800c str r8, [r2, #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;
b834: e37a0001 cmn sl, #1 <== NOT EXECUTED
b838: 05c35011 strbeq r5, [r3, #17] <== NOT EXECUTED
b83c: 15c31011 strbne r1, [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;
b840: e59c800c ldr r8, [ip, #12] <== NOT EXECUTED
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
b844: e58c2008 str r2, [ip, #8] <== NOT EXECUTED
p->avl.left = p2->avl.right;
p2->avl.right = p;
b848: e58c300c str r3, [ip, #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;
b84c: e5838008 str r8, [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;
b850: e1dc31d1 ldrsb r3, [ip, #17] <== NOT EXECUTED
b854: e3530001 cmp r3, #1 <== NOT EXECUTED
b858: 05c26011 strbeq r6, [r2, #17] <== NOT EXECUTED
b85c: 1a000020 bne b8e4 <rtems_bdbuf_get_buffer_from_lru_list+0x31c><== NOT EXECUTED
b860: ea000020 b b8e8 <rtems_bdbuf_get_buffer_from_lru_list+0x320><== NOT EXECUTED
break;
}
}
else
{
switch (p->avl.bal)
b864: e3520000 cmp r2, #0
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
b868: 05c35011 strbeq r5, [r3, #17]
break;
}
}
else
{
switch (p->avl.bal)
b86c: 0a000021 beq b8f8 <rtems_bdbuf_get_buffer_from_lru_list+0x330>
b870: e3520001 cmp r2, #1 <== NOT EXECUTED
b874: 0a000004 beq b88c <rtems_bdbuf_get_buffer_from_lru_list+0x2c4><== NOT EXECUTED
b878: e3720001 cmn r2, #1 <== NOT EXECUTED
b87c: 1a00001d bne b8f8 <rtems_bdbuf_get_buffer_from_lru_list+0x330><== NOT EXECUTED
{
case -1:
p->avl.bal = 0;
b880: e5c31011 strb r1, [r3, #17] <== NOT EXECUTED
b884: e1a02003 mov r2, r3 <== NOT EXECUTED
b888: ea000018 b b8f0 <rtems_bdbuf_get_buffer_from_lru_list+0x328><== NOT EXECUTED
case 0:
p->avl.bal = 1;
break;
case 1:
p1 = p->avl.right;
b88c: e593200c ldr r2, [r3, #12] <== NOT EXECUTED
if (p1->avl.bal == 1) /* simple RR-turn */
b890: e1d2c1d1 ldrsb ip, [r2, #17] <== NOT EXECUTED
b894: e35c0001 cmp ip, #1 <== NOT EXECUTED
b898: e592c008 ldr ip, [r2, #8] <== NOT EXECUTED
{
p->avl.right = p1->avl.left;
p1->avl.left = p;
p->avl.bal = 0;
b89c: 05c31011 strbeq r1, [r3, #17] <== NOT EXECUTED
case 1:
p1 = p->avl.right;
if (p1->avl.bal == 1) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
b8a0: 0583c00c streq ip, [r3, #12] <== NOT EXECUTED
p1->avl.left = p;
b8a4: 05823008 streq r3, [r2, #8] <== NOT EXECUTED
p->avl.bal = 1;
break;
case 1:
p1 = p->avl.right;
if (p1->avl.bal == 1) /* simple RR-turn */
b8a8: 0a00000f beq b8ec <rtems_bdbuf_get_buffer_from_lru_list+0x324><== NOT EXECUTED
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
b8ac: e59c800c ldr r8, [ip, #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;
b8b0: e1dca1d1 ldrsb sl, [ip, #17] <== NOT EXECUTED
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
b8b4: e5828008 str r8, [r2, #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;
b8b8: e35a0001 cmp sl, #1 <== NOT EXECUTED
b8bc: 05c36011 strbeq r6, [r3, #17] <== NOT EXECUTED
b8c0: 15c31011 strbne r1, [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;
b8c4: e59c8008 ldr r8, [ip, #8] <== NOT EXECUTED
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
b8c8: e58c200c str r2, [ip, #12] <== NOT EXECUTED
p->avl.right = p2->avl.left;
p2->avl.left = p;
b8cc: e58c3008 str r3, [ip, #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;
b8d0: e583800c str r8, [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;
b8d4: e1dc31d1 ldrsb r3, [ip, #17] <== NOT EXECUTED
b8d8: e3730001 cmn r3, #1 <== NOT EXECUTED
b8dc: 05c25011 strbeq r5, [r2, #17] <== NOT EXECUTED
b8e0: 0a000000 beq b8e8 <rtems_bdbuf_get_buffer_from_lru_list+0x320><== NOT EXECUTED
b8e4: e5c21011 strb r1, [r2, #17] <== NOT EXECUTED
b8e8: e1a0200c mov r2, ip <== NOT EXECUTED
p = p2;
}
p->avl.bal = 0;
b8ec: e5c21011 strb r1, [r2, #17] <== NOT EXECUTED
b8f0: e3a0c000 mov ip, #0 <== NOT EXECUTED
b8f4: ea000001 b b900 <rtems_bdbuf_get_buffer_from_lru_list+0x338><== NOT EXECUTED
b8f8: e1a02003 mov r2, r3
b8fc: e3a0c001 mov ip, #1
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
b900: e1540007 cmp r4, r7
b904: 9a000008 bls b92c <rtems_bdbuf_get_buffer_from_lru_list+0x364>
{
p = *--buf_prev;
b908: e5143004 ldr r3, [r4, #-4] <== NOT EXECUTED
if (p->avl.cache == -1)
b90c: e1d381d0 ldrsb r8, [r3, #16] <== NOT EXECUTED
b910: e3780001 cmn r8, #1 <== NOT EXECUTED
{
p->avl.left = q;
b914: 05832008 streq r2, [r3, #8] <== NOT EXECUTED
}
else
{
p->avl.right = q;
b918: 1583200c strne r2, [r3, #12] <== NOT EXECUTED
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
b91c: e35c0000 cmp ip, #0 <== NOT EXECUTED
p->avl.right = q;
}
}
else
{
*root = p;
b920: e2444004 sub r4, r4, #4 <== NOT EXECUTED
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
b924: 1affffac bne b7dc <rtems_bdbuf_get_buffer_from_lru_list+0x214><== NOT EXECUTED
b928: ea000001 b b934 <rtems_bdbuf_get_buffer_from_lru_list+0x36c><== NOT EXECUTED
p->avl.right = q;
}
}
else
{
*root = p;
b92c: e59f3030 ldr r3, [pc, #48] ; b964 <rtems_bdbuf_get_buffer_from_lru_list+0x39c>
b930: e5832040 str r2, [r3, #64] ; 0x40
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
b934: e3a03001 mov r3, #1
b938: e5803024 str r3, [r0, #36] ; 0x24
if (empty_bd != NULL)
{
rtems_bdbuf_setup_empty_buffer (empty_bd, dev, block);
return empty_bd;
b93c: ea000004 b b954 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
b940: e5988000 ldr r8, [r8]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
b944: e59f2024 ldr r2, [pc, #36] ; b970 <rtems_bdbuf_get_buffer_from_lru_list+0x3a8>
b948: e1580002 cmp r8, r2
b94c: 1affff27 bne b5f0 <rtems_bdbuf_get_buffer_from_lru_list+0x28>
b950: e3a00000 mov r0, #0
node = rtems_chain_next (node);
}
return NULL;
}
b954: e28dd088 add sp, sp, #136 ; 0x88
b958: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
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);
b95c: e59f0010 ldr r0, [pc, #16] ; b974 <rtems_bdbuf_get_buffer_from_lru_list+0x3ac><== NOT EXECUTED
b960: ebffebf5 bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
0000a2b0 <rtems_bdbuf_init>:
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
a2b0: 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())
a2b4: e59f33b0 ldr r3, [pc, #944] ; a66c <rtems_bdbuf_init+0x3bc>
a2b8: e5933000 ldr r3, [r3]
a2bc: e3530000 cmp r3, #0
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
a2c0: e24dd014 sub sp, sp, #20
rtems_mode prev_mode;
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
a2c4: 13a00012 movne r0, #18
a2c8: 1a0000e5 bne a664 <rtems_bdbuf_init+0x3b4>
return RTEMS_CALLED_FROM_ISR;
/*
* Check the configuration table values.
*/
if ((bdbuf_config.buffer_max % bdbuf_config.buffer_min) != 0)
a2cc: e59f739c ldr r7, [pc, #924] ; a670 <rtems_bdbuf_init+0x3c0>
a2d0: e5973024 ldr r3, [r7, #36] ; 0x24
a2d4: e5976020 ldr r6, [r7, #32]
a2d8: e1a00003 mov r0, r3
a2dc: e1a01006 mov r1, r6
a2e0: e58d3010 str r3, [sp, #16]
a2e4: eb0040cd bl 1a620 <__umodsi3>
a2e8: e3500000 cmp r0, #0
a2ec: 13a0000a movne r0, #10
a2f0: 1a0000db bne a664 <rtems_bdbuf_init+0x3b4>
/*
* 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 ();
a2f4: ebffffa4 bl a18c <rtems_bdbuf_disable_preemption>
if (bdbuf_cache.initialised)
a2f8: e59f4374 ldr r4, [pc, #884] ; a674 <rtems_bdbuf_init+0x3c4>
a2fc: e5d45088 ldrb r5, [r4, #136] ; 0x88
a300: e3550000 cmp r5, #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 ();
a304: e1a08000 mov r8, r0
if (bdbuf_cache.initialised)
a308: 0a000002 beq a318 <rtems_bdbuf_init+0x68>
{
rtems_bdbuf_restore_preemption (prev_mode);
a30c: ebffffac bl a1c4 <rtems_bdbuf_restore_preemption> <== NOT EXECUTED
a310: e3a0000c mov r0, #12 <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
a314: ea0000d2 b a664 <rtems_bdbuf_init+0x3b4> <== NOT EXECUTED
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
a318: e1a01005 mov r1, r5
a31c: e3a0208c mov r2, #140 ; 0x8c
a320: e1a00004 mov r0, r4
a324: eb001d53 bl 11878 <memset>
bdbuf_cache.initialised = true;
rtems_bdbuf_restore_preemption (prev_mode);
a328: e1a00008 mov r0, r8
rtems_bdbuf_restore_preemption (prev_mode);
return RTEMS_RESOURCE_IN_USE;
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
bdbuf_cache.initialised = true;
a32c: e3a08001 mov r8, #1
a330: e5c48088 strb r8, [r4, #136] ; 0x88
rtems_bdbuf_restore_preemption (prev_mode);
a334: ebffffa2 bl a1c4 <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;
a338: e3e0a000 mvn sl, #0
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
a33c: e284c00c add ip, r4, #12
a340: e3e0b000 mvn fp, #0
a344: e584a038 str sl, [r4, #56] ; 0x38
a348: e584b03c str fp, [r4, #60] ; 0x3c
a34c: e584c008 str ip, [r4, #8]
a350: e59fb320 ldr fp, [pc, #800] ; a678 <rtems_bdbuf_init+0x3c8>
a354: e59fc320 ldr ip, [pc, #800] ; a67c <rtems_bdbuf_init+0x3cc>
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
a358: e59fa320 ldr sl, [pc, #800] ; a680 <rtems_bdbuf_init+0x3d0>
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
a35c: e584b044 str fp, [r4, #68] ; 0x44
a360: e584c050 str ip, [r4, #80] ; 0x50
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
a364: e584a058 str sl, [r4, #88] ; 0x58
a368: e59fc314 ldr ip, [pc, #788] ; a684 <rtems_bdbuf_init+0x3d4>
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
a36c: e59fb314 ldr fp, [pc, #788] ; a688 <rtems_bdbuf_init+0x3d8>
rtems_chain_initialize_empty (&bdbuf_cache.sync);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
a370: e59fa314 ldr sl, [pc, #788] ; a68c <rtems_bdbuf_init+0x3dc>
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
a374: e284e008 add lr, r4, #8
a378: e2849044 add r9, r4, #68 ; 0x44
a37c: e1a03005 mov r3, r5
a380: e584e010 str lr, [r4, #16]
a384: e584904c str r9, [r4, #76] ; 0x4c
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
a388: e584b05c str fp, [r4, #92] ; 0x5c
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
a38c: e584c064 str ip, [r4, #100] ; 0x64
a390: e59f02f8 ldr r0, [pc, #760] ; a690 <rtems_bdbuf_init+0x3e0>
a394: e58da000 str sl, [sp]
a398: e1a01008 mov r1, r8
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
a39c: e584500c str r5, [r4, #12]
a3a0: e5845048 str r5, [r4, #72] ; 0x48
a3a4: e5845054 str r5, [r4, #84] ; 0x54
a3a8: e5845060 str r5, [r4, #96] ; 0x60
a3ac: e3a02054 mov r2, #84 ; 0x54
a3b0: ebffef61 bl 613c <rtems_semaphore_create>
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
a3b4: e2505000 subs r5, r0, #0
a3b8: 1a00008c bne a5f0 <rtems_bdbuf_init+0x340>
goto error;
rtems_bdbuf_lock_cache ();
a3bc: ebfffe2e bl 9c7c <rtems_bdbuf_lock_cache>
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'),
a3c0: e1a01008 mov r1, r8
a3c4: e284c02c add ip, r4, #44 ; 0x2c
a3c8: e1a03005 mov r3, r5
a3cc: e59f02c0 ldr r0, [pc, #704] ; a694 <rtems_bdbuf_init+0x3e4>
a3d0: e3a02054 mov r2, #84 ; 0x54
a3d4: e58dc000 str ip, [sp]
a3d8: ebffef57 bl 613c <rtems_semaphore_create>
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.sync_lock);
if (sc != RTEMS_SUCCESSFUL)
a3dc: e2501000 subs r1, r0, #0
a3e0: 1a000082 bne a5f0 <rtems_bdbuf_init+0x340>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'),
a3e4: e284c06c add ip, r4, #108 ; 0x6c
a3e8: e1a03001 mov r3, r1
a3ec: e59f02a4 ldr r0, [pc, #676] ; a698 <rtems_bdbuf_init+0x3e8>
a3f0: e3a02024 mov r2, #36 ; 0x24
a3f4: e58dc000 str ip, [sp]
a3f8: ebffef4f bl 613c <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.access_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
a3fc: e2501000 subs r1, r0, #0
a400: 1a00007a bne a5f0 <rtems_bdbuf_init+0x340>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'),
a404: e284c074 add ip, r4, #116 ; 0x74
a408: e1a03001 mov r3, r1
a40c: e59f0288 ldr r0, [pc, #648] ; a69c <rtems_bdbuf_init+0x3ec>
a410: e3a02024 mov r2, #36 ; 0x24
a414: e58dc000 str ip, [sp]
a418: ebffef47 bl 613c <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.transfer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
a41c: e2501000 subs r1, r0, #0
a420: 1a000072 bne a5f0 <rtems_bdbuf_init+0x340>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'),
a424: e284c07c add ip, r4, #124 ; 0x7c
a428: e59f0270 ldr r0, [pc, #624] ; a6a0 <rtems_bdbuf_init+0x3f0>
a42c: e3a02024 mov r2, #36 ; 0x24
a430: e1a03001 mov r3, r1
a434: e58dc000 str ip, [sp]
a438: ebffef3f bl 613c <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.buffer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
a43c: e3500000 cmp r0, #0
a440: 1a00006a bne a5f0 <rtems_bdbuf_init+0x340>
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
a444: e597001c ldr r0, [r7, #28]
a448: e1a01006 mov r1, r6
a44c: eb003fdf bl 1a3d0 <__aeabi_uidiv>
a450: e1a05000 mov r5, r0
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
a454: e1a01006 mov r1, r6
a458: e59d0010 ldr r0, [sp, #16]
goto error;
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
a45c: e584501c str r5, [r4, #28]
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
a460: eb003fda bl 1a3d0 <__aeabi_uidiv>
a464: e1a03000 mov r3, r0
bdbuf_cache.group_count =
a468: e1a01000 mov r1, r0
/*
* 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 =
a46c: e5843020 str r3, [r4, #32]
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
a470: e1a00005 mov r0, r5
a474: eb003fd5 bl 1a3d0 <__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),
a478: e1a01005 mov r1, r5
*/
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 =
a47c: 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),
a480: e3a0003c mov r0, #60 ; 0x3c
a484: ebffe1c4 bl 2b9c <calloc>
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
a488: 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),
a48c: e5840014 str r0, [r4, #20]
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
a490: 0a000056 beq a5f0 <rtems_bdbuf_init+0x340>
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
a494: e3a00014 mov r0, #20
a498: e5941080 ldr r1, [r4, #128] ; 0x80
a49c: ebffe1be bl 2b9c <calloc>
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
a4a0: e3500000 cmp r0, #0
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
a4a4: e5840084 str r0, [r4, #132] ; 0x84
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
a4a8: 0a000050 beq a5f0 <rtems_bdbuf_init+0x340>
* 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,
a4ac: e59f71c0 ldr r7, [pc, #448] ; a674 <rtems_bdbuf_init+0x3c4>
a4b0: e597201c ldr r2, [r7, #28]
a4b4: e2870018 add r0, r7, #24
a4b8: e0020296 mul r2, r6, r2
a4bc: e3a01020 mov r1, #32
a4c0: eb000f5c bl e238 <rtems_memalign>
a4c4: e2505000 subs r5, r0, #0
a4c8: 1a000048 bne a5f0 <rtems_bdbuf_init+0x340>
/*
* 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,
a4cc: e1a0a007 mov sl, r7
a4d0: e5978084 ldr r8, [r7, #132] ; 0x84
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
a4d4: e5974014 ldr r4, [r7, #20]
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dev = BDBUF_INVALID_DEV;
a4d8: e3e02000 mvn r2, #0
/*
* 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,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
a4dc: e5977018 ldr r7, [r7, #24]
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dev = BDBUF_INVALID_DEV;
a4e0: e3e03000 mvn r3, #0
a4e4: e1a09006 mov r9, r6
/*
* 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,
a4e8: ea000012 b a538 <rtems_bdbuf_init+0x288>
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;
a4ec: e5842014 str r2, [r4, #20]
a4f0: e5843018 str r3, [r4, #24]
bd->group = group;
a4f4: e584802c str r8, [r4, #44] ; 0x2c
bd->buffer = buffer;
a4f8: e5847020 str r7, [r4, #32]
a4fc: e58d200c str r2, [sp, #12]
a500: e58d3008 str r3, [sp, #8]
a504: ebfff22d bl 6dc0 <_Chain_Append>
rtems_chain_append (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
a508: e59a6020 ldr r6, [sl, #32]
a50c: e1a00005 mov r0, r5
a510: e1a01006 mov r1, r6
a514: eb004041 bl 1a620 <__umodsi3>
a518: e2466001 sub r6, r6, #1
a51c: e1500006 cmp r0, r6
a520: e59d200c ldr r2, [sp, #12]
a524: e59d3008 ldr r3, [sp, #8]
(bdbuf_cache.max_bds_per_group - 1))
group++;
a528: 02888014 addeq r8, r8, #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)
a52c: e2855001 add r5, r5, #1
a530: e284403c add r4, r4, #60 ; 0x3c
a534: e0877009 add r7, r7, r9
/*
* 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,
a538: e59a001c ldr r0, [sl, #28]
a53c: e59fc130 ldr ip, [pc, #304] ; a674 <rtems_bdbuf_init+0x3c4>
a540: e1550000 cmp r5, r0
a544: e1a01004 mov r1, r4
a548: e28c0044 add r0, ip, #68 ; 0x44
a54c: 3affffe6 bcc a4ec <rtems_bdbuf_init+0x23c>
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
a550: e59c0020 ldr r0, [ip, #32]
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
a554: e3a0303c mov r3, #60 ; 0x3c
a558: e00e0093 mul lr, r3, r0
group++;
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
a55c: e59c1014 ldr r1, [ip, #20]
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
group = bdbuf_cache.groups,
a560: e59c3084 ldr r3, [ip, #132] ; 0x84
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
a564: e3a02000 mov r2, #0
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
a568: e59cc080 ldr ip, [ip, #128] ; 0x80
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
a56c: ea000004 b a584 <rtems_bdbuf_init+0x2d4>
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
group->bdbuf = bd;
a570: e5831010 str r1, [r3, #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;
a574: e5830008 str r0, [r3, #8]
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
a578: e2822001 add r2, r2, #1
group++,
a57c: e2833014 add r3, r3, #20
bd += bdbuf_cache.max_bds_per_group)
a580: e081100e add r1, r1, lr
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
a584: e152000c cmp r2, ip
a588: 3afffff8 bcc a570 <rtems_bdbuf_init+0x2c0>
* threads.
*/
bdbuf_cache.swapout_enabled = true;
sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),
bdbuf_config.swapout_priority ?
a58c: e59f30dc ldr r3, [pc, #220] ; a670 <rtems_bdbuf_init+0x3c0>
a590: e5931008 ldr r1, [r3, #8]
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
a594: e59f40d8 ldr r4, [pc, #216] ; a674 <rtems_bdbuf_init+0x3c4>
sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),
a598: e3510000 cmp r1, #0
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
a59c: e3a0c001 mov ip, #1
a5a0: e5c4c004 strb ip, [r4, #4]
sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),
a5a4: 03a0100f moveq r1, #15
a5a8: e3a0c000 mov ip, #0
a5ac: e59f00f0 ldr r0, [pc, #240] ; a6a4 <rtems_bdbuf_init+0x3f4>
a5b0: e3a02a02 mov r2, #8192 ; 0x2000
a5b4: e3a03b01 mov r3, #1024 ; 0x400
a5b8: e58dc000 str ip, [sp]
a5bc: e58d4004 str r4, [sp, #4]
a5c0: ebffefdc bl 6538 <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)
a5c4: e3500000 cmp r0, #0
a5c8: 1a000008 bne a5f0 <rtems_bdbuf_init+0x340>
goto error;
sc = rtems_task_start (bdbuf_cache.swapout,
a5cc: e1a02004 mov r2, r4
a5d0: e5940000 ldr r0, [r4]
a5d4: e59f10cc ldr r1, [pc, #204] ; a6a8 <rtems_bdbuf_init+0x3f8>
a5d8: ebfff066 bl 6778 <rtems_task_start>
rtems_bdbuf_swapout_task,
(rtems_task_argument) &bdbuf_cache);
if (sc != RTEMS_SUCCESSFUL)
a5dc: e2504000 subs r4, r0, #0
a5e0: 1a000002 bne a5f0 <rtems_bdbuf_init+0x340>
goto error;
rtems_bdbuf_unlock_cache ();
a5e4: ebfffe1d bl 9e60 <rtems_bdbuf_unlock_cache>
a5e8: e1a00004 mov r0, r4
return RTEMS_SUCCESSFUL;
a5ec: ea00001c b a664 <rtems_bdbuf_init+0x3b4>
error:
if (bdbuf_cache.swapout != 0)
a5f0: e59f307c ldr r3, [pc, #124] ; a674 <rtems_bdbuf_init+0x3c4><== NOT EXECUTED
a5f4: e5930000 ldr r0, [r3] <== NOT EXECUTED
a5f8: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.swapout);
a5fc: 1bfff01f blne 6680 <rtems_task_delete> <== NOT EXECUTED
free (bdbuf_cache.buffers);
a600: e59f406c ldr r4, [pc, #108] ; a674 <rtems_bdbuf_init+0x3c4><== NOT EXECUTED
a604: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED
a608: ebffe1eb bl 2dbc <free> <== NOT EXECUTED
free (bdbuf_cache.groups);
a60c: e5940084 ldr r0, [r4, #132] ; 0x84 <== NOT EXECUTED
a610: ebffe1e9 bl 2dbc <free> <== NOT EXECUTED
free (bdbuf_cache.bds);
a614: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED
a618: ebffe1e7 bl 2dbc <free> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);
a61c: e594007c ldr r0, [r4, #124] ; 0x7c <== NOT EXECUTED
a620: ebffef30 bl 62e8 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);
a624: e594006c ldr r0, [r4, #108] ; 0x6c <== NOT EXECUTED
a628: ebffef2e bl 62e8 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
a62c: e5940074 ldr r0, [r4, #116] ; 0x74 <== NOT EXECUTED
a630: ebffef2c bl 62e8 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.sync_lock);
a634: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED
a638: ebffef2a bl 62e8 <rtems_semaphore_delete> <== NOT EXECUTED
if (bdbuf_cache.lock != 0)
a63c: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
a640: e3530000 cmp r3, #0 <== NOT EXECUTED
a644: 0a000002 beq a654 <rtems_bdbuf_init+0x3a4> <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
a648: ebfffe04 bl 9e60 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.lock);
a64c: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
a650: ebffef24 bl 62e8 <rtems_semaphore_delete> <== NOT EXECUTED
}
bdbuf_cache.initialised = false;
a654: e59f3018 ldr r3, [pc, #24] ; a674 <rtems_bdbuf_init+0x3c4> <== NOT EXECUTED
a658: e3a02000 mov r2, #0 <== NOT EXECUTED
a65c: e5c32088 strb r2, [r3, #136] ; 0x88 <== NOT EXECUTED
a660: e3a0000d mov r0, #13 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
a664: e28dd014 add sp, sp, #20
a668: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00009c58 <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)
{
9c58: e92d4010 push {r4, lr}
9c5c: e1a04001 mov r4, r1
rtems_status_code sc = rtems_semaphore_obtain (lock,
9c60: e3a01000 mov r1, #0
9c64: e1a02001 mov r2, r1
9c68: ebfff1c5 bl 6384 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
9c6c: e3500000 cmp r0, #0
9c70: 08bd8010 popeq {r4, pc}
rtems_fatal_error_occurred (fatal_error_code);
9c74: e1a00004 mov r0, r4 <== NOT EXECUTED
9c78: ebfff32f bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
00009eb0 <rtems_bdbuf_obtain_disk>:
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
9eb0: e59fc0e4 ldr ip, [pc, #228] ; 9f9c <rtems_bdbuf_obtain_disk+0xec>
9eb4: e5dcc088 ldrb ip, [ip, #136] ; 0x88
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)
{
9eb8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
9ebc: 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)
{
9ec0: e1a07002 mov r7, r2
9ec4: e1a08003 mov r8, r3
9ec8: e59d6018 ldr r6, [sp, #24]
9ecc: e59d501c ldr r5, [sp, #28]
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
9ed0: 03a00016 moveq r0, #22
9ed4: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
return RTEMS_NOT_CONFIGURED;
/*
* Do not hold the cache lock when obtaining the disk table.
*/
dd = rtems_disk_obtain (dev);
9ed8: ebffdfeb bl 1e8c <rtems_disk_obtain>
if (dd == NULL)
9edc: e2504000 subs r4, r0, #0
9ee0: 02800004 addeq r0, r0, #4
9ee4: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
return RTEMS_INVALID_ID;
*dd_ptr = dd;
if (media_block_ptr != NULL)
9ee8: e3560000 cmp r6, #0
*/
dd = rtems_disk_obtain (dev);
if (dd == NULL)
return RTEMS_INVALID_ID;
*dd_ptr = dd;
9eec: e5884000 str r4, [r8]
if (media_block_ptr != NULL)
9ef0: 0a00000c beq 9f28 <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)
9ef4: e5940020 ldr r0, [r4, #32]
9ef8: e0832097 umull r2, r3, r7, r0
9efc: e1a00002 mov r0, r2
9f00: e1a01003 mov r1, r3
9f04: e5942024 ldr r2, [r4, #36] ; 0x24
9f08: e3a03000 mov r3, #0
9f0c: eb0046dc bl 1ba84 <__udivdi3>
* the user.
*/
rtems_blkdev_bnum mb = rtems_bdbuf_media_block (block,
dd->block_size,
dd->media_block_size);
if (mb >= dd->size)
9f10: e594301c ldr r3, [r4, #28]
9f14: e1500003 cmp r0, r3
{
rtems_disk_release(dd);
return RTEMS_INVALID_NUMBER;
}
*media_block_ptr = mb + dd->start;
9f18: 35943018 ldrcc r3, [r4, #24]
9f1c: 30800003 addcc r0, r0, r3
9f20: 35860000 strcc r0, [r6]
* the user.
*/
rtems_blkdev_bnum mb = rtems_bdbuf_media_block (block,
dd->block_size,
dd->media_block_size);
if (mb >= dd->size)
9f24: 2a000015 bcs 9f80 <rtems_bdbuf_obtain_disk+0xd0>
}
*media_block_ptr = mb + dd->start;
}
if (bds_per_group_ptr != NULL)
9f28: e3550000 cmp r5, #0
9f2c: 01a00005 moveq r0, r5
9f30: 08bd81f0 popeq {r4, r5, r6, r7, r8, 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)
9f34: e59f3064 ldr r3, [pc, #100] ; 9fa0 <rtems_bdbuf_obtain_disk+0xf0>
*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);
9f38: 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)
9f3c: e5932024 ldr r2, [r3, #36] ; 0x24
9f40: e1500002 cmp r0, r2
9f44: 8a00000d bhi 9f80 <rtems_bdbuf_obtain_disk+0xd0>
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
9f48: e5931020 ldr r1, [r3, #32]
9f4c: e2400001 sub r0, r0, #1
9f50: eb00411e bl 1a3d0 <__aeabi_uidiv>
9f54: e3a01001 mov r1, #1
9f58: e2800001 add r0, r0, #1
9f5c: ea000000 b 9f64 <rtems_bdbuf_obtain_disk+0xb4>
for (bds_per_size = 1;
bds_per_size < bufs_per_size;
bds_per_size <<= 1)
9f60: 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;
9f64: e1510000 cmp r1, r0
9f68: 3afffffc bcc 9f60 <rtems_bdbuf_obtain_disk+0xb0>
bds_per_size < bufs_per_size;
bds_per_size <<= 1)
;
return bdbuf_cache.max_bds_per_group / bds_per_size;
9f6c: e59f3028 ldr r3, [pc, #40] ; 9f9c <rtems_bdbuf_obtain_disk+0xec>
9f70: e5930020 ldr r0, [r3, #32]
9f74: eb004115 bl 1a3d0 <__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)
9f78: e3500000 cmp r0, #0
9f7c: 1a000003 bne 9f90 <rtems_bdbuf_obtain_disk+0xe0>
{
rtems_disk_release (dd);
9f80: e1a00004 mov r0, r4 <== NOT EXECUTED
9f84: ebffe03c bl 207c <rtems_disk_release> <== NOT EXECUTED
9f88: e3a0000a mov r0, #10 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
9f8c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
}
*bds_per_group_ptr = bds_per_group;
9f90: e5850000 str r0, [r5]
9f94: e3a00000 mov r0, #0
}
return RTEMS_SUCCESSFUL;
}
9f98: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
0000ac60 <rtems_bdbuf_purge>:
}
}
static void
rtems_bdbuf_purge (rtems_bdbuf_purge_compare compare, dev_t dev)
{
ac60: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
ac64: e24dd094 sub sp, sp, #148 ; 0x94
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
ac68: e28d6088 add r6, sp, #136 ; 0x88
the_chain->permanent_null = NULL;
ac6c: e3a04000 mov r4, #0
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
ac70: e2863004 add r3, r6, #4
ac74: e58d3088 str r3, [sp, #136] ; 0x88
the_chain->permanent_null = NULL;
ac78: e58d408c str r4, [sp, #140] ; 0x8c
ac7c: e1a07000 mov r7, r0
the_chain->last = _Chain_Head(the_chain);
ac80: e58d6090 str r6, [sp, #144] ; 0x90
ac84: e88d0006 stm sp, {r1, r2}
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
ac88: ebfffbfb bl 9c7c <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;
ac8c: e59f3158 ldr r3, [pc, #344] ; adec <rtems_bdbuf_purge+0x18c>
*prev = NULL;
ac90: e28d5094 add r5, sp, #148 ; 0x94
ac94: e525408c str r4, [r5, #-140]! ; 0x8c
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ac98: e3a08006 mov r8, #6
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;
ac9c: e5934040 ldr r4, [r3, #64] ; 0x40
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
aca0: e3a0a00a mov sl, #10
aca4: ea00003c b ad9c <rtems_bdbuf_purge+0x13c>
*prev = NULL;
while (cur != NULL)
{
if ((*compare) (cur->dev, dev))
aca8: e2841014 add r1, r4, #20
acac: e8910003 ldm r1, {r0, r1}
acb0: e89d000c ldm sp, {r2, r3}
acb4: e1a0e00f mov lr, pc
acb8: e12fff17 bx r7
acbc: e3500000 cmp r0, #0
acc0: 0a000020 beq ad48 <rtems_bdbuf_purge+0xe8>
{
switch (cur->state)
acc4: e5943024 ldr r3, [r4, #36] ; 0x24
acc8: e353000a cmp r3, #10
accc: 979ff103 ldrls pc, [pc, r3, lsl #2]
acd0: ea00001a b ad40 <rtems_bdbuf_purge+0xe0> <== NOT EXECUTED
acd4: 0000ad48 .word 0x0000ad48 <== NOT EXECUTED
acd8: 0000ad48 .word 0x0000ad48 <== NOT EXECUTED
acdc: 0000ad18 .word 0x0000ad18 <== NOT EXECUTED
ace0: 0000ad38 .word 0x0000ad38 <== NOT EXECUTED
ace4: 0000ad38 .word 0x0000ad38 <== NOT EXECUTED
ace8: 0000ad38 .word 0x0000ad38 <== NOT EXECUTED
acec: 0000ad48 .word 0x0000ad48 <== NOT EXECUTED
acf0: 0000ad08 .word 0x0000ad08 <== NOT EXECUTED
acf4: 0000ad00 .word 0x0000ad00 <== NOT EXECUTED
acf8: 0000ad30 .word 0x0000ad30 <== NOT EXECUTED
acfc: 0000ad48 .word 0x0000ad48 <== 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);
ad00: e59f00e8 ldr r0, [pc, #232] ; adf0 <rtems_bdbuf_purge+0x190>
ad04: ebfffbe2 bl 9c94 <rtems_bdbuf_wake>
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
ad08: e594302c ldr r3, [r4, #44] ; 0x2c
ad0c: e593200c ldr r2, [r3, #12]
ad10: e2422001 sub r2, r2, #1
ad14: e583200c str r2, [r3, #12]
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ad18: e1a00004 mov r0, r4
ad1c: ebfff032 bl 6dec <_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 );
ad20: e1a00006 mov r0, r6
ad24: e1a01004 mov r1, r4
ad28: ebfff024 bl 6dc0 <_Chain_Append>
ad2c: ea000005 b ad48 <rtems_bdbuf_purge+0xe8>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ad30: e584a024 str sl, [r4, #36] ; 0x24
ad34: ea000003 b ad48 <rtems_bdbuf_purge+0xe8>
ad38: e5848024 str r8, [r4, #36] ; 0x24
ad3c: ea000001 b ad48 <rtems_bdbuf_purge+0xe8>
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);
ad40: e59f00ac ldr r0, [pc, #172] ; adf4 <rtems_bdbuf_purge+0x194><== NOT EXECUTED
ad44: ebffeefc bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
}
if (cur->avl.left != NULL)
ad48: e5943008 ldr r3, [r4, #8]
ad4c: e3530000 cmp r3, #0
{
/* Left */
++prev;
*prev = cur;
ad50: 15a54004 strne r4, [r5, #4]!
cur = cur->avl.left;
ad54: 15943008 ldrne r3, [r4, #8]
default:
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_STATE_11);
}
}
if (cur->avl.left != NULL)
ad58: 1a00000e bne ad98 <rtems_bdbuf_purge+0x138>
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
ad5c: e594300c ldr r3, [r4, #12]
ad60: e3530000 cmp r3, #0
{
/* Right */
++prev;
*prev = cur;
ad64: 15a54004 strne r4, [r5, #4]!
cur = cur->avl.right;
ad68: 1594300c ldrne r3, [r4, #12]
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
ad6c: 1a000009 bne ad98 <rtems_bdbuf_purge+0x138>
ad70: ea000001 b ad7c <rtems_bdbuf_purge+0x11c>
{
while (*prev != NULL && cur == (*prev)->avl.right)
{
/* Up */
cur = *prev;
--prev;
ad74: e2455004 sub r5, r5, #4 <== NOT EXECUTED
ad78: e1a04003 mov r4, r3 <== NOT EXECUTED
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL && cur == (*prev)->avl.right)
ad7c: e5953000 ldr r3, [r5]
ad80: e3530000 cmp r3, #0
ad84: 0a000003 beq ad98 <rtems_bdbuf_purge+0x138>
ad88: e593200c ldr r2, [r3, #12] <== NOT EXECUTED
ad8c: e1540002 cmp r4, r2 <== NOT EXECUTED
ad90: 0afffff7 beq ad74 <rtems_bdbuf_purge+0x114> <== NOT EXECUTED
ad94: ea000012 b ade4 <rtems_bdbuf_purge+0x184> <== NOT EXECUTED
ad98: e1a04003 mov r4, r3
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
ad9c: e3540000 cmp r4, #0
ada0: 1affffc0 bne aca8 <rtems_bdbuf_purge+0x48>
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
ada4: e28d5088 add r5, sp, #136 ; 0x88
ada8: ea000003 b adbc <rtems_bdbuf_purge+0x15c>
while ((node = rtems_chain_get (purge_list)) != NULL)
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
adac: e5933028 ldr r3, [r3, #40] ; 0x28
adb0: e3530000 cmp r3, #0
adb4: 03a04001 moveq r4, #1
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
adb8: ebffff34 bl aa90 <rtems_bdbuf_discard_buffer>
adbc: e1a00005 mov r0, r5
adc0: ebfff012 bl 6e10 <_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)
adc4: e2503000 subs r3, r0, #0
adc8: 1afffff7 bne adac <rtems_bdbuf_purge+0x14c>
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
adcc: e3540000 cmp r4, #0
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
add0: 159f0020 ldrne r0, [pc, #32] ; adf8 <rtems_bdbuf_purge+0x198>
add4: 1bfffbae blne 9c94 <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 ();
add8: ebfffc20 bl 9e60 <rtems_bdbuf_unlock_cache>
}
addc: e28dd094 add sp, sp, #148 ; 0x94
ade0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
cur = *prev;
--prev;
}
if (*prev != NULL)
/* Right */
cur = (*prev)->avl.right;
ade4: e1a03002 mov r3, r2 <== NOT EXECUTED
ade8: eaffffea b ad98 <rtems_bdbuf_purge+0x138> <== NOT EXECUTED
00009c48 <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);
}
9c48: e1500002 cmp r0, r2 <== NOT EXECUTED
9c4c: 13a00000 movne r0, #0 <== NOT EXECUTED
9c50: 03a00001 moveq r0, #1 <== NOT EXECUTED
9c54: e12fff1e bx lr <== NOT EXECUTED
0000adfc <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)
{
adfc: 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);
ae00: e59f0004 ldr r0, [pc, #4] ; ae0c <rtems_bdbuf_purge_major+0x10><== NOT EXECUTED
ae04: e3a02000 mov r2, #0 <== NOT EXECUTED
ae08: eaffff94 b ac60 <rtems_bdbuf_purge> <== NOT EXECUTED
0000bc8c <rtems_bdbuf_read>:
rtems_status_code
rtems_bdbuf_read (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
bc8c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
bc90: 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);
bc94: e24be028 sub lr, fp, #40 ; 0x28
rtems_status_code
rtems_bdbuf_read (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
bc98: e24dd02c sub sp, sp, #44 ; 0x2c
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
bc9c: e3a0c000 mov ip, #0
rtems_status_code
rtems_bdbuf_read (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
bca0: e50b303c str r3, [fp, #-60] ; 0x3c
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);
bca4: e58de000 str lr, [sp]
bca8: e24b3024 sub r3, fp, #36 ; 0x24
bcac: 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;
bcb0: e50bc02c str ip, [fp, #-44] ; 0x2c
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
bcb4: 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;
bcb8: e50bc024 str ip, [fp, #-36] ; 0x24
rtems_blkdev_request *req = NULL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
bcbc: 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);
bcc0: ebfff87a bl 9eb0 <rtems_bdbuf_obtain_disk>
if (sc != RTEMS_SUCCESSFUL)
bcc4: e3500000 cmp r0, #0
bcc8: e50b0030 str r0, [fp, #-48] ; 0x30
bccc: 1a0000a0 bne bf54 <rtems_bdbuf_read+0x2c8>
/*
* 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) +
bcd0: e59f329c ldr r3, [pc, #668] ; bf74 <rtems_bdbuf_read+0x2e8>
bcd4: e5937000 ldr r7, [r3]
bcd8: e2877001 add r7, r7, #1
bcdc: e1a03207 lsl r3, r7, #4
bce0: e283301c add r3, r3, #28
bce4: 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 ();
bce8: ebfff7e3 bl 9c7c <rtems_bdbuf_lock_cache>
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
bcec: e51b5024 ldr r5, [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;
bcf0: e5952020 ldr r2, [r5, #32]
bcf4: e5951024 ldr r1, [r5, #36] ; 0x24
bcf8: e1a00002 mov r0, r2
bcfc: e50b2034 str r2, [fp, #-52] ; 0x34
bd00: eb0039b2 bl 1a3d0 <__aeabi_uidiv>
dev_t dev = dd->dev;
bd04: e285301c add r3, r5, #28
bd08: e8131008 ldmda r3, {r3, ip}
bd0c: e08cc003 add ip, ip, r3
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);
bd10: e51b6028 ldr r6, [fp, #-40] ; 0x28
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;
bd14: e59f325c ldr r3, [pc, #604] ; bf78 <rtems_bdbuf_read+0x2ec>
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;
bd18: e51be030 ldr lr, [fp, #-48] ; 0x30
/*
* 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) +
bd1c: e28d4008 add r4, sp, #8
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);
bd20: e51b202c ldr r2, [fp, #-44] ; 0x2c
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;
bd24: e066c00c rsb ip, r6, ip
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;
bd28: e5843004 str r3, [r4, #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;
bd2c: e584e000 str lr, [r4]
req->req_done = rtems_bdbuf_transfer_done;
req->done_arg = req;
bd30: e5844008 str r4, [r4, #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;
bd34: e595a000 ldr sl, [r5]
bd38: e5958004 ldr r8, [r5, #4]
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 ();
bd3c: e50bc044 str ip, [fp, #-68] ; 0x44
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);
bd40: e50b2038 str r2, [fp, #-56] ; 0x38
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;
bd44: e50b0040 str r0, [fp, #-64] ; 0x40
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 ();
bd48: eb000a66 bl e6e8 <rtems_task_self>
req->status = RTEMS_RESOURCE_IN_USE;
bd4c: e3a0e00c mov lr, #12
bd50: e584e00c str lr, [r4, #12]
req->bufnum = 0;
bd54: e51be030 ldr lr, [fp, #-48] ; 0x30
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 ();
bd58: e5840014 str r0, [r4, #20]
req->status = RTEMS_RESOURCE_IN_USE;
req->bufnum = 0;
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
bd5c: e1a02006 mov r2, r6
bd60: e51b3038 ldr r3, [fp, #-56] ; 0x38
bd64: e1a0000a mov r0, sl
bd68: e1a01008 mov r1, r8
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;
bd6c: e584e010 str lr, [r4, #16]
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
bd70: ebffff00 bl b978 <rtems_bdbuf_get_buffer_for_access>
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;
bd74: 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)
bd78: e5909024 ldr r9, [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;
bd7c: e5903020 ldr r3, [r0, #32]
*bd_ptr = bd;
req->bufs [0].user = bd;
req->bufs [0].block = media_block;
req->bufs [0].length = block_size;
bd80: e51b2034 ldr r2, [fp, #-52] ; 0x34
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;
bd84: e15c0007 cmp ip, r7
bd88: 21a0c007 movcs ip, r7
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
bd8c: e3590002 cmp r9, #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);
bd90: e1a05000 mov r5, 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;
bd94: e5843020 str r3, [r4, #32]
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
*bd_ptr = bd;
req->bufs [0].user = bd;
bd98: e5840024 str r0, [r4, #36] ; 0x24
req->bufs [0].block = media_block;
bd9c: e5846018 str r6, [r4, #24]
req->bufs [0].length = block_size;
bda0: e584201c str r2, [r4, #28]
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
bda4: 0a000046 beq bec4 <rtems_bdbuf_read+0x238>
bda8: e3590007 cmp r9, #7
bdac: 0a000044 beq bec4 <rtems_bdbuf_read+0x238>
bdb0: e3590001 cmp r9, #1
bdb4: 1a000006 bne bdd4 <rtems_bdbuf_read+0x148>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
bdb8: e1a07004 mov r7, r4
bdbc: e3a03009 mov r3, #9
bdc0: e1a0400c mov r4, ip
bdc4: e5803024 str r3, [r0, #36] ; 0x24
bdc8: e1a0c000 mov ip, r0
bdcc: e1a05007 mov r5, r7
bdd0: ea000036 b beb0 <rtems_bdbuf_read+0x224>
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);
bdd4: 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);
bdd8: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
bddc: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
bde0: e380001d orr r0, r0, #29 <== NOT EXECUTED
bde4: ea000056 b bf44 <rtems_bdbuf_read+0x2b8> <== NOT EXECUTED
break;
}
while (transfer_index < transfer_count)
{
media_block += media_block_count;
bde8: e51b3040 ldr r3, [fp, #-64] ; 0x40
static rtems_bdbuf_buffer *
rtems_bdbuf_avl_search (rtems_bdbuf_buffer** root,
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
bdec: e59fe188 ldr lr, [pc, #392] ; bf7c <rtems_bdbuf_read+0x2f0>
break;
}
while (transfer_index < transfer_count)
{
media_block += media_block_count;
bdf0: e0866003 add r6, r6, 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;
bdf4: e59e3040 ldr r3, [lr, #64] ; 0x40
bdf8: ea000009 b be24 <rtems_bdbuf_read+0x198>
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
{
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
bdfc: e1580002 cmp r8, r2 <== NOT EXECUTED
be00: 8a000004 bhi be18 <rtems_bdbuf_read+0x18c> <== NOT EXECUTED
be04: 1a000005 bne be20 <rtems_bdbuf_read+0x194> <== NOT EXECUTED
be08: e15a0001 cmp sl, r1 <== NOT EXECUTED
be0c: 8a000001 bhi be18 <rtems_bdbuf_read+0x18c> <== NOT EXECUTED
be10: ea000002 b be20 <rtems_bdbuf_read+0x194> <== NOT EXECUTED
be14: 2a000001 bcs be20 <rtems_bdbuf_read+0x194>
{
p = p->avl.right;
be18: e593300c ldr r3, [r3, #12]
be1c: ea000000 b be24 <rtems_bdbuf_read+0x198>
}
else
{
p = p->avl.left;
be20: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
be24: e3530000 cmp r3, #0
be28: 0a000009 beq be54 <rtems_bdbuf_read+0x1c8>
be2c: e5931014 ldr r1, [r3, #20]
be30: e151000a cmp r1, sl
be34: e5932018 ldr r2, [r3, #24]
be38: 1affffef bne bdfc <rtems_bdbuf_read+0x170>
be3c: e1520008 cmp r2, r8
be40: 1affffed bne bdfc <rtems_bdbuf_read+0x170>
be44: e593201c ldr r2, [r3, #28]
be48: e1520006 cmp r2, r6
be4c: 1afffff0 bne be14 <rtems_bdbuf_read+0x188>
be50: ea000018 b beb8 <rtems_bdbuf_read+0x22c> <== NOT EXECUTED
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);
be54: e1a0000a mov r0, sl
be58: e1a01008 mov r1, r8
be5c: e1a02006 mov r2, r6
be60: e51b3038 ldr r3, [fp, #-56] ; 0x38
be64: e50bc044 str ip, [fp, #-68] ; 0x44
be68: ebfffdd6 bl b5c8 <rtems_bdbuf_get_buffer_from_lru_list>
if (bd != NULL)
be6c: e3500000 cmp r0, #0
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);
be70: e2877010 add r7, r7, #16
if (bd != NULL)
be74: e51bc044 ldr ip, [fp, #-68] ; 0x44
be78: 0a00000e beq beb8 <rtems_bdbuf_read+0x22c>
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
be7c: e590302c ldr r3, [r0, #44] ; 0x2c <== NOT EXECUTED
be80: e593100c ldr r1, [r3, #12] <== 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;
be84: e5902020 ldr r2, [r0, #32] <== NOT EXECUTED
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
be88: e2811001 add r1, r1, #1 <== NOT EXECUTED
be8c: e583100c str r1, [r3, #12] <== 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;
be90: e51b3034 ldr r3, [fp, #-52] ; 0x34 <== NOT EXECUTED
req->bufs [transfer_index].buffer = bd->buffer;
be94: e5872020 str r2, [r7, #32] <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
be98: e3a02009 mov r2, #9 <== NOT EXECUTED
be9c: e5802024 str r2, [r0, #36] ; 0x24 <== NOT EXECUTED
if (bd == NULL)
break;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
bea0: e5870024 str r0, [r7, #36] ; 0x24 <== NOT EXECUTED
req->bufs [transfer_index].block = media_block;
bea4: e5876018 str r6, [r7, #24] <== NOT EXECUTED
req->bufs [transfer_index].length = block_size;
bea8: e587301c str r3, [r7, #28] <== NOT EXECUTED
req->bufs [transfer_index].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
beac: e2899001 add r9, r9, #1 <== NOT EXECUTED
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
break;
}
while (transfer_index < transfer_count)
beb0: e1590004 cmp r9, r4
beb4: 3affffcb bcc bde8 <rtems_bdbuf_read+0x15c>
beb8: e1a04005 mov r4, r5
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
}
req->bufnum = transfer_index;
bebc: e5849010 str r9, [r4, #16]
bec0: e1a0500c mov r5, ip
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)
bec4: e5943010 ldr r3, [r4, #16]
bec8: e3530000 cmp r3, #0
becc: 0a00000b beq bf00 <rtems_bdbuf_read+0x274>
{
sc = rtems_bdbuf_execute_transfer_request (dd, req, true);
bed0: e1a01004 mov r1, r4
bed4: e51b0024 ldr r0, [fp, #-36] ; 0x24
bed8: e3a02001 mov r2, #1
bedc: ebfffbd0 bl ae24 <rtems_bdbuf_execute_transfer_request>
if (sc == RTEMS_SUCCESSFUL)
bee0: e3500000 cmp r0, #0
bee4: 1a00001d bne bf60 <rtems_bdbuf_read+0x2d4>
bee8: e1a00005 mov r0, r5
beec: ebffebbe bl 6dec <_Chain_Extract>
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
bef0: e595302c ldr r3, [r5, #44] ; 0x2c
bef4: e593200c ldr r2, [r3, #12]
bef8: e2822001 add r2, r2, #1
befc: e583200c str r2, [r3, #12]
}
}
if (sc == RTEMS_SUCCESSFUL)
{
switch (bd->state)
bf00: e5953024 ldr r3, [r5, #36] ; 0x24
bf04: e3530002 cmp r3, #2
bf08: 0a000002 beq bf18 <rtems_bdbuf_read+0x28c>
bf0c: e3530007 cmp r3, #7
bf10: 1a000007 bne bf34 <rtems_bdbuf_read+0x2a8>
bf14: ea000001 b bf20 <rtems_bdbuf_read+0x294>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
bf18: e3a03003 mov r3, #3
bf1c: ea000000 b bf24 <rtems_bdbuf_read+0x298>
bf20: e3a03004 mov r3, #4
{
rtems_bdbuf_show_users ("read", bd);
rtems_bdbuf_show_usage ();
}
*bd_ptr = bd;
bf24: e51be03c ldr lr, [fp, #-60] ; 0x3c
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
bf28: e5853024 str r3, [r5, #36] ; 0x24
{
rtems_bdbuf_show_users ("read", bd);
rtems_bdbuf_show_usage ();
}
*bd_ptr = bd;
bf2c: e58e5000 str r5, [lr]
bf30: ea000004 b bf48 <rtems_bdbuf_read+0x2bc>
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);
bf34: e5950024 ldr r0, [r5, #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);
bf38: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
bf3c: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
bf40: e3800002 orr r0, r0, #2 <== NOT EXECUTED
bf44: ebffea7c bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
*bd_ptr = bd;
}
else
*bd_ptr = NULL;
rtems_bdbuf_unlock_cache ();
bf48: ebfff7c4 bl 9e60 <rtems_bdbuf_unlock_cache>
rtems_bdbuf_release_disk (dd);
bf4c: e51b0024 ldr r0, [fp, #-36] ; 0x24
bf50: ebfff813 bl 9fa4 <rtems_bdbuf_release_disk>
return sc;
}
bf54: e51b0030 ldr r0, [fp, #-48] ; 0x30
bf58: e24bd020 sub sp, fp, #32
bf5c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
}
*bd_ptr = bd;
}
else
*bd_ptr = NULL;
bf60: e51b203c ldr r2, [fp, #-60] ; 0x3c
bf64: e3a03000 mov r3, #0
bf68: e5823000 str r3, [r2]
bf6c: e50b0030 str r0, [fp, #-48] ; 0x30
bf70: eafffff4 b bf48 <rtems_bdbuf_read+0x2bc>
0000ab8c <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)
ab8c: e59f30bc ldr r3, [pc, #188] ; ac50 <rtems_bdbuf_release+0xc4>
ab90: e5d33088 ldrb r3, [r3, #136] ; 0x88
ab94: e3530000 cmp r3, #0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
ab98: e92d4010 push {r4, lr}
ab9c: e1a04000 mov r4, r0
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
aba0: 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)
aba4: 08bd8010 popeq {r4, pc}
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
aba8: e3540000 cmp r4, #0
abac: 03a00009 moveq r0, #9
abb0: 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();
abb4: ebfffc30 bl 9c7c <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
abb8: e5943024 ldr r3, [r4, #36] ; 0x24
abbc: e2433003 sub r3, r3, #3
abc0: e3530003 cmp r3, #3
abc4: 979ff103 ldrls pc, [pc, r3, lsl #2]
abc8: ea000018 b ac30 <rtems_bdbuf_release+0xa4> <== NOT EXECUTED
abcc: 0000abdc .word 0x0000abdc <== NOT EXECUTED
abd0: 0000ac24 .word 0x0000ac24 <== NOT EXECUTED
abd4: 0000ac18 .word 0x0000ac18 <== NOT EXECUTED
abd8: 0000ac18 .word 0x0000ac18 <== NOT EXECUTED
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
abdc: e594302c ldr r3, [r4, #44] ; 0x2c
abe0: e593200c ldr r2, [r3, #12]
abe4: e2422001 sub r2, r2, #1
abe8: e583200c str r2, [r3, #12]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
abec: e3a03002 mov r3, #2
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
abf0: e59f005c ldr r0, [pc, #92] ; ac54 <rtems_bdbuf_release+0xc8>
abf4: e5843024 str r3, [r4, #36] ; 0x24
abf8: e1a01004 mov r1, r4
abfc: ebfff06f bl 6dc0 <_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)
ac00: e5943028 ldr r3, [r4, #40] ; 0x28
ac04: e3530000 cmp r3, #0
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
ac08: 159f0048 ldrne r0, [pc, #72] ; ac58 <rtems_bdbuf_release+0xcc>
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
ac0c: 059f0048 ldreq r0, [pc, #72] ; ac5c <rtems_bdbuf_release+0xd0>
ac10: ebfffc1f bl 9c94 <rtems_bdbuf_wake>
ac14: ea00000a b ac44 <rtems_bdbuf_release+0xb8>
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);
ac18: e1a00004 mov r0, r4
ac1c: ebffffa9 bl aac8 <rtems_bdbuf_discard_buffer_after_access>
break;
ac20: ea000007 b ac44 <rtems_bdbuf_release+0xb8>
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
ac24: e1a00004 mov r0, r4
ac28: ebfffcef bl 9fec <rtems_bdbuf_add_to_modified_list_after_access>
break;
ac2c: ea000004 b ac44 <rtems_bdbuf_release+0xb8>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_0);
ac30: 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);
ac34: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
ac38: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
ac3c: e380001c orr r0, r0, #28 <== NOT EXECUTED
ac40: ebffef3d bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
ac44: ebfffc85 bl 9e60 <rtems_bdbuf_unlock_cache>
ac48: e3a00000 mov r0, #0
return RTEMS_SUCCESSFUL;
}
ac4c: e8bd8010 pop {r4, pc}
00009fa4 <rtems_bdbuf_release_disk>:
static void
rtems_bdbuf_release_disk (rtems_disk_device *dd)
{
9fa4: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_disk_release (dd);
9fa8: ebffe033 bl 207c <rtems_disk_release>
if (sc != RTEMS_SUCCESSFUL)
9fac: e3500000 cmp r0, #0
9fb0: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_DISK_REL);
9fb4: e59f0000 ldr r0, [pc, #0] ; 9fbc <rtems_bdbuf_release_disk+0x18><== NOT EXECUTED
9fb8: ebfff25f bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
0000ab04 <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)
ab04: e59f307c ldr r3, [pc, #124] ; ab88 <rtems_bdbuf_release_modified+0x84>
ab08: e5d33088 ldrb r3, [r3, #136] ; 0x88
ab0c: e3530000 cmp r3, #0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
ab10: e92d4010 push {r4, lr}
ab14: e1a04000 mov r4, r0
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
ab18: 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)
ab1c: 08bd8010 popeq {r4, pc}
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
ab20: e3540000 cmp r4, #0
ab24: 03a00009 moveq r0, #9
ab28: 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();
ab2c: ebfffc52 bl 9c7c <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
ab30: e5943024 ldr r3, [r4, #36] ; 0x24
ab34: e3530003 cmp r3, #3
ab38: 3a00000a bcc ab68 <rtems_bdbuf_release_modified+0x64>
ab3c: e3530005 cmp r3, #5
ab40: 9a000002 bls ab50 <rtems_bdbuf_release_modified+0x4c>
ab44: e3530006 cmp r3, #6
ab48: 1a000006 bne ab68 <rtems_bdbuf_release_modified+0x64>
ab4c: ea000002 b ab5c <rtems_bdbuf_release_modified+0x58>
{
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);
ab50: e1a00004 mov r0, r4
ab54: ebfffd24 bl 9fec <rtems_bdbuf_add_to_modified_list_after_access>
break;
ab58: ea000007 b ab7c <rtems_bdbuf_release_modified+0x78>
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
ab5c: e1a00004 mov r0, r4
ab60: ebffffd8 bl aac8 <rtems_bdbuf_discard_buffer_after_access>
break;
ab64: ea000004 b ab7c <rtems_bdbuf_release_modified+0x78>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_6);
ab68: 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);
ab6c: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
ab70: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
ab74: e3800004 orr r0, r0, #4 <== NOT EXECUTED
ab78: ebffef6f bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
ab7c: ebfffcb7 bl 9e60 <rtems_bdbuf_unlock_cache>
ab80: e3a00000 mov r0, #0
return RTEMS_SUCCESSFUL;
}
ab84: e8bd8010 pop {r4, pc}
0000a6fc <rtems_bdbuf_remove_from_tree>:
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
a6fc: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
a700: e59f3340 ldr r3, [pc, #832] ; aa48 <rtems_bdbuf_remove_from_tree+0x34c>
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
a704: e24dd080 sub sp, sp, #128 ; 0x80
a708: e1a05000 mov r5, 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));
a70c: e3a01000 mov r1, #0
a710: e1a0000d mov r0, sp
a714: e3a02080 mov r2, #128 ; 0x80
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
a718: e5934040 ldr r4, [r3, #64] ; 0x40
*/
static int
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer** root,
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
a71c: e5958014 ldr r8, [r5, #20]
a720: e2857018 add r7, r5, #24
a724: e8970480 ldm r7, {r7, 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));
a728: e1a0600d mov r6, sp
a72c: eb001c51 bl 11878 <memset>
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
{
p->avl.cache = 1;
a730: e3a00001 mov r0, #1
p = p->avl.right;
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
a734: e3e01000 mvn r1, #0
a738: ea000014 b a790 <rtems_bdbuf_remove_from_tree+0x94>
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
a73c: e5943018 ldr r3, [r4, #24]
a740: e1570003 cmp r7, r3
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
a744: e4864004 str r4, [r6], #4
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
a748: e5942014 ldr r2, [r4, #20]
a74c: 8a000009 bhi a778 <rtems_bdbuf_remove_from_tree+0x7c>
a750: 1a000001 bne a75c <rtems_bdbuf_remove_from_tree+0x60>
a754: e1580002 cmp r8, r2
a758: 8a000006 bhi a778 <rtems_bdbuf_remove_from_tree+0x7c>
a75c: e1520008 cmp r2, r8
a760: 1a000008 bne a788 <rtems_bdbuf_remove_from_tree+0x8c>
a764: e1530007 cmp r3, r7
a768: 1a000006 bne a788 <rtems_bdbuf_remove_from_tree+0x8c>
a76c: e594301c ldr r3, [r4, #28]
a770: e153000a cmp r3, sl
a774: 2a000002 bcs a784 <rtems_bdbuf_remove_from_tree+0x88>
{
p->avl.cache = 1;
a778: e5c40010 strb r0, [r4, #16]
p = p->avl.right;
a77c: e594400c ldr r4, [r4, #12]
a780: ea000002 b a790 <rtems_bdbuf_remove_from_tree+0x94>
}
else if ((p->dev != dev) || (p->block != block))
a784: 0a000004 beq a79c <rtems_bdbuf_remove_from_tree+0xa0>
{
p->avl.cache = -1;
a788: e5c41010 strb r1, [r4, #16]
p = p->avl.left;
a78c: e5944008 ldr r4, [r4, #8]
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
a790: e3540000 cmp r4, #0
a794: 1affffe8 bne a73c <rtems_bdbuf_remove_from_tree+0x40>
a798: ea0000a3 b aa2c <rtems_bdbuf_remove_from_tree+0x330> <== NOT EXECUTED
return -1;
}
q = p;
buf_prev--;
a79c: e2462004 sub r2, r6, #4
if (buf_prev > buf_stack)
a7a0: e1a0300d mov r3, sp
a7a4: e1520003 cmp r2, r3
{
p = NULL;
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
a7a8: e594300c ldr r3, [r4, #12]
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
a7ac: 93a01000 movls r1, #0
{
p = *(buf_prev - 1);
a7b0: 85121004 ldrhi r1, [r2, #-4]
{
p = NULL;
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
a7b4: e3530000 cmp r3, #0
a7b8: 1a000005 bne a7d4 <rtems_bdbuf_remove_from_tree+0xd8>
{
r = q->avl.left;
a7bc: e5943008 ldr r3, [r4, #8]
if (r != NULL)
a7c0: e3530000 cmp r3, #0
{
r->avl.bal = 0;
a7c4: 13a00000 movne r0, #0
a7c8: 15c30011 strbne r0, [r3, #17]
a7cc: e1a06002 mov r6, r2
a7d0: ea00001e b a850 <rtems_bdbuf_remove_from_tree+0x154>
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
a7d4: e5930008 ldr r0, [r3, #8]
a7d8: e3500000 cmp r0, #0
{
r->avl.left = q->avl.left;
a7dc: 0594c008 ldreq ip, [r4, #8]
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
a7e0: 11a00006 movne r0, r6
a7e4: 11a0c003 movne ip, r3
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
a7e8: 13e05000 mvnne r5, #0
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
a7ec: 05d40011 ldrbeq r0, [r4, #17]
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
a7f0: 0583c008 streq ip, [r3, #8]
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
a7f4: 1a000005 bne a810 <rtems_bdbuf_remove_from_tree+0x114>
a7f8: ea000010 b a840 <rtems_bdbuf_remove_from_tree+0x144>
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
a7fc: e5003004 str r3, [r0, #-4] <== NOT EXECUTED
s = r->avl.left;
a800: e5936008 ldr r6, [r3, #8] <== NOT EXECUTED
r->avl.cache = -1;
a804: e5c35010 strb r5, [r3, #16] <== NOT EXECUTED
a808: e1a0c003 mov ip, r3 <== NOT EXECUTED
a80c: e1a03006 mov r3, r6 <== NOT EXECUTED
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
a810: e5936008 ldr r6, [r3, #8] <== NOT EXECUTED
a814: e3560000 cmp r6, #0 <== NOT EXECUTED
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
a818: e1a06000 mov r6, r0 <== NOT EXECUTED
a81c: e2800004 add r0, r0, #4 <== NOT EXECUTED
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
a820: 1afffff5 bne a7fc <rtems_bdbuf_remove_from_tree+0x100> <== NOT EXECUTED
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
a824: e5947008 ldr r7, [r4, #8] <== NOT EXECUTED
r->avl.left = s->avl.right;
a828: e593500c ldr r5, [r3, #12] <== NOT EXECUTED
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
a82c: e5d40011 ldrb r0, [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;
a830: 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;
a834: e5837008 str r7, [r3, #8] <== NOT EXECUTED
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
a838: e583400c str r4, [r3, #12] <== NOT EXECUTED
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
a83c: e58c5008 str r5, [ip, #8] <== NOT EXECUTED
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
a840: e5c30011 strb r0, [r3, #17]
s->avl.cache = 1;
a844: e3a00001 mov r0, #1
a848: e5c30010 strb r0, [r3, #16]
*t = q = s;
a84c: e5823000 str r3, [r2]
}
}
if (p != NULL)
a850: e3510000 cmp r1, #0
p->avl.right = q;
}
}
else
{
*root = q;
a854: 059f21ec ldreq r2, [pc, #492] ; aa48 <rtems_bdbuf_remove_from_tree+0x34c>
a858: 05823040 streq r3, [r2, #64] ; 0x40
*t = q = s;
}
}
if (p != NULL)
a85c: 0a000003 beq a870 <rtems_bdbuf_remove_from_tree+0x174>
{
if (p->avl.cache == -1)
a860: e1d121d0 ldrsb r2, [r1, #16]
a864: e3720001 cmn r2, #1
{
p->avl.left = q;
a868: 05813008 streq r3, [r1, #8]
}
else
{
p->avl.right = q;
a86c: 1581300c strne r3, [r1, #12]
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
a870: e1a0700d mov r7, sp
a874: e1560007 cmp r6, r7
a878: 9a000070 bls aa40 <rtems_bdbuf_remove_from_tree+0x344>
default:
break;
}
}
if (buf_prev > buf_stack)
a87c: e1a0700d mov r7, sp
{
case -1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = 1;
a880: e3a04001 mov r4, #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;
a884: e3a01000 mov r1, #0
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
a888: e3e05000 mvn r5, #0
while (modified)
{
if (buf_prev > buf_stack)
{
p = *--buf_prev;
a88c: e5363004 ldr r3, [r6, #-4]!
else
{
break;
}
if (p->avl.cache == -1)
a890: e1d3a1d0 ldrsb sl, [r3, #16]
a894: e37a0001 cmn sl, #1
a898: e1d3c1d1 ldrsb ip, [r3, #17]
a89c: 1a000027 bne a940 <rtems_bdbuf_remove_from_tree+0x244>
{
/* rebalance left branch */
switch (p->avl.bal)
a8a0: e35c0000 cmp ip, #0
{
case -1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = 1;
a8a4: 05c34011 strbeq r4, [r3, #17]
}
if (p->avl.cache == -1)
{
/* rebalance left branch */
switch (p->avl.bal)
a8a8: 0a00002d beq a964 <rtems_bdbuf_remove_from_tree+0x268>
a8ac: e35c0001 cmp ip, #1
a8b0: 0a000002 beq a8c0 <rtems_bdbuf_remove_from_tree+0x1c4>
a8b4: e37c0001 cmn ip, #1
{
case -1:
p->avl.bal = 0;
a8b8: 05c31011 strbeq r1, [r3, #17]
a8bc: ea00004b b a9f0 <rtems_bdbuf_remove_from_tree+0x2f4>
p->avl.bal = 1;
modified = false;
break;
case +1:
p1 = p->avl.right;
a8c0: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
if (p1->avl.bal >= 0) /* simple RR-turn */
a8c4: e1d091d1 ldrsb r9, [r0, #17] <== NOT EXECUTED
a8c8: e3590000 cmp r9, #0 <== NOT EXECUTED
a8cc: e5908008 ldr r8, [r0, #8] <== NOT EXECUTED
a8d0: ba000009 blt a8fc <rtems_bdbuf_remove_from_tree+0x200> <== NOT EXECUTED
{
p->avl.right = p1->avl.left;
a8d4: e583800c str r8, [r3, #12] <== NOT EXECUTED
p1->avl.left = p;
a8d8: e5803008 str r3, [r0, #8] <== NOT EXECUTED
p1->avl.bal = -1;
modified = false;
}
else
{
p->avl.bal = 0;
a8dc: 15c31011 strbne r1, [r3, #17] <== NOT EXECUTED
p->avl.right = p1->avl.left;
p1->avl.left = p;
if (p1->avl.bal == 0)
{
p1->avl.bal = -1;
a8e0: 05c0a011 strbeq sl, [r0, #17] <== NOT EXECUTED
a8e4: 01a02000 moveq r2, r0 <== NOT EXECUTED
a8e8: 01a03009 moveq r3, r9 <== NOT EXECUTED
modified = false;
}
else
{
p->avl.bal = 0;
p1->avl.bal = 0;
a8ec: 11a02000 movne r2, r0 <== NOT EXECUTED
a8f0: 15c01011 strbne r1, [r0, #17] <== NOT EXECUTED
if (p1->avl.bal >= 0) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
p1->avl.left = p;
if (p1->avl.bal == 0)
a8f4: 1a00001b bne a968 <rtems_bdbuf_remove_from_tree+0x26c> <== NOT EXECUTED
a8f8: ea00003e b a9f8 <rtems_bdbuf_remove_from_tree+0x2fc> <== NOT EXECUTED
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
a8fc: e598200c ldr r2, [r8, #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;
a900: e1d8c1d1 ldrsb ip, [r8, #17] <== NOT EXECUTED
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
a904: e5802008 str r2, [r0, #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;
a908: e35c0001 cmp ip, #1 <== NOT EXECUTED
a90c: 05c3a011 strbeq sl, [r3, #17] <== NOT EXECUTED
a910: 15c31011 strbne r1, [r3, #17] <== NOT EXECUTED
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
a914: e5982008 ldr r2, [r8, #8] <== NOT EXECUTED
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
a918: e588000c str r0, [r8, #12] <== NOT EXECUTED
p->avl.right = p2->avl.left;
p2->avl.left = p;
a91c: e5883008 str r3, [r8, #8] <== NOT EXECUTED
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
a920: e583200c str r2, [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;
a924: e1d831d1 ldrsb r3, [r8, #17] <== NOT EXECUTED
a928: e3730001 cmn r3, #1 <== NOT EXECUTED
a92c: 05c04011 strbeq r4, [r0, #17] <== NOT EXECUTED
a930: 15c01011 strbne r1, [r0, #17] <== NOT EXECUTED
}
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
a934: e1a02008 mov r2, r8 <== 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;
a938: e5c81011 strb r1, [r8, #17] <== NOT EXECUTED
a93c: ea00002c b a9f4 <rtems_bdbuf_remove_from_tree+0x2f8> <== NOT EXECUTED
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
a940: e35c0000 cmp ip, #0
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
a944: 05c35011 strbeq r5, [r3, #17]
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
a948: 0a000005 beq a964 <rtems_bdbuf_remove_from_tree+0x268>
a94c: e35c0001 cmp ip, #1
a950: 0a000002 beq a960 <rtems_bdbuf_remove_from_tree+0x264>
a954: e37c0001 cmn ip, #1 <== NOT EXECUTED
a958: 1a000024 bne a9f0 <rtems_bdbuf_remove_from_tree+0x2f4> <== NOT EXECUTED
a95c: ea000003 b a970 <rtems_bdbuf_remove_from_tree+0x274> <== NOT EXECUTED
{
case +1:
p->avl.bal = 0;
a960: e5c31011 strb r1, [r3, #17]
break;
case 0:
p->avl.bal = -1;
a964: e1a02003 mov r2, r3
a968: e1a0300c mov r3, ip
a96c: ea000021 b a9f8 <rtems_bdbuf_remove_from_tree+0x2fc>
modified = false;
break;
case -1:
p1 = p->avl.left;
a970: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
if (p1->avl.bal <= 0) /* simple LL-turn */
a974: e1d081d1 ldrsb r8, [r0, #17] <== NOT EXECUTED
a978: e3580000 cmp r8, #0 <== NOT EXECUTED
a97c: e590c00c ldr ip, [r0, #12] <== NOT EXECUTED
a980: ca000009 bgt a9ac <rtems_bdbuf_remove_from_tree+0x2b0> <== NOT EXECUTED
{
p->avl.left = p1->avl.right;
a984: e583c008 str ip, [r3, #8] <== NOT EXECUTED
p1->avl.right = p;
a988: e580300c str r3, [r0, #12] <== NOT EXECUTED
p1->avl.bal = 1;
modified = false;
}
else
{
p->avl.bal = 0;
a98c: 15c31011 strbne r1, [r3, #17] <== NOT EXECUTED
{
p->avl.left = p1->avl.right;
p1->avl.right = p;
if (p1->avl.bal == 0)
{
p1->avl.bal = 1;
a990: 05c04011 strbeq r4, [r0, #17] <== NOT EXECUTED
a994: 01a02000 moveq r2, r0 <== NOT EXECUTED
a998: 01a03008 moveq r3, r8 <== NOT EXECUTED
modified = false;
}
else
{
p->avl.bal = 0;
p1->avl.bal = 0;
a99c: 11a02000 movne r2, r0 <== NOT EXECUTED
a9a0: 15c01011 strbne r1, [r0, #17] <== NOT EXECUTED
if (p1->avl.bal <= 0) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
p1->avl.right = p;
if (p1->avl.bal == 0)
a9a4: 1a000012 bne a9f4 <rtems_bdbuf_remove_from_tree+0x2f8> <== NOT EXECUTED
a9a8: ea000012 b a9f8 <rtems_bdbuf_remove_from_tree+0x2fc> <== NOT EXECUTED
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
a9ac: e59c2008 ldr r2, [ip, #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;
a9b0: e1dc81d1 ldrsb r8, [ip, #17] <== NOT EXECUTED
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
a9b4: e580200c str r2, [r0, #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;
a9b8: e3780001 cmn r8, #1 <== NOT EXECUTED
a9bc: 05c34011 strbeq r4, [r3, #17] <== NOT EXECUTED
a9c0: 15c31011 strbne r1, [r3, #17] <== NOT EXECUTED
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
a9c4: e59c200c ldr r2, [ip, #12] <== NOT EXECUTED
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
a9c8: e58c0008 str r0, [ip, #8] <== NOT EXECUTED
p->avl.left = p2->avl.right;
p2->avl.right = p;
a9cc: e58c300c str r3, [ip, #12] <== NOT EXECUTED
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
a9d0: e5832008 str r2, [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;
a9d4: e1dc31d1 ldrsb r3, [ip, #17] <== NOT EXECUTED
a9d8: e3530001 cmp r3, #1 <== NOT EXECUTED
a9dc: 05c05011 strbeq r5, [r0, #17] <== NOT EXECUTED
a9e0: 15c01011 strbne r1, [r0, #17] <== NOT EXECUTED
}
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
a9e4: e1a0200c mov r2, ip <== 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;
a9e8: e5cc1011 strb r1, [ip, #17] <== NOT EXECUTED
a9ec: ea000000 b a9f4 <rtems_bdbuf_remove_from_tree+0x2f8> <== NOT EXECUTED
a9f0: e1a02003 mov r2, r3
a9f4: e3a03001 mov r3, #1
default:
break;
}
}
if (buf_prev > buf_stack)
a9f8: e1560007 cmp r6, r7
a9fc: 9a000007 bls aa20 <rtems_bdbuf_remove_from_tree+0x324>
{
q = *(buf_prev - 1);
aa00: e5160004 ldr r0, [r6, #-4] <== NOT EXECUTED
if (q->avl.cache == -1)
aa04: e1d0c1d0 ldrsb ip, [r0, #16] <== NOT EXECUTED
aa08: e37c0001 cmn ip, #1 <== NOT EXECUTED
{
q->avl.left = p;
aa0c: 05802008 streq r2, [r0, #8] <== NOT EXECUTED
}
else
{
q->avl.right = p;
aa10: 1580200c strne r2, [r0, #12] <== NOT EXECUTED
*root = q;
}
modified = true;
while (modified)
aa14: e3530000 cmp r3, #0 <== NOT EXECUTED
aa18: 1affff9b bne a88c <rtems_bdbuf_remove_from_tree+0x190> <== NOT EXECUTED
aa1c: ea000007 b aa40 <rtems_bdbuf_remove_from_tree+0x344> <== NOT EXECUTED
q->avl.right = p;
}
}
else
{
*root = p;
aa20: e59f3020 ldr r3, [pc, #32] ; aa48 <rtems_bdbuf_remove_from_tree+0x34c>
aa24: e5832040 str r2, [r3, #64] ; 0x40
aa28: ea000004 b aa40 <rtems_bdbuf_remove_from_tree+0x344>
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);
aa2c: e5950024 ldr r0, [r5, #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);
aa30: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
aa34: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
aa38: e3800009 orr r0, r0, #9 <== NOT EXECUTED
aa3c: ebffefbe bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
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);
}
aa40: e28dd080 add sp, sp, #128 ; 0x80
aa44: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
0000aa4c <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)
aa4c: e5903024 ldr r3, [r0, #36] ; 0x24
aa50: 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)
{
aa54: e92d4010 push {r4, lr}
aa58: e1a04000 mov r4, r0
switch (bd->state)
aa5c: 0a000008 beq aa84 <rtems_bdbuf_remove_from_tree_and_lru_list+0x38>
aa60: e3530002 cmp r3, #2
aa64: 1a000001 bne aa70 <rtems_bdbuf_remove_from_tree_and_lru_list+0x24>
{
case RTEMS_BDBUF_STATE_FREE:
break;
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_remove_from_tree (bd);
aa68: ebffff23 bl a6fc <rtems_bdbuf_remove_from_tree>
break;
aa6c: ea000004 b aa84 <rtems_bdbuf_remove_from_tree_and_lru_list+0x38>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_10);
aa70: 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);
aa74: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
aa78: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
aa7c: e3800008 orr r0, r0, #8 <== NOT EXECUTED
aa80: ebffefad bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
aa84: e1a00004 mov r0, r4
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_10);
}
rtems_chain_extract (&bd->link);
}
aa88: e8bd4010 pop {r4, lr}
aa8c: eafff0d6 b 6dec <_Chain_Extract>
0000b0a4 <rtems_bdbuf_swapout_task>:
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
b0a4: 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;;
b0a8: e59f42f8 ldr r4, [pc, #760] ; b3a8 <rtems_bdbuf_swapout_task+0x304>
b0ac: e594200c ldr r2, [r4, #12]
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
b0b0: e24dd034 sub sp, sp, #52 ; 0x34
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;;
b0b4: e58d2008 str r2, [sp, #8]
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
b0b8: ebfffd7b bl a6ac <rtems_bdbuf_swapout_writereq_alloc>
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
b0bc: e59dc008 ldr ip, [sp, #8]
b0c0: e59f22e4 ldr r2, [pc, #740] ; b3ac <rtems_bdbuf_swapout_task+0x308>
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
b0c4: e28d3010 add r3, sp, #16
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 ();
b0c8: e58d0028 str r0, [sp, #40] ; 0x28
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
b0cc: e3a00ffa mov r0, #1000 ; 0x3e8
b0d0: e592100c ldr r1, [r2, #12]
the_chain->permanent_null = NULL;
b0d4: e3a05000 mov r5, #0
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
b0d8: e2832004 add r2, r3, #4
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;
b0dc: e3e0a000 mvn sl, #0
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
b0e0: e000009c mul r0, ip, r0
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;
b0e4: e3e09000 mvn r9, #0
b0e8: e58d2010 str r2, [sp, #16]
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
b0ec: e58d3018 str r3, [sp, #24]
b0f0: e58d901c str r9, [sp, #28]
b0f4: e58da020 str sl, [sp, #32]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
b0f8: e58d5014 str r5, [sp, #20]
transfer.syncing = false;
b0fc: e5cd5024 strb r5, [sp, #36] ; 0x24
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
b100: eb003cb2 bl 1a3d0 <__aeabi_uidiv>
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;
b104: e1a0800a mov r8, sl
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
b108: e58d000c str r0, [sp, #12]
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;
b10c: e3a0a001 mov sl, #1
rtems_bdbuf_swapout_workers_open (void)
{
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
b110: ebfffad9 bl 9c7c <rtems_bdbuf_lock_cache>
b114: e1a06005 mov r6, r5
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),
(bdbuf_config.swapout_priority ?
b118: e5947008 ldr r7, [r4, #8]
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
b11c: e594b014 ldr fp, [r4, #20]
b120: ea000028 b b1c8 <rtems_bdbuf_swapout_task+0x124>
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
b124: e3a00030 mov r0, #48 ; 0x30 <== NOT EXECUTED
b128: ebffdfef bl 30ec <malloc> <== NOT EXECUTED
if (!worker)
b12c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
b130: 059f0278 ldreq r0, [pc, #632] ; b3b0 <rtems_bdbuf_swapout_task+0x30c><== NOT EXECUTED
b134: 0a00001a beq b1a4 <rtems_bdbuf_swapout_task+0x100> <== 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 );
b138: e1a01004 mov r1, r4 <== NOT EXECUTED
b13c: e59f0270 ldr r0, [pc, #624] ; b3b4 <rtems_bdbuf_swapout_task+0x310><== NOT EXECUTED
b140: ebffef1e bl 6dc0 <_Chain_Append> <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
b144: e5c4a00c strb sl, [r4, #12] <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
b148: ebfffd57 bl a6ac <rtems_bdbuf_swapout_writereq_alloc> <== NOT EXECUTED
b14c: 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),
b150: e59f0260 ldr r0, [pc, #608] ; b3b8 <rtems_bdbuf_swapout_task+0x314><== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
b154: e2841014 add r1, r4, #20 <== NOT EXECUTED
b158: e3570000 cmp r7, #0 <== NOT EXECUTED
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
b15c: e2842010 add r2, r4, #16 <== NOT EXECUTED
b160: e2853061 add r3, r5, #97 ; 0x61 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
b164: e5841010 str r1, [r4, #16] <== NOT EXECUTED
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
b168: e5842018 str r2, [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;
b16c: e5846014 str r6, [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;
b170: e584901c str r9, [r4, #28] <== NOT EXECUTED
b174: e5848020 str r8, [r4, #32] <== NOT EXECUTED
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
b178: e1830000 orr r0, r3, r0 <== NOT EXECUTED
b17c: 11a01007 movne r1, r7 <== NOT EXECUTED
b180: 03a0100f moveq r1, #15 <== NOT EXECUTED
b184: e284c008 add ip, r4, #8 <== NOT EXECUTED
b188: e3a02a02 mov r2, #8192 ; 0x2000 <== NOT EXECUTED
b18c: e3a03b01 mov r3, #1024 ; 0x400 <== NOT EXECUTED
b190: e88d1040 stm sp, {r6, ip} <== NOT EXECUTED
b194: ebffece7 bl 6538 <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)
b198: e3500000 cmp r0, #0 <== NOT EXECUTED
b19c: 0a000001 beq b1a8 <rtems_bdbuf_swapout_task+0x104> <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
b1a0: e59f0214 ldr r0, [pc, #532] ; b3bc <rtems_bdbuf_swapout_task+0x318><== NOT EXECUTED
b1a4: ebffede4 bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
sc = rtems_task_start (worker->id,
b1a8: e1a02004 mov r2, r4 <== NOT EXECUTED
b1ac: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
b1b0: e59f1208 ldr r1, [pc, #520] ; b3c0 <rtems_bdbuf_swapout_task+0x31c><== NOT EXECUTED
b1b4: ebffed6f bl 6778 <rtems_task_start> <== NOT EXECUTED
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
b1b8: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
b1bc: 159f0200 ldrne r0, [pc, #512] ; b3c4 <rtems_bdbuf_swapout_task+0x320><== NOT EXECUTED
b1c0: 1afffff7 bne b1a4 <rtems_bdbuf_swapout_task+0x100> <== NOT EXECUTED
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
b1c4: e2855001 add r5, r5, #1 <== NOT EXECUTED
b1c8: e155000b cmp r5, fp
b1cc: 3affffd4 bcc b124 <rtems_bdbuf_swapout_task+0x80>
* 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)
b1d0: e3a0b000 mov fp, #0
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
}
rtems_bdbuf_unlock_cache ();
b1d4: ebfffb21 bl 9e60 <rtems_bdbuf_unlock_cache>
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
b1d8: e59f51e8 ldr r5, [pc, #488] ; b3c8 <rtems_bdbuf_swapout_task+0x324>
* 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)
b1dc: e28d9010 add r9, sp, #16
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
b1e0: ea000059 b b34c <rtems_bdbuf_swapout_task+0x2a8>
b1e4: e3a07001 mov r7, #1
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
b1e8: ebfffaa3 bl 9c7c <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)
b1ec: e5d53030 ldrb r3, [r5, #48] ; 0x30
b1f0: e3530000 cmp r3, #0
b1f4: 13a06000 movne r6, #0
b1f8: 1a000004 bne b210 <rtems_bdbuf_swapout_task+0x16c>
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
b1fc: e59f01b0 ldr r0, [pc, #432] ; b3b4 <rtems_bdbuf_swapout_task+0x310>
b200: ebffef02 bl 6e10 <_Chain_Get>
worker = NULL;
else
{
worker = (rtems_bdbuf_swapout_worker*)
rtems_chain_get (&bdbuf_cache.swapout_workers);
if (worker)
b204: e2506000 subs r6, r0, #0
transfer = &worker->transfer;
b208: 12864010 addne r4, r6, #16
worker = NULL;
else
{
worker = (rtems_bdbuf_swapout_worker*)
rtems_chain_get (&bdbuf_cache.swapout_workers);
if (worker)
b20c: 1a000000 bne b214 <rtems_bdbuf_swapout_task+0x170>
b210: e1a04009 mov r4, r9
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dev = BDBUF_INVALID_DEV;
transfer->syncing = bdbuf_cache.sync_active;
b214: e5d53030 ldrb r3, [r5, #48] ; 0x30
b218: 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)
b21c: e5d53030 ldrb r3, [r5, #48] ; 0x30
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
b220: e284a004 add sl, r4, #4
b224: e3530000 cmp r3, #0
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dev = BDBUF_INVALID_DEV;
b228: e3e02000 mvn r2, #0
b22c: e3e03000 mvn r3, #0
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
b230: e8840c00 stm r4, {sl, fp}
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
b234: e5844008 str r4, [r4, #8]
b238: e584200c str r2, [r4, #12]
b23c: e5843010 str r3, [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;
b240: 12853038 addne r3, r5, #56 ; 0x38
b244: 1893000c ldmne r3, {r2, r3}
b248: 1584200c strne r2, [r4, #12]
b24c: 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,
b250: e3a0c000 mov ip, #0
b254: e284800c add r8, r4, #12
b258: e58dc000 str ip, [sp]
b25c: e59dc008 ldr ip, [sp, #8]
b260: e1a02004 mov r2, r4
b264: e1a00008 mov r0, r8
b268: e59f115c ldr r1, [pc, #348] ; b3cc <rtems_bdbuf_swapout_task+0x328>
b26c: e3a03001 mov r3, #1
b270: e58dc004 str ip, [sp, #4]
b274: ebfffa91 bl 9cc0 <rtems_bdbuf_swapout_modified_processing>
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dev,
b278: e59dc008 ldr ip, [sp, #8]
&bdbuf_cache.modified,
&transfer->bds,
bdbuf_cache.sync_active,
b27c: e5d53030 ldrb r3, [r5, #48] ; 0x30
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dev,
b280: e1a02004 mov r2, r4
b284: e1a00008 mov r0, r8
b288: e59f1140 ldr r1, [pc, #320] ; b3d0 <rtems_bdbuf_swapout_task+0x32c>
b28c: e88d1080 stm sp, {r7, ip}
b290: ebfffa8a bl 9cc0 <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 ();
b294: ebfffaf1 bl 9e60 <rtems_bdbuf_unlock_cache>
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
b298: e5943000 ldr r3, [r4]
b29c: e153000a cmp r3, sl
b2a0: 03a04000 moveq r4, #0
b2a4: 0a00000b beq b2d8 <rtems_bdbuf_swapout_task+0x234>
{
if (worker)
b2a8: e3560000 cmp r6, #0
b2ac: 0a000006 beq b2cc <rtems_bdbuf_swapout_task+0x228>
{
rtems_status_code sc = rtems_event_send (worker->id,
b2b0: e5960008 ldr r0, [r6, #8] <== NOT EXECUTED
b2b4: e3a01004 mov r1, #4 <== NOT EXECUTED
b2b8: ebffeb1e bl 5f38 <rtems_event_send> <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
b2bc: e3500000 cmp r0, #0 <== NOT EXECUTED
b2c0: 0a000003 beq b2d4 <rtems_bdbuf_swapout_task+0x230> <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
b2c4: e59f0108 ldr r0, [pc, #264] ; b3d4 <rtems_bdbuf_swapout_task+0x330><== NOT EXECUTED
b2c8: eaffffb5 b b1a4 <rtems_bdbuf_swapout_task+0x100> <== NOT EXECUTED
}
else
{
rtems_bdbuf_swapout_write (transfer);
b2cc: e1a00004 mov r0, r4
b2d0: ebffff14 bl af28 <rtems_bdbuf_swapout_write>
b2d4: e3a04001 mov r4, #1
}
transfered_buffers = true;
}
if (bdbuf_cache.sync_active && !transfered_buffers)
b2d8: e5d57030 ldrb r7, [r5, #48] ; 0x30
b2dc: e21770ff ands r7, r7, #255 ; 0xff
b2e0: e59f60e0 ldr r6, [pc, #224] ; b3c8 <rtems_bdbuf_swapout_task+0x324>
b2e4: 0a00000d beq b320 <rtems_bdbuf_swapout_task+0x27c>
b2e8: e3540000 cmp r4, #0
b2ec: e3a07000 mov r7, #0
b2f0: 1affffbc bne b1e8 <rtems_bdbuf_swapout_task+0x144>
{
rtems_id sync_requester;
rtems_bdbuf_lock_cache ();
b2f4: ebfffa60 bl 9c7c <rtems_bdbuf_lock_cache>
sync_requester = bdbuf_cache.sync_requester;
b2f8: e5967034 ldr r7, [r6, #52] ; 0x34
bdbuf_cache.sync_active = false;
b2fc: e5c64030 strb r4, [r6, #48] ; 0x30
bdbuf_cache.sync_requester = 0;
b300: e5864034 str r4, [r6, #52] ; 0x34
rtems_bdbuf_unlock_cache ();
b304: ebfffad5 bl 9e60 <rtems_bdbuf_unlock_cache>
if (sync_requester)
b308: e3570000 cmp r7, #0
b30c: 0a000005 beq b328 <rtems_bdbuf_swapout_task+0x284>
rtems_event_send (sync_requester, RTEMS_BDBUF_TRANSFER_SYNC);
b310: e1a00007 mov r0, r7
b314: e3a01002 mov r1, #2
b318: ebffeb06 bl 5f38 <rtems_event_send>
b31c: ea000001 b b328 <rtems_bdbuf_swapout_task+0x284>
/*
* 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,
b320: e3540000 cmp r4, #0
b324: 1affffaf bne b1e8 <rtems_bdbuf_swapout_task+0x144>
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
b328: e3a00004 mov r0, #4
b32c: e3a01000 mov r1, #0
b330: e59d200c ldr r2, [sp, #12]
b334: e28d3030 add r3, sp, #48 ; 0x30
b338: ebffeaa2 bl 5dc8 <rtems_event_receive>
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
b33c: e3500006 cmp r0, #6
b340: 13500000 cmpne r0, #0
rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);
b344: 159f008c ldrne r0, [pc, #140] ; b3d8 <rtems_bdbuf_swapout_task+0x334>
b348: 1affff95 bne b1a4 <rtems_bdbuf_swapout_task+0x100>
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
b34c: e5d53004 ldrb r3, [r5, #4]
b350: e21330ff ands r3, r3, #255 ; 0xff
b354: e59f406c ldr r4, [pc, #108] ; b3c8 <rtems_bdbuf_swapout_task+0x324>
b358: 1affffa1 bne b1e4 <rtems_bdbuf_swapout_task+0x140>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
b35c: e284600c add r6, r4, #12 <== NOT EXECUTED
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
b360: e1a05003 mov r5, r3 <== NOT EXECUTED
static void
rtems_bdbuf_swapout_workers_close (void)
{
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
b364: ebfffa44 bl 9c7c <rtems_bdbuf_lock_cache> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return the_chain->first;
b368: e5944008 ldr r4, [r4, #8] <== NOT EXECUTED
b36c: ea000004 b b384 <rtems_bdbuf_swapout_task+0x2e0> <== NOT EXECUTED
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
b370: e5c4500c strb r5, [r4, #12] <== NOT EXECUTED
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
b374: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
b378: e3a01004 mov r1, #4 <== NOT EXECUTED
b37c: ebffeaed bl 5f38 <rtems_event_send> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
b380: e5944000 ldr r4, [r4] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
b384: e1540006 cmp r4, r6 <== NOT EXECUTED
b388: 1afffff8 bne b370 <rtems_bdbuf_swapout_task+0x2cc> <== NOT EXECUTED
node = rtems_chain_next (node);
}
rtems_bdbuf_unlock_cache ();
b38c: ebfffab3 bl 9e60 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);
}
rtems_bdbuf_swapout_workers_close ();
free (transfer.write_req);
b390: e59d0028 ldr r0, [sp, #40] ; 0x28 <== NOT EXECUTED
b394: ebffde88 bl 2dbc <free> <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
b398: e3a00000 mov r0, #0 <== NOT EXECUTED
b39c: ebffecb7 bl 6680 <rtems_task_delete> <== NOT EXECUTED
}
b3a0: e28dd034 add sp, sp, #52 ; 0x34 <== NOT EXECUTED
b3a4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0000b3dc <rtems_bdbuf_swapout_worker_task>:
* @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)
{
b3dc: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
b3e0: e1a04000 mov r4, r0 <== NOT EXECUTED
while (worker->enabled)
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
rtems_bdbuf_swapout_write (&worker->transfer);
b3e4: e2805010 add r5, r0, #16 <== NOT EXECUTED
b3e8: 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;
b3ec: e3a08000 mov r8, #0 <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
b3f0: e3e06000 mvn r6, #0 <== NOT EXECUTED
b3f4: e3e07000 mvn r7, #0 <== 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)
b3f8: ea00000c b b430 <rtems_bdbuf_swapout_worker_task+0x54> <== NOT EXECUTED
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
b3fc: ebfffb2f bl a0c0 <rtems_bdbuf_wait_for_event> <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
b400: e1a00005 mov r0, r5 <== NOT EXECUTED
b404: ebfffec7 bl af28 <rtems_bdbuf_swapout_write> <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
b408: ebfffa1b bl 9c7c <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 );
b40c: e59f0048 ldr r0, [pc, #72] ; b45c <rtems_bdbuf_swapout_worker_task+0x80><== NOT EXECUTED
b410: e1a01004 mov r1, r4 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
b414: e584a010 str sl, [r4, #16] <== NOT EXECUTED
the_chain->permanent_null = NULL;
b418: e5848014 str r8, [r4, #20] <== NOT EXECUTED
the_chain->last = _Chain_Head(the_chain);
b41c: e5845018 str r5, [r4, #24] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
b420: e584601c str r6, [r4, #28] <== NOT EXECUTED
b424: e5847020 str r7, [r4, #32] <== NOT EXECUTED
b428: ebffee64 bl 6dc0 <_Chain_Append> <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
b42c: ebfffa8b bl 9e60 <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)
b430: e5d4900c ldrb r9, [r4, #12] <== NOT EXECUTED
b434: e21990ff ands r9, r9, #255 ; 0xff <== NOT EXECUTED
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
b438: e3a00004 mov r0, #4 <== 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)
b43c: 1affffee bne b3fc <rtems_bdbuf_swapout_worker_task+0x20> <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
}
free (worker->transfer.write_req);
b440: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
b444: ebffde5c bl 2dbc <free> <== NOT EXECUTED
free (worker);
b448: e1a00004 mov r0, r4 <== NOT EXECUTED
b44c: ebffde5a bl 2dbc <free> <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
b450: e1a00009 mov r0, r9 <== NOT EXECUTED
}
b454: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
}
free (worker->transfer.write_req);
free (worker);
rtems_task_delete (RTEMS_SELF);
b458: eaffec88 b 6680 <rtems_task_delete> <== NOT EXECUTED
0000af28 <rtems_bdbuf_swapout_write>:
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))
af28: e5903000 ldr r3, [r0]
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
af2c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
af30: e2807004 add r7, r0, #4
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))
af34: e1530007 cmp r3, r7
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
af38: 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))
af3c: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* 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);
af40: e280100c add r1, r0, #12
af44: e8910003 ldm r1, {r0, r1}
af48: ebffdbcf bl 1e8c <rtems_disk_obtain>
if (dd == NULL)
dd = &null_disk;
bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;
af4c: e59f9148 ldr r9, [pc, #328] ; b09c <rtems_bdbuf_swapout_write+0x174>
* 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)
af50: e3500000 cmp r0, #0
af54: e59f5144 ldr r5, [pc, #324] ; b0a0 <rtems_bdbuf_swapout_write+0x178>
af58: 11a05000 movne r5, r0
dd = &null_disk;
bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;
af5c: e5950020 ldr r0, [r5, #32]
af60: e5991020 ldr r1, [r9, #32]
af64: eb003d19 bl 1a3d0 <__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;
af68: e5943018 ldr r3, [r4, #24]
transfer->write_req->bufnum = 0;
af6c: 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;
af70: e3a0800c mov r8, #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))
af74: e599b004 ldr fp, [r9, #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;
af78: e1a0a000 mov sl, 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))
af7c: e1a06002 mov r6, r2
* 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;
transfer->write_req->bufnum = 0;
af80: 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;
af84: e583800c str r8, [r3, #12]
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
buf->length = dd->block_size;
buf->buffer = bd->buffer;
last_block = bd->block;
af88: e1a09002 mov r9, r2
* 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)
af8c: ea00002f b b050 <rtems_bdbuf_swapout_write+0x128>
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) &&
af90: e5953008 ldr r3, [r5, #8]
af94: e593300c ldr r3, [r3, #12]
af98: e3130001 tst r3, #1
af9c: 0a00000c beq afd4 <rtems_bdbuf_swapout_write+0xac>
transfer->write_req->bufnum &&
afa0: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED
afa4: e5931010 ldr r1, [r3, #16] <== NOT EXECUTED
afa8: e3510000 cmp r1, #0 <== NOT EXECUTED
(bd->block != (last_block + bufs_per_bd)))
afac: e086300a add r3, r6, sl <== NOT EXECUTED
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) &&
transfer->write_req->bufnum &&
afb0: 0a000007 beq afd4 <rtems_bdbuf_swapout_write+0xac> <== NOT EXECUTED
(bd->block != (last_block + bufs_per_bd)))
afb4: e592101c ldr r1, [r2, #28] <== NOT EXECUTED
afb8: e1510003 cmp r1, r3 <== NOT EXECUTED
afbc: 0a000004 beq afd4 <rtems_bdbuf_swapout_write+0xac> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
afc0: e1a01002 mov r1, r2 <== NOT EXECUTED
afc4: e1a00004 mov r0, r4 <== NOT EXECUTED
afc8: eb000e94 bl ea20 <_Chain_Insert> <== NOT EXECUTED
afcc: e3a03001 mov r3, #1 <== 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) &&
afd0: ea00000e b b010 <rtems_bdbuf_swapout_write+0xe8> <== NOT EXECUTED
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
afd4: e5943018 ldr r3, [r4, #24]
afd8: e5930010 ldr r0, [r3, #16]
transfer->write_req->bufnum++;
afdc: e2801001 add r1, r0, #1
afe0: e5831010 str r1, [r3, #16]
buf->user = bd;
buf->block = bd->block;
afe4: 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;
afe8: e0831200 add r1, r3, r0, lsl #4
buf->block = bd->block;
afec: e581c018 str ip, [r1, #24]
buf->length = dd->block_size;
aff0: e595c020 ldr ip, [r5, #32]
aff4: e581c01c str ip, [r1, #28]
buf->buffer = bd->buffer;
aff8: e592c020 ldr ip, [r2, #32]
affc: e2800002 add r0, r0, #2
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
b000: e5812024 str r2, [r1, #36] ; 0x24
buf->block = bd->block;
buf->length = dd->block_size;
buf->buffer = bd->buffer;
last_block = bd->block;
b004: 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;
b008: e783c200 str ip, [r3, r0, lsl #4]
last_block = bd->block;
b00c: e3a03000 mov r3, #0
/*
* 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) ||
b010: e5942000 ldr r2, [r4]
b014: e1520007 cmp r2, r7
b018: 0a000005 beq b034 <rtems_bdbuf_swapout_write+0x10c>
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
b01c: e5942018 ldr r2, [r4, #24]
b020: e5922010 ldr r2, [r2, #16]
b024: e152000b cmp r2, fp
b028: 2a000001 bcs b034 <rtems_bdbuf_swapout_write+0x10c>
write = true;
if (write)
b02c: e3530000 cmp r3, #0
b030: 0a000006 beq b050 <rtems_bdbuf_swapout_write+0x128>
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
b034: e1a00005 mov r0, r5
b038: e5941018 ldr r1, [r4, #24]
b03c: e3a02000 mov r2, #0
b040: ebffff77 bl ae24 <rtems_bdbuf_execute_transfer_request>
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
b044: e5943018 ldr r3, [r4, #24]
transfer->write_req->bufnum = 0;
b048: 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;
b04c: e583800c str r8, [r3, #12]
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
b050: e1a00004 mov r0, r4
b054: ebffef6d bl 6e10 <_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)
b058: e2502000 subs r2, r0, #0
b05c: 1affffcb bne af90 <rtems_bdbuf_swapout_write+0x68>
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
}
}
if (dd != &null_disk)
b060: e59f3038 ldr r3, [pc, #56] ; b0a0 <rtems_bdbuf_swapout_write+0x178>
b064: e1550003 cmp r5, r3
b068: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
b06c: e5d43014 ldrb r3, [r4, #20]
b070: e3530000 cmp r3, #0
b074: 0a000005 beq b090 <rtems_bdbuf_swapout_write+0x168>
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
b078: 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 &&
b07c: e590300c ldr r3, [r0, #12]
b080: e3130002 tst r3, #2
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
b084: 13a01002 movne r1, #2
b088: 11a0e00f movne lr, pc
b08c: 1595f028 ldrne pc, [r5, #40] ; 0x28
/* How should the error be handled ? */
}
rtems_disk_release (dd);
b090: e1a00005 mov r0, r5
}
}
}
b094: 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);
b098: eaffdbf7 b 207c <rtems_disk_release>
0000b460 <rtems_bdbuf_sync>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
b460: 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)
b464: e59f514c ldr r5, [pc, #332] ; b5b8 <rtems_bdbuf_sync+0x158>
b468: e5d53088 ldrb r3, [r5, #136] ; 0x88
b46c: e3530000 cmp r3, #0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
b470: e1a04000 mov r4, r0
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
b474: 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)
b478: 08bd8030 popeq {r4, r5, pc}
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
b47c: e3540000 cmp r4, #0
b480: 03a00009 moveq r0, #9
b484: 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();
b488: ebfff9fb bl 9c7c <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
b48c: e5943024 ldr r3, [r4, #36] ; 0x24
b490: e3530003 cmp r3, #3
b494: 3a00003f bcc b598 <rtems_bdbuf_sync+0x138>
b498: e3530005 cmp r3, #5
b49c: 9a000002 bls b4ac <rtems_bdbuf_sync+0x4c>
b4a0: e3530006 cmp r3, #6
b4a4: 1a00003b bne b598 <rtems_bdbuf_sync+0x138>
b4a8: ea000037 b b58c <rtems_bdbuf_sync+0x12c>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
b4ac: e3a03008 mov r3, #8
b4b0: e5843024 str r3, [r4, #36] ; 0x24
b4b4: e285005c add r0, r5, #92 ; 0x5c
b4b8: e1a01004 mov r1, r4
b4bc: ebffee3f bl 6dc0 <_Chain_Append>
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
b4c0: e5943028 ldr r3, [r4, #40] ; 0x28
b4c4: e3530000 cmp r3, #0
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
b4c8: 12850068 addne r0, r5, #104 ; 0x68
b4cc: 1bfff9f0 blne 9c94 <rtems_bdbuf_wake>
rtems_bdbuf_wake_swapper ();
b4d0: ebfffaba bl 9fc0 <rtems_bdbuf_wake_swapper>
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
b4d4: e5943024 ldr r3, [r4, #36] ; 0x24
b4d8: e2433001 sub r3, r3, #1
b4dc: e3530009 cmp r3, #9
b4e0: 979ff103 ldrls pc, [pc, r3, lsl #2]
b4e4: ea00000d b b520 <rtems_bdbuf_sync+0xc0> <== NOT EXECUTED
b4e8: 0000b534 .word 0x0000b534 <== NOT EXECUTED
b4ec: 0000b534 .word 0x0000b534 <== NOT EXECUTED
b4f0: 0000b534 .word 0x0000b534 <== NOT EXECUTED
b4f4: 0000b534 .word 0x0000b534 <== NOT EXECUTED
b4f8: 0000b534 .word 0x0000b534 <== NOT EXECUTED
b4fc: 0000b534 .word 0x0000b534 <== NOT EXECUTED
b500: 0000b534 .word 0x0000b534 <== NOT EXECUTED
b504: 0000b510 .word 0x0000b510 <== NOT EXECUTED
b508: 0000b510 .word 0x0000b510 <== NOT EXECUTED
b50c: 0000b510 .word 0x0000b510 <== 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);
b510: e1a00004 mov r0, r4
b514: e59f10a0 ldr r1, [pc, #160] ; b5bc <rtems_bdbuf_sync+0x15c>
b518: ebfffb51 bl a264 <rtems_bdbuf_wait>
b51c: eaffffec b b4d4 <rtems_bdbuf_sync+0x74>
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_9);
b520: 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);
b524: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
b528: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
b52c: e3800007 orr r0, r0, #7 <== NOT EXECUTED
b530: ea00001c b b5a8 <rtems_bdbuf_sync+0x148> <== NOT EXECUTED
/*
* We may have created a cached or empty buffer which may be recycled.
*/
if (bd->waiters == 0
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
b534: 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
b538: e3530000 cmp r3, #0
b53c: 1a00001a bne b5ac <rtems_bdbuf_sync+0x14c>
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
b540: 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
b544: e3530002 cmp r3, #2
b548: 0a000002 beq b558 <rtems_bdbuf_sync+0xf8>
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
b54c: 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
b550: e3530001 cmp r3, #1
b554: 1a000014 bne b5ac <rtems_bdbuf_sync+0x14c>
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
b558: e5943024 ldr r3, [r4, #36] ; 0x24
b55c: e3530001 cmp r3, #1
b560: 1a000006 bne b580 <rtems_bdbuf_sync+0x120>
{
rtems_bdbuf_remove_from_tree (bd);
b564: e1a00004 mov r0, r4
b568: ebfffc63 bl a6fc <rtems_bdbuf_remove_from_tree>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
b56c: e3a03000 mov r3, #0
b570: 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);
b574: e1a01004 mov r1, r4
b578: e59f0040 ldr r0, [pc, #64] ; b5c0 <rtems_bdbuf_sync+0x160>
b57c: eb000d27 bl ea20 <_Chain_Insert>
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
{
rtems_bdbuf_remove_from_tree (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
}
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
b580: e59f003c ldr r0, [pc, #60] ; b5c4 <rtems_bdbuf_sync+0x164>
b584: ebfff9c2 bl 9c94 <rtems_bdbuf_wake>
b588: ea000007 b b5ac <rtems_bdbuf_sync+0x14c>
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);
b58c: e1a00004 mov r0, r4
b590: ebfffd4c bl aac8 <rtems_bdbuf_discard_buffer_after_access>
break;
b594: ea000004 b b5ac <rtems_bdbuf_sync+0x14c>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_5);
b598: 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);
b59c: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
b5a0: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
b5a4: e3800003 orr r0, r0, #3 <== NOT EXECUTED
b5a8: ebffece3 bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
b5ac: ebfffa2b bl 9e60 <rtems_bdbuf_unlock_cache>
b5b0: e3a00000 mov r0, #0
return RTEMS_SUCCESSFUL;
}
b5b4: e8bd8030 pop {r4, r5, pc}
00009e60 <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);
9e60: e59f3018 ldr r3, [pc, #24] ; 9e80 <rtems_bdbuf_unlock_cache+0x20>
/**
* Unlock the cache.
*/
static void
rtems_bdbuf_unlock_cache (void)
{
9e64: 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);
9e68: e5930028 ldr r0, [r3, #40] ; 0x28
9e6c: ebfff18a bl 649c <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
9e70: e3500000 cmp r0, #0
9e74: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_fatal_error_occurred (fatal_error_code);
9e78: e59f0004 ldr r0, [pc, #4] ; 9e84 <rtems_bdbuf_unlock_cache+0x24><== NOT EXECUTED
9e7c: ebfff2ae bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
00009e88 <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);
9e88: e59f3018 ldr r3, [pc, #24] ; 9ea8 <rtems_bdbuf_unlock_sync+0x20>
/**
* Unlock the cache's sync lock. Any blocked writers are woken.
*/
static void
rtems_bdbuf_unlock_sync (void)
{
9e8c: 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);
9e90: e593002c ldr r0, [r3, #44] ; 0x2c
9e94: ebfff180 bl 649c <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
9e98: e3500000 cmp r0, #0
9e9c: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_fatal_error_occurred (fatal_error_code);
9ea0: e59f0004 ldr r0, [pc, #4] ; 9eac <rtems_bdbuf_unlock_sync+0x24><== NOT EXECUTED
9ea4: ebfff2a4 bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
0000a0c0 <rtems_bdbuf_wait_for_event>:
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
a0c0: e92d4011 push {r0, r4, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
a0c4: e3a01000 mov r1, #0
a0c8: e28d3004 add r3, sp, #4
a0cc: e5231004 str r1, [r3, #-4]!
sc = rtems_event_receive (event,
a0d0: e1a02001 mov r2, r1
a0d4: e1a0300d mov r3, sp
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
a0d8: e1a04000 mov r4, r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
sc = rtems_event_receive (event,
a0dc: ebffef39 bl 5dc8 <rtems_event_receive>
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
a0e0: e3500000 cmp r0, #0
a0e4: 1a000002 bne a0f4 <rtems_bdbuf_wait_for_event+0x34>
a0e8: e59d3000 ldr r3, [sp]
a0ec: e1530004 cmp r3, r4
a0f0: 0a000001 beq a0fc <rtems_bdbuf_wait_for_event+0x3c>
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_WAIT_EVNT);
a0f4: e59f0004 ldr r0, [pc, #4] ; a100 <rtems_bdbuf_wait_for_event+0x40><== NOT EXECUTED
a0f8: ebfff20f bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
a0fc: e8bd8018 pop {r3, r4, pc}
00009c94 <rtems_bdbuf_wake>:
static void
rtems_bdbuf_wake (const rtems_bdbuf_waiters *waiters)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
9c94: e5903000 ldr r3, [r0]
9c98: 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)
{
9c9c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
9ca0: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
{
sc = rtems_semaphore_flush (waiters->sema);
9ca4: e5900004 ldr r0, [r0, #4]
9ca8: eb001215 bl e504 <rtems_semaphore_flush>
if (sc != RTEMS_SUCCESSFUL)
9cac: e3500000 cmp r0, #0
9cb0: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAKE);
9cb4: e59f0000 ldr r0, [pc, #0] ; 9cbc <rtems_bdbuf_wake+0x28> <== NOT EXECUTED
9cb8: ebfff31f bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
00009fc0 <rtems_bdbuf_wake_swapper>:
}
static void
rtems_bdbuf_wake_swapper (void)
{
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
9fc0: e59f301c ldr r3, [pc, #28] ; 9fe4 <rtems_bdbuf_wake_swapper+0x24>
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
9fc4: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
9fc8: e5930000 ldr r0, [r3]
9fcc: e3a01004 mov r1, #4
9fd0: ebffefd8 bl 5f38 <rtems_event_send>
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
9fd4: e3500000 cmp r0, #0
9fd8: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
9fdc: e59f0004 ldr r0, [pc, #4] ; 9fe8 <rtems_bdbuf_wake_swapper+0x28><== NOT EXECUTED
9fe0: ebfff255 bl 693c <rtems_fatal_error_occurred> <== NOT EXECUTED
000206fc <rtems_bdpart_create>:
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
206fc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
20700: e2514000 subs r4, r1, #0 <== NOT EXECUTED
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
20704: e24dd01c sub sp, sp, #28 <== NOT EXECUTED
20708: e98d000c stmib sp, {r2, r3} <== NOT EXECUTED
2070c: e59d5040 ldr r5, [sp, #64] ; 0x40 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
20710: 0a000003 beq 20724 <rtems_bdpart_create+0x28> <== NOT EXECUTED
&& format->type == RTEMS_BDPART_FORMAT_MBR
20714: e5943000 ldr r3, [r4] <== NOT EXECUTED
20718: e3530000 cmp r3, #0 <== NOT EXECUTED
2071c: 05d48008 ldrbeq r8, [r4, #8] <== NOT EXECUTED
20720: 0a000000 beq 20728 <rtems_bdpart_create+0x2c> <== NOT EXECUTED
20724: e3a08000 mov r8, #0 <== NOT EXECUTED
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
20728: e3580000 cmp r8, #0 <== NOT EXECUTED
2072c: 13a0603f movne r6, #63 ; 0x3f <== NOT EXECUTED
20730: 03a06001 moveq r6, #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) {
20734: e3550000 cmp r5, #0 <== NOT EXECUTED
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
20738: e20880ff and r8, r8, #255 ; 0xff <== 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) {
2073c: 01a07005 moveq r7, r5 <== NOT EXECUTED
20740: 0a00006a beq 208f0 <rtems_bdpart_create+0x1f4> <== NOT EXECUTED
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL || dist == NULL) {
20744: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
20748: e3540000 cmp r4, #0 <== NOT EXECUTED
2074c: 13510000 cmpne r1, #0 <== NOT EXECUTED
20750: 13a03000 movne r3, #0 <== NOT EXECUTED
20754: 03a03001 moveq r3, #1 <== NOT EXECUTED
20758: 0a000061 beq 208e4 <rtems_bdpart_create+0x1e8> <== NOT EXECUTED
2075c: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED
20760: e3520000 cmp r2, #0 <== NOT EXECUTED
20764: 0a00005e beq 208e4 <rtems_bdpart_create+0x1e8> <== 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;
20768: e3a0b000 mov fp, #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);
2076c: e28d1010 add r1, sp, #16 <== NOT EXECUTED
20770: e28d2018 add r2, sp, #24 <== 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;
20774: e3a0a000 mov sl, #0 <== NOT EXECUTED
20778: e58da010 str sl, [sp, #16] <== NOT EXECUTED
2077c: e58db014 str fp, [sp, #20] <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
20780: e58d3018 str r3, [sp, #24] <== 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);
20784: eb000163 bl 20d18 <rtems_bdpart_get_disk_data> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
20788: e2507000 subs r7, r0, #0 <== NOT EXECUTED
2078c: 01a03007 moveq r3, r7 <== NOT EXECUTED
20790: 01a0b007 moveq fp, r7 <== NOT EXECUTED
20794: 0a000007 beq 207b8 <rtems_bdpart_create+0xbc> <== NOT EXECUTED
20798: ea000054 b 208f0 <rtems_bdpart_create+0x1f4> <== NOT EXECUTED
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
unsigned prev_sum = dist_sum;
dist_sum += dist [i];
2079c: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED
207a0: e79c2103 ldr r2, [ip, r3, lsl #2] <== NOT EXECUTED
if (dist_sum < prev_sum) {
207a4: e09bb002 adds fp, fp, r2 <== NOT EXECUTED
207a8: 2a00004f bcs 208ec <rtems_bdpart_create+0x1f0> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
}
if (dist [i] == 0) {
207ac: e3520000 cmp r2, #0 <== NOT EXECUTED
207b0: 0a00004d beq 208ec <rtems_bdpart_create+0x1f0> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
207b4: e2833001 add r3, r3, #1 <== NOT EXECUTED
207b8: e1530005 cmp r3, r5 <== NOT EXECUTED
207bc: 3afffff6 bcc 2079c <rtems_bdpart_create+0xa0> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
207c0: e5943000 ldr r3, [r4] <== NOT EXECUTED
207c4: e3530000 cmp r3, #0 <== NOT EXECUTED
207c8: 13a07018 movne r7, #24 <== NOT EXECUTED
207cc: 1a000047 bne 208f0 <rtems_bdpart_create+0x1f4> <== NOT EXECUTED
return RTEMS_NOT_IMPLEMENTED;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
207d0: e3580000 cmp r8, #0 <== NOT EXECUTED
207d4: 0a000005 beq 207f0 <rtems_bdpart_create+0xf4> <== NOT EXECUTED
disk_end -= (disk_end % record_space);
207d8: e59d4018 ldr r4, [sp, #24] <== NOT EXECUTED
207dc: e1a01006 mov r1, r6 <== NOT EXECUTED
207e0: e1a00004 mov r0, r4 <== NOT EXECUTED
207e4: eb00d217 bl 55048 <__umodsi3> <== NOT EXECUTED
207e8: e0600004 rsb r0, r0, r4 <== NOT EXECUTED
207ec: e58d0018 str r0, [sp, #24] <== 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) {
207f0: e3550004 cmp r5, #4 <== NOT EXECUTED
overhead += (count - 3) * record_space;
207f4: 82453003 subhi r3, r5, #3 <== NOT EXECUTED
207f8: 802c6693 mlahi ip, r3, r6, r6 <== 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) {
207fc: 91a0c006 movls ip, r6 <== NOT EXECUTED
/*
* Account space to align every partition on cylinder boundaries if
* necessary.
*/
if (dos_compatibility) {
20800: e3580000 cmp r8, #0 <== NOT EXECUTED
overhead += (count - 1) * record_space;
20804: 12453001 subne r3, r5, #1 <== NOT EXECUTED
20808: 102cc693 mlane ip, r3, r6, ip <== NOT EXECUTED
}
/* Check disk space */
if ((overhead + count) > disk_end) {
2080c: e59d9018 ldr r9, [sp, #24] <== NOT EXECUTED
20810: e08c3005 add r3, ip, r5 <== NOT EXECUTED
20814: e1530009 cmp r3, r9 <== NOT EXECUTED
20818: 83a0701b movhi r7, #27 <== NOT EXECUTED
2081c: 8a000033 bhi 208f0 <rtems_bdpart_create+0x1f4> <== NOT EXECUTED
/* Begin of first primary partition */
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
20820: e06cc009 rsb ip, ip, r9 <== NOT EXECUTED
20824: e1a02009 mov r2, r9 <== NOT EXECUTED
20828: e59d8004 ldr r8, [sp, #4] <== NOT EXECUTED
2082c: e1a09007 mov r9, r7 <== NOT EXECUTED
20830: e1a0a006 mov sl, r6 <== NOT EXECUTED
20834: e3a04000 mov r4, #0 <== NOT EXECUTED
20838: e1a0700c mov r7, ip <== NOT EXECUTED
for (i = 0; i < count; ++i) {
2083c: ea00001b b 208b0 <rtems_bdpart_create+0x1b4> <== NOT EXECUTED
rtems_bdpart_partition *p = pt + i;
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
20840: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
20844: e793c104 ldr ip, [r3, r4, lsl #2] <== NOT EXECUTED
20848: e003079c mul r3, ip, r7 <== NOT EXECUTED
if (s < free_space || s < dist [i]) {
2084c: e1530007 cmp r3, r7 <== NOT EXECUTED
/* TODO: Calculate without overflow */
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
20850: e1a00003 mov r0, r3 <== NOT EXECUTED
for (i = 0; i < count; ++i) {
rtems_bdpart_partition *p = pt + i;
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
if (s < free_space || s < dist [i]) {
20854: 3a000024 bcc 208ec <rtems_bdpart_create+0x1f0> <== NOT EXECUTED
20858: e153000c cmp r3, ip <== NOT EXECUTED
2085c: 3a000022 bcc 208ec <rtems_bdpart_create+0x1f0> <== NOT EXECUTED
/* TODO: Calculate without overflow */
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
20860: e58d2000 str r2, [sp] <== NOT EXECUTED
20864: eb00d163 bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
/* Ensure that the partition is not empty */
if (s == 0) {
20868: e3500000 cmp r0, #0 <== NOT EXECUTED
2086c: 11a03000 movne r3, r0 <== NOT EXECUTED
20870: 03a03001 moveq r3, #1 <== NOT EXECUTED
/* Align partition upwards */
s += record_space - (s % record_space);
/* Partition begin and end */
p->begin = pos;
pos += s;
20874: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED
/* Align partition upwards */
s += record_space - (s % record_space);
/* Partition begin and end */
p->begin = pos;
20878: e588a000 str sl, [r8] <== NOT EXECUTED
pos += s;
2087c: e1a01006 mov r1, r6 <== NOT EXECUTED
20880: e1a00003 mov r0, r3 <== NOT EXECUTED
20884: e08ca003 add sl, ip, r3 <== NOT EXECUTED
20888: eb00d1ee bl 55048 <__umodsi3> <== NOT EXECUTED
p->end = pos;
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
2088c: e3540002 cmp r4, #2 <== NOT EXECUTED
20890: 83550004 cmphi r5, #4 <== NOT EXECUTED
p->begin += record_space;
20894: 859d100c ldrhi r1, [sp, #12] <== NOT EXECUTED
/* Align partition upwards */
s += record_space - (s % record_space);
/* Partition begin and end */
p->begin = pos;
pos += s;
20898: e060a00a rsb sl, r0, sl <== NOT EXECUTED
p->end = pos;
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
2089c: e59d2000 ldr r2, [sp] <== NOT EXECUTED
s += record_space - (s % record_space);
/* Partition begin and end */
p->begin = pos;
pos += s;
p->end = pos;
208a0: e588a004 str sl, [r8, #4] <== NOT EXECUTED
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
p->begin += record_space;
208a4: 85881000 strhi r1, [r8] <== NOT EXECUTED
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
208a8: e2844001 add r4, r4, #1 <== NOT EXECUTED
208ac: e2888030 add r8, r8, #48 ; 0x30 <== NOT EXECUTED
if (s == 0) {
s = 1;
}
/* Align partition upwards */
s += record_space - (s % record_space);
208b0: e08a3006 add r3, sl, r6 <== NOT EXECUTED
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
208b4: e1540005 cmp r4, r5 <== NOT EXECUTED
rtems_blkdev_bnum s = free_space * dist [i];
if (s < free_space || s < dist [i]) {
/* TODO: Calculate without overflow */
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
208b8: e1a0100b mov r1, fp <== NOT EXECUTED
if (s == 0) {
s = 1;
}
/* Align partition upwards */
s += record_space - (s % record_space);
208bc: e58d300c str r3, [sp, #12] <== NOT EXECUTED
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
208c0: 3affffde bcc 20840 <rtems_bdpart_create+0x144> <== NOT EXECUTED
p->begin += record_space;
}
}
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
208c4: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
208c8: e1a07009 mov r7, r9 <== NOT EXECUTED
208cc: e2455001 sub r5, r5, #1 <== NOT EXECUTED
208d0: e1a09002 mov r9, r2 <== NOT EXECUTED
208d4: e3a02030 mov r2, #48 ; 0x30 <== NOT EXECUTED
208d8: e0233592 mla r3, r2, r5, r3 <== NOT EXECUTED
208dc: e5839004 str r9, [r3, #4] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
208e0: ea000002 b 208f0 <rtems_bdpart_create+0x1f4> <== NOT EXECUTED
208e4: e3a07009 mov r7, #9 <== NOT EXECUTED
208e8: ea000000 b 208f0 <rtems_bdpart_create+0x1f4> <== NOT EXECUTED
208ec: e3a0700a mov r7, #10 <== NOT EXECUTED
}
208f0: e1a00007 mov r0, r7 <== NOT EXECUTED
208f4: e28dd01c add sp, sp, #28 <== NOT EXECUTED
208f8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
000208fc <rtems_bdpart_dump>:
{
uuid_unparse_lower( type, str);
}
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
208fc: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
20900: e1a04000 mov r4, r0 <== NOT EXECUTED
20904: e24dd038 sub sp, sp, #56 ; 0x38 <== NOT EXECUTED
size_t i = 0;
printf(
20908: e3a06000 mov r6, #0 <== NOT EXECUTED
2090c: e59f00e0 ldr r0, [pc, #224] ; 209f4 <rtems_bdpart_dump+0xf8><== NOT EXECUTED
{
uuid_unparse_lower( type, str);
}
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
20910: e1a07001 mov r7, r1 <== 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;
20914: e1a08006 mov r8, r6 <== NOT EXECUTED
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
size_t i = 0;
printf(
20918: eb00837b bl 4170c <puts> <== 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)) {
2091c: e28da037 add sl, sp, #55 ; 0x37 <== NOT EXECUTED
static void rtems_bdpart_type_to_string(
const uuid_t type,
char str [37]
)
{
uuid_unparse_lower( type, str);
20920: e1a0500d mov r5, sp <== NOT EXECUTED
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
20924: ea00002c b 209dc <rtems_bdpart_dump+0xe0> <== 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)) {
20928: e2849008 add r9, r4, #8 <== NOT EXECUTED
2092c: e1a00009 mov r0, r9 <== NOT EXECUTED
20930: e1a0100a mov r1, sl <== 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;
20934: e5cd8037 strb r8, [sp, #55] ; 0x37 <== NOT EXECUTED
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
20938: eb000115 bl 20d94 <rtems_bdpart_to_mbr_partition_type> <== NOT EXECUTED
2093c: e3500000 cmp r0, #0 <== NOT EXECUTED
20940: 0a00001c beq 209b8 <rtems_bdpart_dump+0xbc> <== NOT EXECUTED
switch (type_mbr) {
20944: e5dd3037 ldrb r3, [sp, #55] ; 0x37 <== NOT EXECUTED
20948: 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;
2094c: 059f30a4 ldreq r3, [pc, #164] ; 209f8 <rtems_bdpart_dump+0xfc><== 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) {
20950: 0a00001c beq 209c8 <rtems_bdpart_dump+0xcc> <== NOT EXECUTED
20954: 8a000005 bhi 20970 <rtems_bdpart_dump+0x74> <== NOT EXECUTED
20958: e3530001 cmp r3, #1 <== NOT EXECUTED
2095c: 059f3098 ldreq r3, [pc, #152] ; 209fc <rtems_bdpart_dump+0x100><== NOT EXECUTED
20960: 0a000018 beq 209c8 <rtems_bdpart_dump+0xcc> <== NOT EXECUTED
20964: e3530004 cmp r3, #4 <== NOT EXECUTED
20968: 1a00000d bne 209a4 <rtems_bdpart_dump+0xa8> <== NOT EXECUTED
2096c: ea000008 b 20994 <rtems_bdpart_dump+0x98> <== NOT EXECUTED
20970: e353000e cmp r3, #14 <== NOT EXECUTED
20974: 059f3084 ldreq r3, [pc, #132] ; 20a00 <rtems_bdpart_dump+0x104><== NOT EXECUTED
20978: 0a000012 beq 209c8 <rtems_bdpart_dump+0xcc> <== NOT EXECUTED
2097c: 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;
20980: 059f307c ldreq r3, [pc, #124] ; 20a04 <rtems_bdpart_dump+0x108><== 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) {
20984: 0a00000f beq 209c8 <rtems_bdpart_dump+0xcc> <== NOT EXECUTED
20988: e353000c cmp r3, #12 <== NOT EXECUTED
2098c: 1a000004 bne 209a4 <rtems_bdpart_dump+0xa8> <== NOT EXECUTED
20990: ea000001 b 2099c <rtems_bdpart_dump+0xa0> <== NOT EXECUTED
20994: e59f306c ldr r3, [pc, #108] ; 20a08 <rtems_bdpart_dump+0x10c><== NOT EXECUTED
20998: ea00000a b 209c8 <rtems_bdpart_dump+0xcc> <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
2099c: e59f3068 ldr r3, [pc, #104] ; 20a0c <rtems_bdpart_dump+0x110><== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
209a0: ea000008 b 209c8 <rtems_bdpart_dump+0xcc> <== NOT EXECUTED
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
209a4: e1a0000d mov r0, sp <== NOT EXECUTED
209a8: e3a01034 mov r1, #52 ; 0x34 <== NOT EXECUTED
209ac: e59f205c ldr r2, [pc, #92] ; 20a10 <rtems_bdpart_dump+0x114><== NOT EXECUTED
209b0: eb00883d bl 42aac <snprintf> <== NOT EXECUTED
209b4: ea000002 b 209c4 <rtems_bdpart_dump+0xc8> <== NOT EXECUTED
static void rtems_bdpart_type_to_string(
const uuid_t type,
char str [37]
)
{
uuid_unparse_lower( type, str);
209b8: e1a00009 mov r0, r9 <== NOT EXECUTED
209bc: e1a0100d mov r1, sp <== NOT EXECUTED
209c0: eb006159 bl 38f2c <uuid_unparse_lower> <== NOT EXECUTED
209c4: e1a0300d mov r3, sp <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
209c8: e8940006 ldm r4, {r1, r2} <== NOT EXECUTED
209cc: e59f0040 ldr r0, [pc, #64] ; 20a14 <rtems_bdpart_dump+0x118><== NOT EXECUTED
209d0: eb0082a8 bl 41478 <printf> <== NOT EXECUTED
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
209d4: e2866001 add r6, r6, #1 <== NOT EXECUTED
209d8: e2844030 add r4, r4, #48 ; 0x30 <== NOT EXECUTED
209dc: e1560007 cmp r6, r7 <== NOT EXECUTED
209e0: 3affffd0 bcc 20928 <rtems_bdpart_dump+0x2c> <== NOT EXECUTED
p->end,
type
);
}
puts( "------------+------------+-----------------------------------------------------");
209e4: e59f002c ldr r0, [pc, #44] ; 20a18 <rtems_bdpart_dump+0x11c><== NOT EXECUTED
209e8: eb008347 bl 4170c <puts> <== NOT EXECUTED
}
209ec: e28dd038 add sp, sp, #56 ; 0x38 <== NOT EXECUTED
209f0: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
00020d18 <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
)
{
20d18: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
20d1c: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED
20d20: 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);
20d24: 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
)
{
20d28: 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);
20d2c: ebffa040 bl 8e34 <stat> <== NOT EXECUTED
if (rv != 0) {
20d30: e3500000 cmp r0, #0 <== NOT EXECUTED
20d34: 1a000011 bne 20d80 <rtems_bdpart_get_disk_data+0x68> <== NOT EXECUTED
return RTEMS_INVALID_NAME;
}
*disk = st.st_rdev;
20d38: e28d1018 add r1, sp, #24 <== NOT EXECUTED
20d3c: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
20d40: e8840003 stm r4, {r0, r1} <== NOT EXECUTED
/* Get disk begin, end and block size */
dd = rtems_disk_obtain( *disk);
20d44: ebff9554 bl 629c <rtems_disk_obtain> <== NOT EXECUTED
if (dd == NULL) {
20d48: e2503000 subs r3, r0, #0 <== NOT EXECUTED
20d4c: 0a00000b beq 20d80 <rtems_bdpart_get_disk_data+0x68> <== NOT EXECUTED
return RTEMS_INVALID_NAME;
}
disk_begin = dd->start;
*disk_end = dd->size;
20d50: 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;
20d54: e5934018 ldr r4, [r3, #24] <== NOT EXECUTED
*disk_end = dd->size;
20d58: e5852000 str r2, [r5] <== NOT EXECUTED
block_size = dd->block_size;
20d5c: e5935020 ldr r5, [r3, #32] <== NOT EXECUTED
sc = rtems_disk_release( dd);
20d60: ebff95c9 bl 648c <rtems_disk_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
20d64: e3500000 cmp r0, #0 <== NOT EXECUTED
20d68: 1a000007 bne 20d8c <rtems_bdpart_get_disk_data+0x74> <== NOT EXECUTED
return sc;
}
/* Check block size */
if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
20d6c: e3550c02 cmp r5, #512 ; 0x200 <== NOT EXECUTED
20d70: 3a000004 bcc 20d88 <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) {
20d74: e3540000 cmp r4, #0 <== NOT EXECUTED
20d78: 0a000003 beq 20d8c <rtems_bdpart_get_disk_data+0x74> <== NOT EXECUTED
20d7c: ea000001 b 20d88 <rtems_bdpart_get_disk_data+0x70> <== NOT EXECUTED
20d80: e3a00003 mov r0, #3 <== NOT EXECUTED
20d84: ea000000 b 20d8c <rtems_bdpart_get_disk_data+0x74> <== NOT EXECUTED
20d88: e3a0001b mov r0, #27 <== NOT EXECUTED
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
20d8c: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
20d90: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00020b24 <rtems_bdpart_mount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
20b24: e92d4ff3 push {r0, r1, 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, '/');
20b28: 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
)
{
20b2c: e1a0b003 mov fp, r3 <== NOT EXECUTED
20b30: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
20b34: e1a0a000 mov sl, r0 <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
20b38: eb008f39 bl 44824 <strrchr> <== NOT EXECUTED
20b3c: e1a04000 mov r4, 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);
20b40: e1a0000a mov r0, sl <== NOT EXECUTED
20b44: eb008bea bl 43af4 <strlen> <== NOT EXECUTED
20b48: e1a06000 mov r6, r0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
20b4c: e1a0000b mov r0, fp <== NOT EXECUTED
20b50: eb008be7 bl 43af4 <strlen> <== NOT EXECUTED
20b54: e1a07000 mov r7, r0 <== NOT EXECUTED
size_t i = 0;
/* Create logical disk name base */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
20b58: e2860004 add r0, r6, #4 <== NOT EXECUTED
20b5c: ebff9c7b bl 7d50 <malloc> <== NOT EXECUTED
if (logical_disk_name == NULL) {
20b60: e2505000 subs r5, r0, #0 <== NOT EXECUTED
20b64: 03a0601a moveq r6, #26 <== NOT EXECUTED
20b68: 0a000042 beq 20c78 <rtems_bdpart_mount+0x154> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
20b6c: e1a0100a mov r1, sl <== NOT EXECUTED
20b70: e1a02006 mov r2, r6 <== NOT EXECUTED
20b74: eb008c7e bl 43d74 <strncpy> <== NOT EXECUTED
/* Get disk file name */
if (disk_file_name != NULL) {
20b78: e3540000 cmp r4, #0 <== NOT EXECUTED
20b7c: 01a08006 moveq r8, r6 <== NOT EXECUTED
20b80: 0a000003 beq 20b94 <rtems_bdpart_mount+0x70> <== NOT EXECUTED
disk_file_name += 1;
20b84: e284a001 add sl, r4, #1 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
20b88: e1a0000a mov r0, sl <== NOT EXECUTED
20b8c: eb008bd8 bl 43af4 <strlen> <== NOT EXECUTED
20b90: e1a08000 mov r8, 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);
20b94: e0889007 add r9, r8, r7 <== NOT EXECUTED
20b98: e2890005 add r0, r9, #5 <== NOT EXECUTED
20b9c: ebff9c6b bl 7d50 <malloc> <== NOT EXECUTED
if (mount_point == NULL) {
20ba0: e2504000 subs r4, r0, #0 <== NOT EXECUTED
20ba4: 03a0601a moveq r6, #26 <== NOT EXECUTED
20ba8: 0a00002e beq 20c68 <rtems_bdpart_mount+0x144> <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
20bac: e1a02007 mov r2, r7 <== NOT EXECUTED
20bb0: e1a0100b mov r1, fp <== NOT EXECUTED
20bb4: eb008c6e bl 43d74 <strncpy> <== NOT EXECUTED
mount_point [mount_base_size] = '/';
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
20bb8: 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] = '/';
20bbc: e3a0302f mov r3, #47 ; 0x2f <== NOT EXECUTED
20bc0: e7c43007 strb r3, [r4, r7] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
20bc4: e0840000 add r0, r4, r0 <== NOT EXECUTED
20bc8: e1a0100a mov r1, sl <== NOT EXECUTED
20bcc: e1a02008 mov r2, r8 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
20bd0: e2899001 add r9, r9, #1 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
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);
20bd4: eb008c66 bl 43d74 <strncpy> <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
20bd8: e0856006 add r6, r5, r6 <== NOT EXECUTED
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
20bdc: e0849009 add r9, r4, r9 <== NOT EXECUTED
20be0: e3a07000 mov r7, #0 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
20be4: ea000016 b 20c44 <rtems_bdpart_mount+0x120> <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
20be8: eb0087af bl 42aac <snprintf> <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
20bec: 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);
20bf0: e3a02004 mov r2, #4 <== NOT EXECUTED
20bf4: e1a01006 mov r1, r6 <== NOT EXECUTED
20bf8: e1a00009 mov r0, r9 <== 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) {
20bfc: c3a06003 movgt r6, #3 <== NOT EXECUTED
20c00: ca000018 bgt 20c68 <rtems_bdpart_mount+0x144> <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
20c04: eb008c5a bl 43d74 <strncpy> <== NOT EXECUTED
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
20c08: e59f1070 ldr r1, [pc, #112] ; 20c80 <rtems_bdpart_mount+0x15c><== NOT EXECUTED
20c0c: e1a00004 mov r0, r4 <== NOT EXECUTED
20c10: ebffa023 bl 8ca4 <rtems_mkdir> <== NOT EXECUTED
if (rv != 0) {
20c14: e250c000 subs ip, r0, #0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
20c18: e1a01004 mov r1, r4 <== NOT EXECUTED
20c1c: e59f2060 ldr r2, [pc, #96] ; 20c84 <rtems_bdpart_mount+0x160><== NOT EXECUTED
20c20: e1a0300c mov r3, ip <== NOT EXECUTED
20c24: 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) {
20c28: 13a0601b movne r6, #27 <== NOT EXECUTED
20c2c: 1a00000d bne 20c68 <rtems_bdpart_mount+0x144> <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
20c30: e58dc000 str ip, [sp] <== NOT EXECUTED
20c34: ebff9d24 bl 80cc <mount> <== NOT EXECUTED
mount_point,
"msdos",
0,
NULL
);
if (rv != 0) {
20c38: e3500000 cmp r0, #0 <== NOT EXECUTED
rmdir( mount_point);
20c3c: 11a00004 movne r0, r4 <== NOT EXECUTED
20c40: 1b0016f7 blne 26824 <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) {
20c44: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
20c48: e1570003 cmp r7, r3 <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
20c4c: e2877001 add r7, r7, #1 <== NOT EXECUTED
20c50: e3a01004 mov r1, #4 <== NOT EXECUTED
20c54: e59f202c ldr r2, [pc, #44] ; 20c88 <rtems_bdpart_mount+0x164><== NOT EXECUTED
20c58: e1a00006 mov r0, r6 <== NOT EXECUTED
20c5c: e1a03007 mov r3, r7 <== 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) {
20c60: 3affffe0 bcc 20be8 <rtems_bdpart_mount+0xc4> <== NOT EXECUTED
20c64: e3a06000 mov r6, #0 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
20c68: e1a00005 mov r0, r5 <== NOT EXECUTED
20c6c: ebff9a90 bl 76b4 <free> <== NOT EXECUTED
free( mount_point);
20c70: e1a00004 mov r0, r4 <== NOT EXECUTED
20c74: ebff9a8e bl 76b4 <free> <== NOT EXECUTED
return esc;
}
20c78: e1a00006 mov r0, r6 <== NOT EXECUTED
20c7c: e8bd8ffc pop {r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0002111c <rtems_bdpart_new_record>:
static rtems_status_code rtems_bdpart_new_record(
dev_t disk,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
2111c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
21120: e1a04003 mov r4, r3 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Synchronize previous block if necessary */
if (*block != NULL) {
21124: e5933000 ldr r3, [r3] <== NOT EXECUTED
21128: 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
)
{
2112c: e1a06002 mov r6, r2 <== NOT EXECUTED
21130: e1a07000 mov r7, r0 <== NOT EXECUTED
21134: e1a08001 mov r8, r1 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Synchronize previous block if necessary */
if (*block != NULL) {
21138: 0a000003 beq 2114c <rtems_bdpart_new_record+0x30> <== NOT EXECUTED
sc = rtems_bdbuf_sync( *block);
2113c: e1a00003 mov r0, r3 <== NOT EXECUTED
21140: ebff8e5d bl 4abc <rtems_bdbuf_sync> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
21144: e2505000 subs r5, r0, #0 <== NOT EXECUTED
21148: 1a000016 bne 211a8 <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);
2114c: e1a00007 mov r0, r7 <== NOT EXECUTED
21150: e1a01008 mov r1, r8 <== NOT EXECUTED
21154: e1a02006 mov r2, r6 <== NOT EXECUTED
21158: e1a03004 mov r3, r4 <== NOT EXECUTED
2115c: ebff9061 bl 52e8 <rtems_bdbuf_read> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
21160: e2505000 subs r5, r0, #0 <== NOT EXECUTED
21164: 1a00000f bne 211a8 <rtems_bdpart_new_record+0x8c> <== NOT EXECUTED
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
21168: e5943000 ldr r3, [r4] <== NOT EXECUTED
2116c: e3530000 cmp r3, #0 <== NOT EXECUTED
21170: 03a05009 moveq r5, #9 <== NOT EXECUTED
21174: 0a00000b beq 211a8 <rtems_bdpart_new_record+0x8c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
}
/* Clear record */
memset( (*block)->buffer, 0, RTEMS_BDPART_BLOCK_SIZE);
21178: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED
2117c: e3a02c02 mov r2, #512 ; 0x200 <== NOT EXECUTED
21180: e1a01005 mov r1, r5 <== NOT EXECUTED
21184: eb007c94 bl 403dc <memset> <== NOT EXECUTED
/* Write signature */
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0] =
21188: e5943000 ldr r3, [r4] <== NOT EXECUTED
2118c: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
21190: e3a02055 mov r2, #85 ; 0x55 <== NOT EXECUTED
21194: e5c321fe strb r2, [r3, #510] ; 0x1fe <== NOT EXECUTED
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
21198: e5943000 ldr r3, [r4] <== NOT EXECUTED
2119c: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
211a0: e3e02055 mvn r2, #85 ; 0x55 <== NOT EXECUTED
211a4: e5c321ff strb r2, [r3, #511] ; 0x1ff <== NOT EXECUTED
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
211a8: e1a00005 mov r0, r5 <== NOT EXECUTED
211ac: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00020eb0 <rtems_bdpart_read>:
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
20eb0: 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);
20eb4: e2535000 subs r5, r3, #0 <== NOT EXECUTED
20eb8: 15953000 ldrne r3, [r5] <== NOT EXECUTED
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
20ebc: e1a06002 mov r6, r2 <== 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);
20ec0: 13a02030 movne r2, #48 ; 0x30 <== NOT EXECUTED
20ec4: 10080392 mulne r8, r2, r3 <== NOT EXECUTED
20ec8: 01a08005 moveq r8, r5 <== NOT EXECUTED
dev_t disk = 0;
size_t i = 0;
const uint8_t *data = NULL;
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
20ecc: e3510000 cmp r1, #0 <== NOT EXECUTED
20ed0: 13560000 cmpne r6, #0 <== NOT EXECUTED
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
20ed4: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
20ed8: e1a07001 mov r7, r1 <== NOT EXECUTED
dev_t disk = 0;
size_t i = 0;
const uint8_t *data = NULL;
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
20edc: 13a03000 movne r3, #0 <== NOT EXECUTED
20ee0: 03a03001 moveq r3, #1 <== NOT EXECUTED
20ee4: 0a000088 beq 2110c <rtems_bdpart_read+0x25c> <== NOT EXECUTED
20ee8: e3550000 cmp r5, #0 <== NOT EXECUTED
20eec: 0a000086 beq 2110c <rtems_bdpart_read+0x25c> <== NOT EXECUTED
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 */
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
rtems_blkdev_bnum disk_end = 0;
20ef0: e58d3008 str r3, [sp, #8] <== 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 */
20ef4: 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;
20ef8: e246c030 sub ip, r6, #48 ; 0x30 <== NOT EXECUTED
if (format == NULL || pt == NULL || count == NULL) {
return RTEMS_INVALID_ADDRESS;
}
/* Set count to a save value */
*count = 0;
20efc: e5853000 str r3, [r5] <== NOT EXECUTED
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);
20f00: e1a0100d mov r1, sp <== NOT EXECUTED
20f04: e28d2008 add r2, sp, #8 <== 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;
20f08: e3a0a000 mov sl, #0 <== NOT EXECUTED
20f0c: e3a0b000 mov fp, #0 <== NOT EXECUTED
20f10: e88d0c00 stm sp, {sl, fp} <== 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;
20f14: e58dc010 str ip, [sp, #16] <== NOT EXECUTED
size_t *count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
20f18: e58d3014 str r3, [sp, #20] <== NOT EXECUTED
/* Set count to a save value */
*count = 0;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);
20f1c: ebffff7d bl 20d18 <rtems_bdpart_get_disk_data> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
20f20: e3500000 cmp r0, #0 <== NOT EXECUTED
20f24: 1a000079 bne 21110 <rtems_bdpart_read+0x260> <== NOT EXECUTED
return sc;
}
/* Read MBR */
sc = rtems_bdpart_read_record( disk, 0, &block);
20f28: e1a02000 mov r2, r0 <== NOT EXECUTED
20f2c: e28d3014 add r3, sp, #20 <== NOT EXECUTED
20f30: e89d0003 ldm sp, {r0, r1} <== NOT EXECUTED
20f34: ebffff54 bl 20c8c <rtems_bdpart_read_record> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
20f38: e2504000 subs r4, r0, #0 <== NOT EXECUTED
20f3c: 1a00006d bne 210f8 <rtems_bdpart_read+0x248> <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
20f40: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED
20f44: e593a020 ldr sl, [r3, #32] <== NOT EXECUTED
20f48: e28a4f6f add r4, sl, #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);
20f4c: e0868008 add r8, r6, r8 <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
20f50: e2844002 add r4, r4, #2 <== NOT EXECUTED
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
20f54: e28d9010 add r9, sp, #16 <== NOT EXECUTED
20f58: e28db00c add fp, sp, #12 <== NOT EXECUTED
20f5c: e1a00004 mov r0, r4 <== NOT EXECUTED
20f60: e1a01009 mov r1, r9 <== NOT EXECUTED
20f64: e1a02008 mov r2, r8 <== NOT EXECUTED
20f68: e1a0300b mov r3, fp <== NOT EXECUTED
20f6c: ebffff98 bl 20dd4 <rtems_bdpart_read_mbr_partition> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
20f70: e3500000 cmp r0, #0 <== NOT EXECUTED
20f74: 1a00002f bne 21038 <rtems_bdpart_read+0x188> <== 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) {
20f78: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
20f7c: e5d33008 ldrb r3, [r3, #8] <== NOT EXECUTED
20f80: e35300ee cmp r3, #238 ; 0xee <== NOT EXECUTED
20f84: 03a04018 moveq r4, #24 <== NOT EXECUTED
20f88: 0a00005a beq 210f8 <rtems_bdpart_read+0x248> <== NOT EXECUTED
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
format->mbr.disk_id = rtems_uint32_from_little_endian(
20f8c: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED
esc = RTEMS_NOT_IMPLEMENTED;
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
20f90: e5870000 str r0, [r7] <== NOT EXECUTED
format->mbr.disk_id = rtems_uint32_from_little_endian(
20f94: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
20f98: e5d321ba ldrb r2, [r3, #442] ; 0x1ba <== NOT EXECUTED
20f9c: e5d301bb ldrb r0, [r3, #443] ; 0x1bb <== NOT EXECUTED
20fa0: e5d311b9 ldrb r1, [r3, #441] ; 0x1b9 <== NOT EXECUTED
20fa4: e0820400 add r0, r2, r0, lsl #8 <== NOT EXECUTED
20fa8: e5d321b8 ldrb r2, [r3, #440] ; 0x1b8 <== NOT EXECUTED
20fac: e0813400 add r3, r1, r0, lsl #8 <== NOT EXECUTED
20fb0: e0823403 add r3, r2, r3, lsl #8 <== NOT EXECUTED
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
20fb4: e3a02001 mov r2, #1 <== NOT EXECUTED
20fb8: e5c72008 strb r2, [r7, #8] <== NOT EXECUTED
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
format->mbr.disk_id = rtems_uint32_from_little_endian(
20fbc: e5873004 str r3, [r7, #4] <== NOT EXECUTED
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
20fc0: e28a7f7b add r7, sl, #492 ; 0x1ec <== NOT EXECUTED
20fc4: e2877002 add r7, r7, #2 <== NOT EXECUTED
/* Iterate through the rest of the primary partition table */
for (i = 1; i < 4; ++i) {
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
20fc8: e1a0a009 mov sl, r9 <== 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;
20fcc: e2844010 add r4, r4, #16 <== NOT EXECUTED
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
20fd0: e1a00004 mov r0, r4 <== NOT EXECUTED
20fd4: e1a0100a mov r1, sl <== NOT EXECUTED
20fd8: e1a02008 mov r2, r8 <== NOT EXECUTED
20fdc: e1a0300b mov r3, fp <== NOT EXECUTED
20fe0: ebffff7b bl 20dd4 <rtems_bdpart_read_mbr_partition> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
20fe4: e3500000 cmp r0, #0 <== NOT EXECUTED
20fe8: 1a000012 bne 21038 <rtems_bdpart_read+0x188> <== 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) {
20fec: e1540007 cmp r4, r7 <== NOT EXECUTED
20ff0: 1afffff5 bne 20fcc <rtems_bdpart_read+0x11c> <== NOT EXECUTED
goto cleanup;
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
20ff4: e59d400c ldr r4, [sp, #12] <== NOT EXECUTED
while (ebr != 0) {
rtems_blkdev_bnum tmp = 0;
/* Read EBR */
sc = rtems_bdpart_read_record( disk, ebr, &block);
20ff8: e28d7014 add r7, sp, #20 <== NOT EXECUTED
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
while (ebr != 0) {
20ffc: ea00002f b 210c0 <rtems_bdpart_read+0x210> <== NOT EXECUTED
rtems_blkdev_bnum tmp = 0;
/* Read EBR */
sc = rtems_bdpart_read_record( disk, ebr, &block);
21000: e89d0003 ldm sp, {r0, r1} <== NOT EXECUTED
21004: ebffff20 bl 20c8c <rtems_bdpart_read_record> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
21008: e3500000 cmp r0, #0 <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
2100c: e1a0100a mov r1, sl <== NOT EXECUTED
21010: e1a02008 mov r2, r8 <== NOT EXECUTED
21014: 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) {
21018: 1a000006 bne 21038 <rtems_bdpart_read+0x188> <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
2101c: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED
21020: e5900020 ldr r0, [r0, #32] <== NOT EXECUTED
21024: e2800f6f add r0, r0, #444 ; 0x1bc <== NOT EXECUTED
21028: e2800002 add r0, r0, #2 <== NOT EXECUTED
2102c: ebffff68 bl 20dd4 <rtems_bdpart_read_mbr_partition> <== NOT EXECUTED
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
&p,
p_end,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
21030: e3500000 cmp r0, #0 <== NOT EXECUTED
21034: 0a000001 beq 21040 <rtems_bdpart_read+0x190> <== NOT EXECUTED
21038: e1a04000 mov r4, r0 <== NOT EXECUTED
2103c: ea00002d b 210f8 <rtems_bdpart_read+0x248> <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Adjust partition begin */
tmp = p->begin + ebr;
21040: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
21044: e5931000 ldr r1, [r3] <== NOT EXECUTED
21048: e0842001 add r2, r4, r1 <== NOT EXECUTED
if (tmp > p->begin) {
2104c: e1520001 cmp r2, r1 <== NOT EXECUTED
21050: 9a000027 bls 210f4 <rtems_bdpart_read+0x244> <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Adjust partition end */
tmp = p->end + ebr;
21054: e5931004 ldr r1, [r3, #4] <== NOT EXECUTED
21058: e0844001 add r4, r4, r1 <== NOT EXECUTED
if (tmp > p->end) {
2105c: e1540001 cmp r4, r1 <== NOT EXECUTED
}
/* Adjust partition begin */
tmp = p->begin + ebr;
if (tmp > p->begin) {
p->begin = tmp;
21060: e5832000 str r2, [r3] <== NOT EXECUTED
goto cleanup;
}
/* Adjust partition end */
tmp = p->end + ebr;
if (tmp > p->end) {
21064: 9a000022 bls 210f4 <rtems_bdpart_read+0x244> <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
21068: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED
2106c: e5922020 ldr r2, [r2, #32] <== NOT EXECUTED
}
/* Adjust partition end */
tmp = p->end + ebr;
if (tmp > p->end) {
p->end = tmp;
21070: e5834004 str r4, [r3, #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);
21074: e2823f75 add r3, r2, #468 ; 0x1d4 <== NOT EXECUTED
21078: e2833002 add r3, r3, #2 <== NOT EXECUTED
2107c: e5d34003 ldrb r4, [r3, #3] <== NOT EXECUTED
21080: e5d3c002 ldrb ip, [r3, #2] <== NOT EXECUTED
21084: e5d30001 ldrb r0, [r3, #1] <== NOT EXECUTED
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EXTENDED) {
21088: e5d211d2 ldrb r1, [r2, #466] ; 0x1d2 <== NOT EXECUTED
2108c: e08c4404 add r4, ip, r4, lsl #8 <== NOT EXECUTED
21090: e5d231d6 ldrb r3, [r2, #470] ; 0x1d6 <== NOT EXECUTED
21094: e0804404 add r4, r0, r4, lsl #8 <== NOT EXECUTED
21098: e3510005 cmp r1, #5 <== NOT EXECUTED
2109c: e0834404 add r4, r3, r4, lsl #8 <== NOT EXECUTED
210a0: 1a00000a bne 210d0 <rtems_bdpart_read+0x220> <== 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) {
210a4: e3540000 cmp r4, #0 <== NOT EXECUTED
210a8: 0a000008 beq 210d0 <rtems_bdpart_read+0x220> <== NOT EXECUTED
/* Adjust partition EBR block index */
tmp = ebr + ep_begin;
210ac: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
210b0: e0843003 add r3, r4, r3 <== NOT EXECUTED
if (tmp > ebr) {
210b4: e1530004 cmp r3, r4 <== NOT EXECUTED
210b8: 9a00000d bls 210f4 <rtems_bdpart_read+0x244> <== NOT EXECUTED
210bc: e1a04003 mov r4, r3 <== NOT EXECUTED
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
while (ebr != 0) {
210c0: e3540000 cmp r4, #0 <== NOT EXECUTED
rtems_blkdev_bnum tmp = 0;
/* Read EBR */
sc = rtems_bdpart_read_record( disk, ebr, &block);
210c4: e1a02004 mov r2, r4 <== NOT EXECUTED
210c8: e1a03007 mov r3, r7 <== NOT EXECUTED
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
while (ebr != 0) {
210cc: 1affffcb bne 21000 <rtems_bdpart_read+0x150> <== NOT EXECUTED
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
210d0: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
210d4: e59f203c ldr r2, [pc, #60] ; 21118 <rtems_bdpart_read+0x268><== NOT EXECUTED
210d8: e0666003 rsb r6, r6, r3 <== NOT EXECUTED
210dc: e1a06246 asr r6, r6, #4 <== NOT EXECUTED
210e0: e0030692 mul r3, r2, r6 <== NOT EXECUTED
210e4: e2833001 add r3, r3, #1 <== NOT EXECUTED
210e8: e5853000 str r3, [r5] <== NOT EXECUTED
210ec: e3a04000 mov r4, #0 <== NOT EXECUTED
210f0: ea000000 b 210f8 <rtems_bdpart_read+0x248> <== NOT EXECUTED
210f4: e3a0401b mov r4, #27 <== NOT EXECUTED
cleanup:
if (block != NULL) {
210f8: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED
210fc: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_bdbuf_release( block);
21100: 1bff8c38 blne 41e8 <rtems_bdbuf_release> <== NOT EXECUTED
21104: e1a00004 mov r0, r4 <== NOT EXECUTED
21108: ea000000 b 21110 <rtems_bdpart_read+0x260> <== NOT EXECUTED
2110c: e3a00009 mov r0, #9 <== NOT EXECUTED
}
return esc;
}
21110: e28dd018 add sp, sp, #24 <== NOT EXECUTED
21114: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00020dd4 <rtems_bdpart_read_mbr_partition>:
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
20dd4: 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);
20dd8: e2805008 add r5, r0, #8 <== NOT EXECUTED
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
20ddc: 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);
20de0: 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];
20de4: e5d57003 ldrb r7, [r5, #3] <== NOT EXECUTED
20de8: e5d08002 ldrb r8, [r0, #2] <== NOT EXECUTED
20dec: e5d56002 ldrb r6, [r5, #2] <== NOT EXECUTED
20df0: e5d0c003 ldrb ip, [r0, #3] <== NOT EXECUTED
20df4: e5d5a001 ldrb sl, [r5, #1] <== NOT EXECUTED
20df8: e5d09001 ldrb r9, [r0, #1] <== NOT EXECUTED
rtems_blkdev_bnum end = begin + size;
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
20dfc: e5d45004 ldrb r5, [r4, #4] <== NOT EXECUTED
20e00: e0866407 add r6, r6, r7, lsl #8 <== NOT EXECUTED
20e04: e088c40c add ip, r8, ip, lsl #8 <== NOT EXECUTED
20e08: e5d40008 ldrb r0, [r4, #8] <== NOT EXECUTED
20e0c: e5d4800c ldrb r8, [r4, #12] <== NOT EXECUTED
20e10: e08a6406 add r6, sl, r6, lsl #8 <== NOT EXECUTED
20e14: e089c40c add ip, r9, ip, lsl #8 <== NOT EXECUTED
if (type == RTEMS_BDPART_MBR_EMPTY) {
20e18: e3550000 cmp r5, #0 <== NOT EXECUTED
20e1c: e0806406 add r6, r0, r6, lsl #8 <== NOT EXECUTED
20e20: e088840c add r8, r8, ip, lsl #8 <== NOT EXECUTED
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
20e24: e1a07001 mov r7, 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) {
20e28: 0a00001e beq 20ea8 <rtems_bdpart_read_mbr_partition+0xd4> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
20e2c: e5910000 ldr r0, [r1] <== NOT EXECUTED
20e30: e1500002 cmp r0, r2 <== NOT EXECUTED
20e34: 03a00005 moveq r0, #5 <== NOT EXECUTED
20e38: 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;
20e3c: e0888006 add r8, r8, r6 <== NOT EXECUTED
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
return RTEMS_TOO_MANY;
} else if (begin >= end) {
20e40: e1560008 cmp r6, r8 <== NOT EXECUTED
20e44: 23a0001b movcs r0, #27 <== NOT EXECUTED
20e48: 28bd87f0 popcs {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
return RTEMS_IO_ERROR;
} else if (type == RTEMS_BDPART_MBR_EXTENDED) {
20e4c: e3550005 cmp r5, #5 <== NOT EXECUTED
20e50: 1a000003 bne 20e64 <rtems_bdpart_read_mbr_partition+0x90> <== NOT EXECUTED
if (ep_begin != NULL) {
20e54: e3530000 cmp r3, #0 <== NOT EXECUTED
*ep_begin = begin;
20e58: 15836000 strne r6, [r3] <== 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) {
20e5c: 1a00000f bne 20ea0 <rtems_bdpart_read_mbr_partition+0xcc> <== NOT EXECUTED
20e60: ea000010 b 20ea8 <rtems_bdpart_read_mbr_partition+0xd4> <== NOT EXECUTED
*ep_begin = begin;
}
} else {
/* Increment partition index */
++(*p);
20e64: e2800030 add r0, r0, #48 ; 0x30 <== NOT EXECUTED
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
20e68: e3a02030 mov r2, #48 ; 0x30 <== NOT EXECUTED
if (ep_begin != NULL) {
*ep_begin = begin;
}
} else {
/* Increment partition index */
++(*p);
20e6c: e5810000 str r0, [r1] <== NOT EXECUTED
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
20e70: e3a01000 mov r1, #0 <== NOT EXECUTED
20e74: eb007d58 bl 403dc <memset> <== NOT EXECUTED
/* Set values */
(*p)->begin = begin;
20e78: e5971000 ldr r1, [r7] <== NOT EXECUTED
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
20e7c: e1a00005 mov r0, r5 <== NOT EXECUTED
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
/* Set values */
(*p)->begin = begin;
20e80: e8810140 stm r1, {r6, r8} <== NOT EXECUTED
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
20e84: e2811008 add r1, r1, #8 <== NOT EXECUTED
20e88: ebffffcb bl 20dbc <rtems_bdpart_to_partition_type> <== NOT EXECUTED
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
20e8c: e5973000 ldr r3, [r7] <== NOT EXECUTED
20e90: e5d41000 ldrb r1, [r4] <== NOT EXECUTED
20e94: e3a02000 mov r2, #0 <== NOT EXECUTED
20e98: e5831028 str r1, [r3, #40] ; 0x28 <== NOT EXECUTED
20e9c: e583202c str r2, [r3, #44] ; 0x2c <== NOT EXECUTED
20ea0: e3a00000 mov r0, #0 <== NOT EXECUTED
20ea4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
20ea8: e3a00000 mov r0, #0 <== NOT EXECUTED
}
return RTEMS_SUCCESSFUL;
}
20eac: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
00020c8c <rtems_bdpart_read_record>:
static rtems_status_code rtems_bdpart_read_record(
dev_t disk,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
20c8c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
20c90: e1a04003 mov r4, r3 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
20c94: e5933000 ldr r3, [r3] <== NOT EXECUTED
20c98: 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
)
{
20c9c: e1a05002 mov r5, r2 <== NOT EXECUTED
20ca0: e1a06000 mov r6, r0 <== NOT EXECUTED
20ca4: e1a07001 mov r7, r1 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
20ca8: 0a000003 beq 20cbc <rtems_bdpart_read_record+0x30> <== NOT EXECUTED
sc = rtems_bdbuf_release( *block);
20cac: e1a00003 mov r0, r3 <== NOT EXECUTED
20cb0: ebff8d4c bl 41e8 <rtems_bdbuf_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
20cb4: e3500000 cmp r0, #0 <== NOT EXECUTED
20cb8: 18bd80f0 popne {r4, r5, r6, r7, pc} <== NOT EXECUTED
return sc;
}
}
/* Read the record block */
sc = rtems_bdbuf_read( disk, index, block);
20cbc: e1a00006 mov r0, r6 <== NOT EXECUTED
20cc0: e1a01007 mov r1, r7 <== NOT EXECUTED
20cc4: e1a02005 mov r2, r5 <== NOT EXECUTED
20cc8: e1a03004 mov r3, r4 <== NOT EXECUTED
20ccc: ebff9185 bl 52e8 <rtems_bdbuf_read> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
20cd0: e3500000 cmp r0, #0 <== NOT EXECUTED
20cd4: 18bd80f0 popne {r4, r5, r6, r7, pc} <== NOT EXECUTED
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
20cd8: e5943000 ldr r3, [r4] <== NOT EXECUTED
20cdc: e3530000 cmp r3, #0 <== NOT EXECUTED
20ce0: 03a00009 moveq r0, #9 <== NOT EXECUTED
20ce4: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
20ce8: 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]
20cec: e5d321fe ldrb r2, [r3, #510] ; 0x1fe <== NOT EXECUTED
20cf0: e3520055 cmp r2, #85 ; 0x55 <== NOT EXECUTED
20cf4: 1a000003 bne 20d08 <rtems_bdpart_read_record+0x7c> <== NOT EXECUTED
20cf8: e5d301ff ldrb r0, [r3, #511] ; 0x1ff <== NOT EXECUTED
20cfc: e35000aa cmp r0, #170 ; 0xaa <== NOT EXECUTED
20d00: 13a00000 movne r0, #0 <== NOT EXECUTED
20d04: 03a00001 moveq r0, #1 <== NOT EXECUTED
if ( *block == NULL ) {
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
20d08: e31000ff tst r0, #255 ; 0xff <== NOT EXECUTED
20d0c: 13a00000 movne r0, #0 <== NOT EXECUTED
20d10: 03a0001b moveq r0, #27 <== NOT EXECUTED
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
20d14: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00005658 <rtems_bdpart_register>:
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
5658: 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;
565c: e3a03000 mov r3, #0 <== NOT EXECUTED
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
5660: e24dd02c sub sp, sp, #44 ; 0x2c <== 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;
5664: e58d3028 str r3, [sp, #40] ; 0x28 <== NOT EXECUTED
dev_t disk = 0;
5668: e3a04000 mov r4, #0 <== NOT EXECUTED
566c: e3a03000 mov r3, #0 <== NOT EXECUTED
5670: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
5674: e58d4024 str r4, [sp, #36] ; 0x24 <== NOT EXECUTED
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
5678: e1a0a000 mov sl, r0 <== NOT EXECUTED
567c: e1a05001 mov r5, r1 <== NOT EXECUTED
5680: e1a0b002 mov fp, 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);
5684: eb00f91a bl 43af4 <strlen> <== NOT EXECUTED
size_t i = 0;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);
5688: e28d1020 add r1, sp, #32 <== 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);
568c: e1a08000 mov r8, r0 <== NOT EXECUTED
size_t i = 0;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);
5690: e28d2028 add r2, sp, #40 ; 0x28 <== NOT EXECUTED
5694: e1a0000a mov r0, sl <== NOT EXECUTED
5698: eb006d9e bl 20d18 <rtems_bdpart_get_disk_data> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
569c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
56a0: 1a000031 bne 576c <rtems_bdpart_register+0x114> <== NOT EXECUTED
return sc;
}
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
56a4: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
/* Create logical disk name */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
56a8: e2880004 add r0, r8, #4 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
56ac: e58d300c str r3, [sp, #12] <== NOT EXECUTED
56b0: e59d7024 ldr r7, [sp, #36] ; 0x24 <== NOT EXECUTED
/* Create logical disk name */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
56b4: eb0009a5 bl 7d50 <malloc> <== NOT EXECUTED
if (logical_disk_name == NULL) {
56b8: e2506000 subs r6, r0, #0 <== NOT EXECUTED
56bc: 03a0401a moveq r4, #26 <== NOT EXECUTED
56c0: 0a000029 beq 576c <rtems_bdpart_register+0x114> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
56c4: e1a02008 mov r2, r8 <== NOT EXECUTED
56c8: e1a0100a mov r1, sl <== NOT EXECUTED
56cc: eb00f9a8 bl 43d74 <strncpy> <== NOT EXECUTED
logical_disk_marker = logical_disk_name + disk_name_size;
56d0: e0868008 add r8, r6, r8 <== NOT EXECUTED
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
56d4: ea000019 b 5740 <rtems_bdpart_register+0xe8> <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
56d8: e59d900c ldr r9, [sp, #12] <== NOT EXECUTED
temp.__overlay.minor = _minor;
56dc: e58d701c str r7, [sp, #28] <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
56e0: e58d9018 str r9, [sp, #24] <== NOT EXECUTED
temp.__overlay.minor = _minor;
return temp.device;
56e4: e28da018 add sl, sp, #24 <== NOT EXECUTED
56e8: e89a0600 ldm sl, {r9, sl} <== NOT EXECUTED
56ec: e58d9010 str r9, [sp, #16] <== NOT EXECUTED
56f0: e58da014 str sl, [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);
56f4: eb00f4ec bl 42aac <snprintf> <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
56f8: e3500003 cmp r0, #3 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
56fc: e28d1010 add r1, sp, #16 <== NOT EXECUTED
5700: e8910003 ldm r1, {r0, r1} <== 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) {
5704: c3a04003 movgt r4, #3 <== NOT EXECUTED
5708: ca000015 bgt 5764 <rtems_bdpart_register+0x10c> <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
570c: e5953000 ldr r3, [r5] <== NOT EXECUTED
5710: e58d3000 str r3, [sp] <== NOT EXECUTED
5714: e595c004 ldr ip, [r5, #4] <== NOT EXECUTED
5718: e063c00c rsb ip, r3, ip <== NOT EXECUTED
571c: e28d3020 add r3, sp, #32 <== NOT EXECUTED
5720: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
5724: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
5728: e58d6008 str r6, [sp, #8] <== NOT EXECUTED
572c: eb0003d2 bl 667c <rtems_disk_create_log> <== NOT EXECUTED
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
5730: e3500000 cmp r0, #0 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
5734: e2855030 add r5, r5, #48 ; 0x30 <== NOT EXECUTED
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
5738: 11a04000 movne r4, r0 <== NOT EXECUTED
573c: 1a000008 bne 5764 <rtems_bdpart_register+0x10c> <== 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) {
5740: e154000b cmp r4, fp <== 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);
5744: 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;
5748: e2877001 add r7, r7, #1 <== 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);
574c: e3a01004 mov r1, #4 <== NOT EXECUTED
5750: e59f2020 ldr r2, [pc, #32] ; 5778 <rtems_bdpart_register+0x120><== NOT EXECUTED
5754: e1a00008 mov r0, r8 <== NOT EXECUTED
5758: e1a03004 mov r3, r4 <== 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) {
575c: 3affffdd bcc 56d8 <rtems_bdpart_register+0x80> <== NOT EXECUTED
5760: e3a04000 mov r4, #0 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
5764: e1a00006 mov r0, r6 <== NOT EXECUTED
5768: eb0007d1 bl 76b4 <free> <== NOT EXECUTED
return esc;
}
576c: e1a00004 mov r0, r4 <== NOT EXECUTED
5770: e28dd02c add sp, sp, #44 ; 0x2c <== NOT EXECUTED
5774: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0000577c <rtems_bdpart_register_from_disk>:
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{
577c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
5780: 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;
5784: e3a0c010 mov ip, #16 <== NOT EXECUTED
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
5788: e28d1c03 add r1, sp, #768 ; 0x300 <== NOT EXECUTED
578c: e1a0200d mov r2, sp <== NOT EXECUTED
5790: 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;
5794: e58dc314 str ip, [sp, #788] ; 0x314 <== NOT EXECUTED
return esc;
}
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{
5798: 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);
579c: eb006dc3 bl 20eb0 <rtems_bdpart_read> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
57a0: 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);
57a4: e1a0400d mov r4, sp <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Register partitions */
return rtems_bdpart_register( disk_name, pt, count);
57a8: 01a00005 moveq r0, r5 <== NOT EXECUTED
57ac: 01a0100d moveq r1, sp <== NOT EXECUTED
57b0: 059d2314 ldreq r2, [sp, #788] ; 0x314 <== NOT EXECUTED
57b4: 0bffffa7 bleq 5658 <rtems_bdpart_register> <== NOT EXECUTED
}
57b8: e28ddfc6 add sp, sp, #792 ; 0x318 <== NOT EXECUTED
57bc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00020d94 <rtems_bdpart_to_mbr_partition_type>:
bool rtems_bdpart_to_mbr_partition_type(
const uuid_t type,
uint8_t *mbr_type
)
{
20d94: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
*mbr_type = rtems_bdpart_mbr_partition_type( type);
20d98: e4d03001 ldrb r3, [r0], #1 <== NOT EXECUTED
return memcmp(
20d9c: 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);
20da0: e5c13000 strb r3, [r1] <== NOT EXECUTED
return memcmp(
20da4: e59f100c ldr r1, [pc, #12] ; 20db8 <rtems_bdpart_to_mbr_partition_type+0x24><== NOT EXECUTED
20da8: eb007cda bl 40118 <memcmp> <== NOT EXECUTED
type + 1,
RTEMS_BDPART_MBR_MASTER_TYPE + 1,
sizeof( uuid_t) - 1
) == 0;
}
20dac: e2700001 rsbs r0, r0, #1 <== NOT EXECUTED
20db0: 33a00000 movcc r0, #0 <== NOT EXECUTED
20db4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00020dbc <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;
20dbc: e4c10001 strb r0, [r1], #1 <== NOT EXECUTED
memcpy( type + 1, RTEMS_BDPART_MBR_MASTER_TYPE + 1, sizeof( uuid_t) - 1);
20dc0: e1a00001 mov r0, r1 <== NOT EXECUTED
20dc4: e59f1004 ldr r1, [pc, #4] ; 20dd0 <rtems_bdpart_to_partition_type+0x14><== NOT EXECUTED
20dc8: e3a0200f mov r2, #15 <== NOT EXECUTED
20dcc: ea007cfb b 401c0 <memcpy> <== NOT EXECUTED
00020a1c <rtems_bdpart_unmount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
20a1c: 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, '/');
20a20: 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
)
{
20a24: e1a09003 mov r9, r3 <== NOT EXECUTED
20a28: e1a04000 mov r4, r0 <== NOT EXECUTED
20a2c: e1a06002 mov r6, r2 <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
20a30: eb008f7b bl 44824 <strrchr> <== NOT EXECUTED
20a34: e1a0a000 mov sl, 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);
20a38: e1a00004 mov r0, r4 <== NOT EXECUTED
20a3c: eb008c2c bl 43af4 <strlen> <== NOT EXECUTED
20a40: e1a08000 mov r8, r0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
20a44: e1a00009 mov r0, r9 <== NOT EXECUTED
20a48: eb008c29 bl 43af4 <strlen> <== NOT EXECUTED
size_t i = 0;
/* Get disk file name */
if (disk_file_name != NULL) {
20a4c: e35a0000 cmp sl, #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);
20a50: e1a05000 mov r5, r0 <== NOT EXECUTED
size_t i = 0;
/* Get disk file name */
if (disk_file_name != NULL) {
20a54: 01a0a004 moveq sl, r4 <== NOT EXECUTED
20a58: 0a000003 beq 20a6c <rtems_bdpart_unmount+0x50> <== NOT EXECUTED
disk_file_name += 1;
20a5c: e28aa001 add sl, sl, #1 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
20a60: e1a0000a mov r0, sl <== NOT EXECUTED
20a64: eb008c22 bl 43af4 <strlen> <== NOT EXECUTED
20a68: e1a08000 mov r8, 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);
20a6c: e0887005 add r7, r8, r5 <== NOT EXECUTED
20a70: e2870005 add r0, r7, #5 <== NOT EXECUTED
20a74: ebff9cb5 bl 7d50 <malloc> <== NOT EXECUTED
if (mount_point == NULL) {
20a78: e2504000 subs r4, r0, #0 <== NOT EXECUTED
20a7c: 03a0501a moveq r5, #26 <== NOT EXECUTED
20a80: 0a000022 beq 20b10 <rtems_bdpart_unmount+0xf4> <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
20a84: e1a02005 mov r2, r5 <== NOT EXECUTED
20a88: e1a01009 mov r1, r9 <== NOT EXECUTED
20a8c: eb008cb8 bl 43d74 <strncpy> <== NOT EXECUTED
mount_point [mount_base_size] = '/';
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
20a90: e2850001 add r0, r5, #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] = '/';
20a94: e3a0302f mov r3, #47 ; 0x2f <== NOT EXECUTED
20a98: e7c43005 strb r3, [r4, r5] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
20a9c: e0840000 add r0, r4, r0 <== NOT EXECUTED
20aa0: e1a0100a mov r1, sl <== NOT EXECUTED
20aa4: e1a02008 mov r2, r8 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
20aa8: e2877001 add r7, r7, #1 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
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);
20aac: eb008cb0 bl 43d74 <strncpy> <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
20ab0: e0847007 add r7, r4, r7 <== NOT EXECUTED
20ab4: e3a05000 mov r5, #0 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
20ab8: ea00000c b 20af0 <rtems_bdpart_unmount+0xd4> <== NOT EXECUTED
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
20abc: eb0087fa bl 42aac <snprintf> <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
20ac0: e3500003 cmp r0, #3 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
20ac4: e1a00004 mov r0, r4 <== 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) {
20ac8: c3a05003 movgt r5, #3 <== NOT EXECUTED
20acc: ca00000f bgt 20b10 <rtems_bdpart_unmount+0xf4> <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
20ad0: eb00187a bl 26cc0 <unmount> <== NOT EXECUTED
if (rv == 0) {
20ad4: e3500000 cmp r0, #0 <== NOT EXECUTED
/* Remove mount point */
rv = rmdir( mount_point);
20ad8: e1a00004 mov r0, r4 <== NOT EXECUTED
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
if (rv == 0) {
20adc: 1a000003 bne 20af0 <rtems_bdpart_unmount+0xd4> <== NOT EXECUTED
/* Remove mount point */
rv = rmdir( mount_point);
20ae0: eb00174f bl 26824 <rmdir> <== NOT EXECUTED
if (rv != 0) {
20ae4: e3500000 cmp r0, #0 <== NOT EXECUTED
20ae8: 13a0501b movne r5, #27 <== NOT EXECUTED
20aec: 1a000007 bne 20b10 <rtems_bdpart_unmount+0xf4> <== 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) {
20af0: e1550006 cmp r5, r6 <== NOT EXECUTED
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
20af4: e2855001 add r5, r5, #1 <== NOT EXECUTED
20af8: e3a01004 mov r1, #4 <== NOT EXECUTED
20afc: e59f201c ldr r2, [pc, #28] ; 20b20 <rtems_bdpart_unmount+0x104><== NOT EXECUTED
20b00: e1a00007 mov r0, r7 <== NOT EXECUTED
20b04: e1a03005 mov r3, 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) {
20b08: 3affffeb bcc 20abc <rtems_bdpart_unmount+0xa0> <== NOT EXECUTED
20b0c: e3a05000 mov r5, #0 <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
20b10: e1a00004 mov r0, r4 <== NOT EXECUTED
20b14: ebff9ae6 bl 76b4 <free> <== NOT EXECUTED
return esc;
}
20b18: e1a00005 mov r0, r5 <== NOT EXECUTED
20b1c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
000055dc <rtems_bdpart_unregister>:
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count
)
{
55dc: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
55e0: 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;
55e4: e3a03000 mov r3, #0 <== NOT EXECUTED
dev_t disk = 0;
55e8: e3a05000 mov r5, #0 <== NOT EXECUTED
55ec: e3a06000 mov r6, #0 <== NOT EXECUTED
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count
)
{
55f0: 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);
55f4: e28d1008 add r1, sp, #8 <== NOT EXECUTED
55f8: 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;
55fc: e58d5008 str r5, [sp, #8] <== NOT EXECUTED
5600: e58d600c str r6, [sp, #12] <== 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;
5604: e58d3010 str r3, [sp, #16] <== 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);
5608: eb006dc2 bl 20d18 <rtems_bdpart_get_disk_data> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
560c: e2507000 subs r7, r0, #0 <== NOT EXECUTED
return sc;
}
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
5610: 059d8008 ldreq r8, [sp, #8] <== NOT EXECUTED
5614: 059d600c ldreq r6, [sp, #12] <== NOT EXECUTED
)
{
union __rtems_dev_t temp;
temp.device = device;
return temp.__overlay.minor;
5618: 01a05007 moveq r5, r7 <== 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);
if (sc != RTEMS_SUCCESSFUL) {
561c: 0a000007 beq 5640 <rtems_bdpart_unregister+0x64> <== NOT EXECUTED
5620: ea000009 b 564c <rtems_bdpart_unregister+0x70> <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
5624: e58d8000 str r8, [sp] <== NOT EXECUTED
temp.__overlay.minor = _minor;
5628: e58d6004 str r6, [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);
562c: e89d0003 ldm sp, {r0, r1} <== NOT EXECUTED
5630: eb000334 bl 6308 <rtems_disk_delete> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
5634: e3500000 cmp r0, #0 <== NOT EXECUTED
5638: 1a000004 bne 5650 <rtems_bdpart_unregister+0x74> <== 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) {
563c: e2855001 add r5, r5, #1 <== NOT EXECUTED
5640: e1550004 cmp r5, r4 <== NOT EXECUTED
/* New minor number */
++minor;
5644: e2866001 add r6, r6, #1 <== 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) {
5648: 3afffff5 bcc 5624 <rtems_bdpart_unregister+0x48> <== NOT EXECUTED
564c: e1a00007 mov r0, r7 <== NOT EXECUTED
return sc;
}
}
return RTEMS_SUCCESSFUL;
}
5650: e28dd014 add sp, sp, #20 <== NOT EXECUTED
5654: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
000211b0 <rtems_bdpart_write>:
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
211b0: 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
211b4: e2518000 subs r8, r1, #0 <== NOT EXECUTED
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
211b8: e24dd034 sub sp, sp, #52 ; 0x34 <== NOT EXECUTED
211bc: e1a05002 mov r5, r2 <== NOT EXECUTED
211c0: e1a06003 mov r6, r3 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
211c4: 0a000003 beq 211d8 <rtems_bdpart_write+0x28> <== NOT EXECUTED
&& format->type == RTEMS_BDPART_FORMAT_MBR
211c8: e5983000 ldr r3, [r8] <== NOT EXECUTED
211cc: e3530000 cmp r3, #0 <== NOT EXECUTED
211d0: 05d8a008 ldrbeq sl, [r8, #8] <== NOT EXECUTED
211d4: 0a000000 beq 211dc <rtems_bdpart_write+0x2c> <== NOT EXECUTED
211d8: e3a0a000 mov sl, #0 <== 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;
211dc: e35a0000 cmp sl, #0 <== NOT EXECUTED
211e0: 13a0203f movne r2, #63 ; 0x3f <== NOT EXECUTED
211e4: 03a02001 moveq r2, #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) {
211e8: e3560000 cmp r6, #0 <== NOT EXECUTED
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& 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;
211ec: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
211f0: e20aa0ff and sl, sl, #255 ; 0xff <== 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) {
211f4: 01a00006 moveq r0, r6 <== NOT EXECUTED
211f8: 0a000120 beq 21680 <rtems_bdpart_write+0x4d0> <== NOT EXECUTED
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
211fc: e3580000 cmp r8, #0 <== NOT EXECUTED
21200: 13550000 cmpne r5, #0 <== NOT EXECUTED
21204: 13a03000 movne r3, #0 <== NOT EXECUTED
21208: 03a03001 moveq r3, #1 <== NOT EXECUTED
2120c: 03a00009 moveq r0, #9 <== NOT EXECUTED
21210: 0a00011a beq 21680 <rtems_bdpart_write+0x4d0> <== 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;
21214: e3a0c000 mov ip, #0 <== 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);
21218: e28d1020 add r1, sp, #32 <== NOT EXECUTED
2121c: 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;
21220: e3a0b000 mov fp, #0 <== NOT EXECUTED
21224: e58db020 str fp, [sp, #32] <== NOT EXECUTED
21228: e58dc024 str ip, [sp, #36] ; 0x24 <== 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;
2122c: e58d302c str r3, [sp, #44] ; 0x2c <== NOT EXECUTED
rtems_blkdev_bnum disk_end = 0;
21230: e58d3028 str r3, [sp, #40] ; 0x28 <== 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);
21234: ebfffeb7 bl 20d18 <rtems_bdpart_get_disk_data> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
21238: e3500000 cmp r0, #0 <== NOT EXECUTED
2123c: 1a00010f bne 21680 <rtems_bdpart_write+0x4d0> <== NOT EXECUTED
return sc;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
21240: e35a0000 cmp sl, #0 <== NOT EXECUTED
21244: 0a000005 beq 21260 <rtems_bdpart_write+0xb0> <== NOT EXECUTED
disk_end -= (disk_end % record_space);
21248: e59d4028 ldr r4, [sp, #40] ; 0x28 <== NOT EXECUTED
2124c: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
21250: e1a00004 mov r0, r4 <== NOT EXECUTED
21254: eb00cf7b bl 55048 <__umodsi3> <== NOT EXECUTED
21258: e0600004 rsb r0, r0, r4 <== NOT EXECUTED
2125c: 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) {
21260: e59d0028 ldr r0, [sp, #40] ; 0x28 <== NOT EXECUTED
21264: e1a07005 mov r7, r5 <== NOT EXECUTED
21268: e1a03005 mov r3, r5 <== NOT EXECUTED
2126c: e3a02000 mov r2, #0 <== NOT EXECUTED
21270: ea00000e b 212b0 <rtems_bdpart_write+0x100> <== NOT EXECUTED
21274: e5931000 ldr r1, [r3] <== NOT EXECUTED
21278: e1510000 cmp r1, r0 <== NOT EXECUTED
2127c: 2a0000f6 bcs 2165c <rtems_bdpart_write+0x4ac> <== NOT EXECUTED
21280: e593c004 ldr ip, [r3, #4] <== NOT EXECUTED
21284: e15c0000 cmp ip, r0 <== NOT EXECUTED
21288: 8a0000f3 bhi 2165c <rtems_bdpart_write+0x4ac> <== NOT EXECUTED
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that begin and end are valid */
if (p->begin >= p->end) {
2128c: e151000c cmp r1, ip <== NOT EXECUTED
21290: 2a0000f1 bcs 2165c <rtems_bdpart_write+0x4ac> <== NOT EXECUTED
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that partitions do not overlap */
if (i > 0 && pt [i - 1].end > p->begin) {
21294: e3520000 cmp r2, #0 <== NOT EXECUTED
21298: 0a000002 beq 212a8 <rtems_bdpart_write+0xf8> <== NOT EXECUTED
2129c: e513c02c ldr ip, [r3, #-44] ; 0x2c <== NOT EXECUTED
212a0: e15c0001 cmp ip, r1 <== NOT EXECUTED
212a4: 8a0000ec bhi 2165c <rtems_bdpart_write+0x4ac> <== 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) {
212a8: e2822001 add r2, r2, #1 <== NOT EXECUTED
212ac: e2833030 add r3, r3, #48 ; 0x30 <== NOT EXECUTED
212b0: e1520006 cmp r2, r6 <== NOT EXECUTED
212b4: 3affffee bcc 21274 <rtems_bdpart_write+0xc4> <== NOT EXECUTED
goto cleanup;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
212b8: e5983000 ldr r3, [r8] <== NOT EXECUTED
212bc: e3530000 cmp r3, #0 <== NOT EXECUTED
212c0: 13a04018 movne r4, #24 <== NOT EXECUTED
212c4: 1a0000e9 bne 21670 <rtems_bdpart_write+0x4c0> <== 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;
212c8: e3560004 cmp r6, #4 <== NOT EXECUTED
212cc: 91a04006 movls r4, r6 <== NOT EXECUTED
212d0: 83a04003 movhi r4, #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) {
212d4: e35a0000 cmp sl, #0 <== NOT EXECUTED
212d8: 1a000009 bne 21304 <rtems_bdpart_write+0x154> <== NOT EXECUTED
* 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) {
if ((pt [i].begin - pt [i - 1].end) < record_space) {
212dc: e3a03030 mov r3, #48 ; 0x30 <== NOT EXECUTED
212e0: e00a0493 mul sl, r3, r4 <== NOT EXECUTED
212e4: e2441001 sub r1, r4, #1 <== NOT EXECUTED
212e8: e085c00a add ip, r5, sl <== NOT EXECUTED
212ec: e0225193 mla r2, r3, r1, r5 <== NOT EXECUTED
212f0: e58da00c str sl, [sp, #12] <== NOT EXECUTED
212f4: e58dc008 str ip, [sp, #8] <== NOT EXECUTED
212f8: e1a0100c mov r1, ip <== NOT EXECUTED
212fc: e1a03004 mov r3, r4 <== NOT EXECUTED
21300: ea00000b b 21334 <rtems_bdpart_write+0x184> <== 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) {
21304: e5953000 ldr r3, [r5] <== NOT EXECUTED
21308: e353003f cmp r3, #63 ; 0x3f <== NOT EXECUTED
2130c: 1a0000d2 bne 2165c <rtems_bdpart_write+0x4ac> <== NOT EXECUTED
21310: eafffff1 b 212dc <rtems_bdpart_write+0x12c> <== NOT EXECUTED
* 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) {
if ((pt [i].begin - pt [i - 1].end) < record_space) {
21314: e5920004 ldr r0, [r2, #4] <== NOT EXECUTED
21318: e491c030 ldr ip, [r1], #48 ; 0x30 <== NOT EXECUTED
2131c: e59da004 ldr sl, [sp, #4] <== NOT EXECUTED
21320: e060000c rsb r0, r0, ip <== NOT EXECUTED
21324: e150000a cmp r0, sl <== NOT EXECUTED
21328: e2822030 add r2, r2, #48 ; 0x30 <== NOT EXECUTED
2132c: 3a0000ca bcc 2165c <rtems_bdpart_write+0x4ac> <== 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) {
21330: e2833001 add r3, r3, #1 <== NOT EXECUTED
21334: e1530006 cmp r3, r6 <== NOT EXECUTED
21338: 3afffff5 bcc 21314 <rtems_bdpart_write+0x164> <== NOT EXECUTED
2133c: e3a09000 mov r9, #0 <== NOT EXECUTED
21340: e1a0a005 mov sl, r5 <== NOT EXECUTED
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
uint8_t type = 0;
21344: e1a0b009 mov fp, r9 <== NOT EXECUTED
const rtems_bdpart_partition *p = pt + i;
/* Check type */
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
21348: e28d3033 add r3, sp, #51 ; 0x33 <== NOT EXECUTED
2134c: ea00000d b 21388 <rtems_bdpart_write+0x1d8> <== NOT EXECUTED
21350: e58d3000 str r3, [sp] <== NOT EXECUTED
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
uint8_t type = 0;
21354: e5cdb033 strb fp, [sp, #51] ; 0x33 <== NOT EXECUTED
const rtems_bdpart_partition *p = pt + i;
/* Check type */
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
21358: ebfffe8d bl 20d94 <rtems_bdpart_to_mbr_partition_type> <== NOT EXECUTED
2135c: e3500000 cmp r0, #0 <== NOT EXECUTED
21360: e59d3000 ldr r3, [sp] <== NOT EXECUTED
21364: 0a0000be beq 21664 <rtems_bdpart_write+0x4b4> <== NOT EXECUTED
esc = RTEMS_INVALID_ID;
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
21368: e59a202c ldr r2, [sl, #44] ; 0x2c <== NOT EXECUTED
2136c: e3520000 cmp r2, #0 <== NOT EXECUTED
21370: e59a2028 ldr r2, [sl, #40] ; 0x28 <== NOT EXECUTED
21374: e28aa030 add sl, sl, #48 ; 0x30 <== NOT EXECUTED
21378: 1a0000b9 bne 21664 <rtems_bdpart_write+0x4b4> <== NOT EXECUTED
2137c: e35200ff cmp r2, #255 ; 0xff <== NOT EXECUTED
21380: 8a0000b7 bhi 21664 <rtems_bdpart_write+0x4b4> <== NOT EXECUTED
goto cleanup;
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
21384: e2899001 add r9, r9, #1 <== NOT EXECUTED
21388: e1590006 cmp r9, r6 <== 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)) {
2138c: e28a0008 add r0, sl, #8 <== NOT EXECUTED
21390: e1a01003 mov r1, r3 <== NOT EXECUTED
goto cleanup;
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
21394: 3affffed bcc 21350 <rtems_bdpart_write+0x1a0> <== NOT EXECUTED
/* Check ID */
/* TODO */
}
/* New MBR */
sc = rtems_bdpart_new_record( disk, 0, &block);
21398: e28d1020 add r1, sp, #32 <== NOT EXECUTED
2139c: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
213a0: e3a02000 mov r2, #0 <== NOT EXECUTED
213a4: e28d302c add r3, sp, #44 ; 0x2c <== NOT EXECUTED
213a8: ebffff5b bl 2111c <rtems_bdpart_new_record> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
213ac: e3500000 cmp r0, #0 <== NOT EXECUTED
213b0: 1a000085 bne 215cc <rtems_bdpart_write+0x41c> <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Write disk ID */
rtems_uint32_to_little_endian(
213b4: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED
213b8: e5982004 ldr r2, [r8, #4] <== NOT EXECUTED
213bc: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
data [i] = (uint8_t) value;
value >>= 8;
213c0: 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;
213c4: e1a08c22 lsr r8, r2, #24 <== NOT EXECUTED
value >>= 8;
213c8: e1a0c422 lsr ip, r2, #8 <== 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;
213cc: e5c311ba strb r1, [r3, #442] ; 0x1ba <== NOT EXECUTED
213d0: e5c381bb strb r8, [r3, #443] ; 0x1bb <== NOT EXECUTED
213d4: e5c3c1b9 strb ip, [r3, #441] ; 0x1b9 <== NOT EXECUTED
213d8: 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;
213dc: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED
213e0: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
213e4: e2831f6f add r1, r3, #444 ; 0x1bc <== NOT EXECUTED
213e8: e2811002 add r1, r1, #2 <== NOT EXECUTED
for (i = 0; i < ppc; ++i) {
213ec: ea00001e b 2146c <rtems_bdpart_write+0x2bc> <== NOT EXECUTED
const rtems_bdpart_partition *p = pt + i;
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
213f0: e8971004 ldm r7, {r2, ip} <== NOT EXECUTED
static inline uint8_t rtems_bdpart_mbr_partition_type(
const uuid_t type
)
{
return type [0];
213f4: e5d78008 ldrb r8, [r7, #8] <== NOT EXECUTED
data,
p->begin,
p->end - p->begin,
rtems_bdpart_mbr_partition_type( p->type),
(uint8_t) p->flags
213f8: e597a028 ldr sl, [r7, #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(
213fc: e062c00c rsb ip, r2, ip <== NOT EXECUTED
21400: e58d8014 str r8, [sp, #20] <== NOT EXECUTED
21404: e1a08c2c lsr r8, ip, #24 <== NOT EXECUTED
data,
p->begin,
p->end - p->begin,
rtems_bdpart_mbr_partition_type( p->type),
(uint8_t) p->flags
21408: e58da01c str sl, [sp, #28] <== NOT EXECUTED
2140c: e58d8018 str r8, [sp, #24] <== NOT EXECUTED
value >>= 8;
21410: e1a0a822 lsr sl, r2, #16 <== NOT EXECUTED
21414: e1a0842c lsr r8, ip, #8 <== NOT EXECUTED
21418: e1a09422 lsr r9, r2, #8 <== 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;
2141c: e1a0bc22 lsr fp, r2, #24 <== NOT EXECUTED
value >>= 8;
21420: 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;
21424: e5c391c7 strb r9, [r3, #455] ; 0x1c7 <== NOT EXECUTED
21428: e5c3a1c8 strb sl, [r3, #456] ; 0x1c8 <== NOT EXECUTED
2142c: e5c3b1c9 strb fp, [r3, #457] ; 0x1c9 <== NOT EXECUTED
21430: e59da010 ldr sl, [sp, #16] <== NOT EXECUTED
value >>= 8;
21434: e1a0882c lsr r8, ip, #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;
21438: e5c3a1cb strb sl, [r3, #459] ; 0x1cb <== NOT EXECUTED
2143c: e5c381cc strb r8, [r3, #460] ; 0x1cc <== NOT EXECUTED
21440: e59d8018 ldr r8, [sp, #24] <== NOT EXECUTED
21444: e5c381cd strb r8, [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;
21448: e59da014 ldr sl, [sp, #20] <== NOT EXECUTED
2144c: e5c3a1c2 strb sl, [r3, #450] ; 0x1c2 <== NOT EXECUTED
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
21450: e59d801c ldr r8, [sp, #28] <== 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) {
21454: e2800001 add r0, r0, #1 <== 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;
21458: e5c381be strb r8, [r3, #446] ; 0x1be <== NOT EXECUTED
2145c: e5c321c6 strb r2, [r3, #454] ; 0x1c6 <== NOT EXECUTED
21460: e5c3c1ca strb ip, [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) {
21464: e2877030 add r7, r7, #48 ; 0x30 <== NOT EXECUTED
21468: e2833010 add r3, r3, #16 <== NOT EXECUTED
2146c: e1500004 cmp r0, r4 <== NOT EXECUTED
21470: 3affffde bcc 213f0 <rtems_bdpart_write+0x240> <== NOT EXECUTED
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
}
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
21474: e1540006 cmp r4, r6 <== 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) {
21478: e0813204 add r3, r1, r4, lsl #4 <== NOT EXECUTED
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
}
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
2147c: 0a00007a beq 2166c <rtems_bdpart_write+0x4bc> <== 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;
21480: e59da00c ldr sl, [sp, #12] <== NOT EXECUTED
21484: e59dc004 ldr ip, [sp, #4] <== NOT EXECUTED
21488: e795700a ldr r7, [r5, sl] <== NOT EXECUTED
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
2148c: e59d2028 ldr r2, [sp, #40] ; 0x28 <== 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;
21490: e06c7007 rsb r7, ip, r7 <== NOT EXECUTED
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
21494: e0672002 rsb r2, r7, r2 <== NOT EXECUTED
value >>= 8;
21498: e1a05427 lsr r5, r7, #8 <== NOT EXECUTED
2149c: e58d5018 str r5, [sp, #24] <== NOT EXECUTED
214a0: e1a05422 lsr r5, r2, #8 <== NOT EXECUTED
214a4: e58d5010 str r5, [sp, #16] <== NOT EXECUTED
uint32_t size,
uint8_t type,
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
214a8: e283c008 add ip, r3, #8 <== 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;
214ac: e1a00c22 lsr r0, r2, #24 <== NOT EXECUTED
value >>= 8;
214b0: e1a05822 lsr r5, 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;
214b4: e1a09c27 lsr r9, r7, #24 <== NOT EXECUTED
214b8: e58d0014 str r0, [sp, #20] <== NOT EXECUTED
value >>= 8;
214bc: e58d500c str r5, [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;
214c0: e5c37008 strb r7, [r3, #8] <== NOT EXECUTED
214c4: e5cc9003 strb r9, [ip, #3] <== NOT EXECUTED
214c8: e59d5018 ldr r5, [sp, #24] <== NOT EXECUTED
value >>= 8;
214cc: e1a0b827 lsr fp, r7, #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;
214d0: e5cc5001 strb r5, [ip, #1] <== NOT EXECUTED
214d4: e5ccb002 strb fp, [ip, #2] <== 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;
214d8: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED
214dc: e5c3200c strb r2, [r3, #12] <== NOT EXECUTED
214e0: e59d2014 ldr r2, [sp, #20] <== 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);
214e4: e283000c add r0, r3, #12 <== NOT EXECUTED
214e8: e5c02003 strb r2, [r0, #3] <== NOT EXECUTED
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
214ec: e28c5004 add r5, ip, #4 <== NOT EXECUTED
214f0: e59dc010 ldr ip, [sp, #16] <== NOT EXECUTED
214f4: e5c0c001 strb ip, [r0, #1] <== NOT EXECUTED
214f8: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
214fc: e3a08000 mov r8, #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;
21500: e3a0a005 mov sl, #5 <== NOT EXECUTED
21504: e5c02002 strb r2, [r0, #2] <== NOT EXECUTED
21508: e5c3a004 strb sl, [r3, #4] <== NOT EXECUTED
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
2150c: e7c18204 strb r8, [r1, r4, lsl #4] <== NOT EXECUTED
21510: e1a08004 mov r8, r4 <== NOT EXECUTED
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
21514: ea00004d b 21650 <rtems_bdpart_write+0x4a0> <== NOT EXECUTED
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
21518: e1580004 cmp r8, r4 <== NOT EXECUTED
2151c: 9a000021 bls 215a8 <rtems_bdpart_write+0x3f8> <== NOT EXECUTED
rtems_blkdev_bnum begin = p->begin - record_space;
rtems_bdpart_write_mbr_partition(
21520: 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;
21524: e59da004 ldr sl, [sp, #4] <== NOT EXECUTED
21528: e5151004 ldr r1, [r5, #-4] <== NOT EXECUTED
rtems_bdpart_write_mbr_partition(
2152c: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
21530: e59d2028 ldr r2, [sp, #40] ; 0x28 <== 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;
21534: e06a1001 rsb r1, sl, r1 <== NOT EXECUTED
rtems_bdpart_write_mbr_partition(
21538: e0612002 rsb r2, r1, r2 <== NOT EXECUTED
2153c: e283cf73 add ip, r3, #460 ; 0x1cc <== NOT EXECUTED
21540: e0671001 rsb r1, r7, r1 <== NOT EXECUTED
21544: e1a0ec22 lsr lr, r2, #24 <== NOT EXECUTED
21548: e28cc002 add ip, ip, #2 <== NOT EXECUTED
2154c: e58de00c str lr, [sp, #12] <== 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);
21550: e28c000c add r0, ip, #12 <== NOT EXECUTED
value >>= 8;
21554: e1a0e422 lsr lr, r2, #8 <== NOT EXECUTED
uint32_t size,
uint8_t type,
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
21558: e28cc008 add ip, ip, #8 <== NOT EXECUTED
2155c: e1a0a821 lsr sl, 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;
21560: e1a0bc21 lsr fp, r1, #24 <== NOT EXECUTED
value >>= 8;
21564: e1a09421 lsr r9, r1, #8 <== NOT EXECUTED
21568: e58de008 str lr, [sp, #8] <== 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;
2156c: e5c311d6 strb r1, [r3, #470] ; 0x1d6 <== NOT EXECUTED
21570: e5ccb003 strb fp, [ip, #3] <== NOT EXECUTED
21574: e5cc9001 strb r9, [ip, #1] <== NOT EXECUTED
21578: e5cca002 strb sl, [ip, #2] <== NOT EXECUTED
2157c: e5c321da strb r2, [r3, #474] ; 0x1da <== NOT EXECUTED
value >>= 8;
21580: 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;
21584: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
21588: e5c02003 strb r2, [r0, #3] <== NOT EXECUTED
2158c: e59da008 ldr sl, [sp, #8] <== 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;
21590: e3a0c000 mov ip, #0 <== NOT EXECUTED
21594: 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;
21598: e3a0e005 mov lr, #5 <== NOT EXECUTED
2159c: e5c0a001 strb sl, [r0, #1] <== NOT EXECUTED
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
215a0: e5c3c1ce strb ip, [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;
215a4: e5c3e1d2 strb lr, [r3, #466] ; 0x1d2 <== NOT EXECUTED
);
}
/* New EBR */
ebr = p->begin - record_space;
sc = rtems_bdpart_new_record( disk, ebr, &block);
215a8: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
215ac: e5152004 ldr r2, [r5, #-4] <== NOT EXECUTED
215b0: e28d302c add r3, sp, #44 ; 0x2c <== NOT EXECUTED
215b4: e0602002 rsb r2, r0, r2 <== NOT EXECUTED
215b8: e28d1020 add r1, sp, #32 <== NOT EXECUTED
215bc: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
215c0: ebfffed5 bl 2111c <rtems_bdpart_new_record> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
215c4: e3500000 cmp r0, #0 <== NOT EXECUTED
215c8: 0a000001 beq 215d4 <rtems_bdpart_write+0x424> <== NOT EXECUTED
215cc: e1a04000 mov r4, r0 <== NOT EXECUTED
215d0: ea000026 b 21670 <rtems_bdpart_write+0x4c0> <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
215d4: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED
215d8: e5d50004 ldrb r0, [r5, #4] <== NOT EXECUTED
215dc: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
215e0: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
215e4: e2831f6f add r1, r3, #444 ; 0x1bc <== NOT EXECUTED
215e8: e595a000 ldr sl, [r5] <== NOT EXECUTED
215ec: e515c004 ldr ip, [r5, #-4] <== 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
215f0: e595b024 ldr fp, [r5, #36] ; 0x24 <== NOT EXECUTED
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
215f4: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
rtems_bdpart_write_mbr_partition(
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
215f8: e1a02003 mov r2, r3 <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
215fc: e2811002 add r1, r1, #2 <== NOT EXECUTED
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
21600: e2839004 add r9, r3, #4 <== NOT EXECUTED
21604: e5c201c6 strb r0, [r2, #454] ; 0x1c6 <== NOT EXECUTED
21608: e2822001 add r2, r2, #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) {
2160c: e1520009 cmp r2, r9 <== NOT EXECUTED
data [i] = (uint8_t) value;
21610: e3a00000 mov r0, #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) {
21614: 1afffffa bne 21604 <rtems_bdpart_write+0x454> <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
21618: e06cc00a rsb ip, ip, sl <== 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);
2161c: e281100c add r1, r1, #12 <== NOT EXECUTED
data [i] = (uint8_t) value;
value >>= 8;
21620: e1a0282c lsr r2, ip, #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;
21624: e1a0ac2c lsr sl, ip, #24 <== NOT EXECUTED
value >>= 8;
21628: e1a0042c lsr r0, ip, #8 <== 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;
2162c: e5c3c1ca strb ip, [r3, #458] ; 0x1ca <== NOT EXECUTED
21630: e5c1a003 strb sl, [r1, #3] <== NOT EXECUTED
21634: e5c10001 strb r0, [r1, #1] <== NOT EXECUTED
21638: e5c12002 strb r2, [r1, #2] <== NOT EXECUTED
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
2163c: e5c3b1be strb fp, [r3, #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;
21640: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED
21644: e5c321c2 strb r2, [r3, #450] ; 0x1c2 <== NOT EXECUTED
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
21648: e2888001 add r8, r8, #1 <== NOT EXECUTED
2164c: e2855030 add r5, r5, #48 ; 0x30 <== NOT EXECUTED
21650: e1580006 cmp r8, r6 <== NOT EXECUTED
21654: 3affffaf bcc 21518 <rtems_bdpart_write+0x368> <== NOT EXECUTED
21658: ea000003 b 2166c <rtems_bdpart_write+0x4bc> <== NOT EXECUTED
2165c: e3a0400a mov r4, #10 <== NOT EXECUTED
21660: ea000002 b 21670 <rtems_bdpart_write+0x4c0> <== NOT EXECUTED
21664: e3a04004 mov r4, #4 <== NOT EXECUTED
21668: ea000000 b 21670 <rtems_bdpart_write+0x4c0> <== NOT EXECUTED
2166c: e3a04000 mov r4, #0 <== NOT EXECUTED
}
}
cleanup:
if (block != NULL) {
21670: e59d002c ldr r0, [sp, #44] ; 0x2c <== NOT EXECUTED
21674: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_bdbuf_sync( block);
21678: 1bff8d0f blne 4abc <rtems_bdbuf_sync> <== NOT EXECUTED
2167c: e1a00004 mov r0, r4 <== NOT EXECUTED
}
return esc;
}
21680: e28dd034 add sp, sp, #52 ; 0x34 <== NOT EXECUTED
21684: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0000c008 <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)
c008: e5921004 ldr r1, [r2, #4]
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;
c00c: e5923000 ldr r3, [r2]
rtems_device_driver
rtems_blkdev_generic_ioctl(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
c010: e92d4010 push {r4, lr}
c014: e1a04002 mov r4, r2
rtems_libio_ioctl_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
int rc;
switch (args->command)
c018: e59f20c0 ldr r2, [pc, #192] ; c0e0 <rtems_blkdev_generic_ioctl+0xd8>
c01c: e1510002 cmp r1, r2
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;
c020: e5933034 ldr r3, [r3, #52] ; 0x34
int rc;
switch (args->command)
c024: 0a000013 beq c078 <rtems_blkdev_generic_ioctl+0x70>
c028: 8a000006 bhi c048 <rtems_blkdev_generic_ioctl+0x40>
c02c: e59f20b0 ldr r2, [pc, #176] ; c0e4 <rtems_blkdev_generic_ioctl+0xdc><== NOT EXECUTED
c030: e1510002 cmp r1, r2 <== NOT EXECUTED
c034: 0a00001b beq c0a8 <rtems_blkdev_generic_ioctl+0xa0> <== NOT EXECUTED
c038: e59f20a8 ldr r2, [pc, #168] ; c0e8 <rtems_blkdev_generic_ioctl+0xe0><== NOT EXECUTED
c03c: e1510002 cmp r1, r2 <== NOT EXECUTED
c040: 1a00001f bne c0c4 <rtems_blkdev_generic_ioctl+0xbc> <== NOT EXECUTED
c044: ea000009 b c070 <rtems_blkdev_generic_ioctl+0x68> <== NOT EXECUTED
c048: e59f209c ldr r2, [pc, #156] ; c0ec <rtems_blkdev_generic_ioctl+0xe4>
c04c: e1510002 cmp r1, r2
c050: 0a00000e beq c090 <rtems_blkdev_generic_ioctl+0x88>
c054: e59f2094 ldr r2, [pc, #148] ; c0f0 <rtems_blkdev_generic_ioctl+0xe8><== NOT EXECUTED
c058: e1510002 cmp r1, r2 <== NOT EXECUTED
c05c: 0a000016 beq c0bc <rtems_blkdev_generic_ioctl+0xb4> <== NOT EXECUTED
c060: e59f208c ldr r2, [pc, #140] ; c0f4 <rtems_blkdev_generic_ioctl+0xec><== NOT EXECUTED
c064: e1510002 cmp r1, r2 <== NOT EXECUTED
c068: 1a000015 bne c0c4 <rtems_blkdev_generic_ioctl+0xbc> <== NOT EXECUTED
c06c: ea00000b b c0a0 <rtems_blkdev_generic_ioctl+0x98> <== NOT EXECUTED
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*((uint32_t *) args->buffer) = dd->media_block_size;
c070: e5932024 ldr r2, [r3, #36] ; 0x24 <== NOT EXECUTED
c074: ea000000 b c07c <rtems_blkdev_generic_ioctl+0x74> <== NOT EXECUTED
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*((uint32_t *) args->buffer) = dd->block_size;
c078: e5932020 ldr r2, [r3, #32] <== NOT EXECUTED
c07c: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
c080: e5832000 str r2, [r3] <== NOT EXECUTED
args->ioctl_return = 0;
c084: e3a03000 mov r3, #0
c088: e584300c str r3, [r4, #12]
break;
c08c: ea000011 b c0d8 <rtems_blkdev_generic_ioctl+0xd0>
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *((uint32_t *) args->buffer);
c090: e5942008 ldr r2, [r4, #8]
c094: e5922000 ldr r2, [r2]
c098: e5832020 str r2, [r3, #32]
c09c: eafffff8 b c084 <rtems_blkdev_generic_ioctl+0x7c>
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_GETSIZE:
*((rtems_blkdev_bnum *) args->buffer) = dd->size;
c0a0: e593201c ldr r2, [r3, #28] <== NOT EXECUTED
c0a4: eafffff4 b c07c <rtems_blkdev_generic_ioctl+0x74> <== NOT EXECUTED
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_SYNCDEV:
rc = rtems_bdbuf_syncdev(dd->dev);
c0a8: e8930003 ldm r3, {r0, r1} <== NOT EXECUTED
c0ac: ebfff814 bl a104 <rtems_bdbuf_syncdev> <== NOT EXECUTED
args->ioctl_return = (uint32_t) (rc == RTEMS_SUCCESSFUL ? 0 : -1);
c0b0: e3500000 cmp r0, #0 <== NOT EXECUTED
c0b4: 13e00000 mvnne r0, #0 <== NOT EXECUTED
c0b8: ea000005 b c0d4 <rtems_blkdev_generic_ioctl+0xcc> <== NOT EXECUTED
case RTEMS_BLKIO_REQUEST:
/*
* It is not allowed to directly access the driver circumventing
* the cache.
*/
args->ioctl_return = (uint32_t) -1;
c0bc: e3e03000 mvn r3, #0 <== NOT EXECUTED
c0c0: eafffff0 b c088 <rtems_blkdev_generic_ioctl+0x80> <== NOT EXECUTED
break;
default:
args->ioctl_return = (uint32_t) dd->ioctl(dd->phys_dev,
c0c4: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
c0c8: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED
c0cc: e1a0e00f mov lr, pc <== NOT EXECUTED
c0d0: e593f028 ldr pc, [r3, #40] ; 0x28 <== NOT EXECUTED
c0d4: e584000c str r0, [r4, #12] <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
c0d8: e3a00000 mov r0, #0
c0dc: e8bd8010 pop {r4, pc}
0000c230 <rtems_blkdev_generic_read>:
void * arg)
{
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;
c230: e5923000 ldr r3, [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)
{
c234: e92d4ff7 push {r0, r1, r2, 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;
c238: e5938034 ldr r8, [r3, #52] ; 0x34 <== 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);
c23c: e9920c00 ldmib r2, {sl, fp} <== 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;
c240: e5986020 ldr r6, [r8, #32] <== NOT EXECUTED
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
c244: e3a05000 mov r5, #0 <== 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)
{
c248: e1a04002 mov r4, r2 <== 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);
c24c: e1a03005 mov r3, r5 <== NOT EXECUTED
c250: e1a0100b mov r1, fp <== NOT EXECUTED
c254: e1a02006 mov r2, r6 <== NOT EXECUTED
c258: e1a0000a mov r0, sl <== NOT EXECUTED
c25c: eb003b9c bl 1b0d4 <__divdi3> <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
c260: e1a03005 mov r3, r5 <== NOT EXECUTED
c264: e1a0100b mov r1, fp <== NOT EXECUTED
c268: e1a02006 mov r2, r6 <== 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);
c26c: e1a07000 mov r7, r0 <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
c270: e1a0000a mov r0, sl <== NOT EXECUTED
c274: eb003cc0 bl 1b57c <__moddi3> <== NOT EXECUTED
dev_t dev = dd->dev;
c278: e898000c ldm r8, {r2, r3} <== NOT EXECUTED
args->bytes_moved = 0;
c27c: e5845018 str r5, [r4, #24] <== NOT EXECUTED
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);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
c280: e1a09000 mov r9, r0 <== NOT EXECUTED
dev_t dev = dd->dev;
c284: e88d000c stm sp, {r2, r3} <== 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;
c288: e594800c ldr r8, [r4, #12] <== NOT EXECUTED
uint32_t count = args->count;
c28c: e5945010 ldr r5, [r4, #16] <== NOT EXECUTED
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dev, block, &diskbuf);
c290: e28db008 add fp, sp, #8 <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
c294: ea000016 b c2f4 <rtems_blkdev_generic_read+0xc4> <== NOT EXECUTED
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dev, block, &diskbuf);
c298: ebfffe7b bl bc8c <rtems_bdbuf_read> <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
c29c: e2503000 subs r3, r0, #0 <== NOT EXECUTED
break;
copy = block_size - blkofs;
c2a0: e069a006 rsb sl, r9, r6 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
c2a4: e1a00008 mov r0, r8 <== NOT EXECUTED
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dev, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
c2a8: 1a000017 bne c30c <rtems_blkdev_generic_read+0xdc> <== NOT EXECUTED
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
c2ac: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
c2b0: 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;
c2b4: e15a0005 cmp sl, r5 <== NOT EXECUTED
c2b8: 21a0a005 movcs sl, r5 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
c2bc: e1a0200a mov r2, sl <== NOT EXECUTED
c2c0: e0811009 add r1, r1, r9 <== NOT EXECUTED
c2c4: eb00152f bl 11788 <memcpy> <== NOT EXECUTED
rc = rtems_bdbuf_release(diskbuf);
c2c8: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED
c2cc: ebfffa2e bl ab8c <rtems_bdbuf_release> <== NOT EXECUTED
args->bytes_moved += copy;
c2d0: e5942018 ldr r2, [r4, #24] <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
c2d4: 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;
c2d8: e082200a add r2, r2, sl <== NOT EXECUTED
c2dc: e5842018 str r2, [r4, #24] <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
c2e0: 1a000009 bne c30c <rtems_blkdev_generic_read+0xdc> <== NOT EXECUTED
break;
count -= copy;
buf += copy;
c2e4: e088800a add r8, r8, sl <== NOT EXECUTED
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
rc = rtems_bdbuf_release(diskbuf);
args->bytes_moved += copy;
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
c2e8: e06a5005 rsb r5, sl, r5 <== NOT EXECUTED
buf += copy;
blkofs = 0;
block++;
c2ec: e2877001 add r7, r7, #1 <== NOT EXECUTED
c2f0: e1a09003 mov r9, r3 <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
c2f4: e3550000 cmp r5, #0 <== NOT EXECUTED
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dev, block, &diskbuf);
c2f8: e1a02007 mov r2, r7 <== NOT EXECUTED
c2fc: e1a0300b mov r3, fp <== NOT EXECUTED
c300: e89d0003 ldm sp, {r0, r1} <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
c304: 1affffe3 bne c298 <rtems_blkdev_generic_read+0x68> <== NOT EXECUTED
c308: e1a03005 mov r3, r5 <== NOT EXECUTED
blkofs = 0;
block++;
}
return rc;
}
c30c: e1a00003 mov r0, r3 <== NOT EXECUTED
c310: e8bd8ffe pop {r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}<== NOT EXECUTED
0000c130 <rtems_blkdev_generic_write>:
void * arg)
{
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;
c130: e5923000 ldr r3, [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)
{
c134: e92d4ff7 push {r0, r1, r2, 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;
c138: e593a034 ldr sl, [r3, #52] ; 0x34 <== 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);
c13c: e9920300 ldmib r2, {r8, r9} <== 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;
c140: e59a6020 ldr r6, [sl, #32] <== NOT EXECUTED
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
c144: e3a05000 mov r5, #0 <== 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)
{
c148: e1a04002 mov r4, r2 <== 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);
c14c: e1a03005 mov r3, r5 <== NOT EXECUTED
c150: e1a00008 mov r0, r8 <== NOT EXECUTED
c154: e1a01009 mov r1, r9 <== NOT EXECUTED
c158: e1a02006 mov r2, r6 <== NOT EXECUTED
c15c: eb003bdc bl 1b0d4 <__divdi3> <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
c160: e1a03005 mov r3, r5 <== NOT EXECUTED
c164: e1a01009 mov r1, r9 <== NOT EXECUTED
c168: e1a02006 mov r2, r6 <== 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);
c16c: e1a07000 mov r7, r0 <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
c170: e1a00008 mov r0, r8 <== NOT EXECUTED
c174: eb003d00 bl 1b57c <__moddi3> <== NOT EXECUTED
dev_t dev = dd->dev;
c178: e89a000c ldm sl, {r2, r3} <== NOT EXECUTED
args->bytes_moved = 0;
c17c: e5845018 str r5, [r4, #24] <== NOT EXECUTED
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);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
c180: e1a08000 mov r8, r0 <== NOT EXECUTED
dev_t dev = dd->dev;
c184: e88d000c stm sp, {r2, r3} <== 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;
c188: e594900c ldr r9, [r4, #12] <== NOT EXECUTED
uint32_t count = args->count;
c18c: e5945010 ldr r5, [r4, #16] <== NOT EXECUTED
c190: e28db008 add fp, sp, #8 <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
c194: ea000021 b c220 <rtems_blkdev_generic_write+0xf0> <== NOT EXECUTED
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
c198: e1550006 cmp r5, r6 <== NOT EXECUTED
c19c: 23580000 cmpcs r8, #0 <== NOT EXECUTED
c1a0: 1a000004 bne c1b8 <rtems_blkdev_generic_write+0x88> <== NOT EXECUTED
rc = rtems_bdbuf_get(dev, block, &diskbuf);
c1a4: e89d0003 ldm sp, {r0, r1} <== NOT EXECUTED
c1a8: e1a02007 mov r2, r7 <== NOT EXECUTED
c1ac: e1a0300b mov r3, fp <== NOT EXECUTED
c1b0: ebfffe82 bl bbc0 <rtems_bdbuf_get> <== NOT EXECUTED
c1b4: ea000003 b c1c8 <rtems_blkdev_generic_write+0x98> <== NOT EXECUTED
else
rc = rtems_bdbuf_read(dev, block, &diskbuf);
c1b8: e1a02007 mov r2, r7 <== NOT EXECUTED
c1bc: e1a0300b mov r3, fp <== NOT EXECUTED
c1c0: e89d0003 ldm sp, {r0, r1} <== NOT EXECUTED
c1c4: ebfffeb0 bl bc8c <rtems_bdbuf_read> <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
c1c8: e3500000 cmp r0, #0 <== NOT EXECUTED
break;
copy = block_size - blkofs;
c1cc: e068a006 rsb sl, r8, r6 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
c1d0: e1a01009 mov r1, r9 <== 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)
c1d4: 1a000014 bne c22c <rtems_blkdev_generic_write+0xfc> <== NOT EXECUTED
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
c1d8: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
c1dc: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED
else
rc = rtems_bdbuf_read(dev, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
c1e0: e15a0005 cmp sl, r5 <== NOT EXECUTED
c1e4: 21a0a005 movcs sl, r5 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
c1e8: e1a0200a mov r2, sl <== NOT EXECUTED
c1ec: e0800008 add r0, r0, r8 <== NOT EXECUTED
c1f0: eb001564 bl 11788 <memcpy> <== NOT EXECUTED
args->bytes_moved += copy;
c1f4: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED
c1f8: e083300a add r3, r3, sl <== NOT EXECUTED
c1fc: e5843018 str r3, [r4, #24] <== NOT EXECUTED
rc = rtems_bdbuf_release_modified(diskbuf);
c200: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED
c204: ebfffa3e bl ab04 <rtems_bdbuf_release_modified> <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
c208: e3500000 cmp r0, #0 <== NOT EXECUTED
c20c: 1a000006 bne c22c <rtems_blkdev_generic_write+0xfc> <== NOT EXECUTED
break;
count -= copy;
buf += copy;
c210: e089900a add r9, r9, sl <== NOT EXECUTED
rc = rtems_bdbuf_release_modified(diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
c214: e06a5005 rsb r5, sl, r5 <== NOT EXECUTED
buf += copy;
blkofs = 0;
block++;
c218: e2877001 add r7, r7, #1 <== NOT EXECUTED
c21c: e1a08000 mov r8, r0 <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
c220: e3550000 cmp r5, #0 <== NOT EXECUTED
c224: 1affffdb bne c198 <rtems_blkdev_generic_write+0x68> <== NOT EXECUTED
c228: e1a00005 mov r0, r5 <== NOT EXECUTED
blkofs = 0;
block++;
}
return rc;
}
c22c: e8bd8ffe pop {r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}<== NOT EXECUTED
0000bf80 <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)
bf80: e59f3078 ldr r3, [pc, #120] ; c000 <rtems_blkdev_ioctl+0x80>
bf84: e1510003 cmp r1, r3
return RTEMS_SUCCESSFUL;
}
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
bf88: e52de004 push {lr} ; (str lr, [sp, #-4]!)
size_t *arg_size = argp;
int rc = 0;
switch (req)
bf8c: 0a00000d beq bfc8 <rtems_blkdev_ioctl+0x48>
bf90: 8a000003 bhi bfa4 <rtems_blkdev_ioctl+0x24>
bf94: e2433001 sub r3, r3, #1
bf98: e1510003 cmp r1, r3
bf9c: 1a000012 bne bfec <rtems_blkdev_ioctl+0x6c>
bfa0: ea000006 b bfc0 <rtems_blkdev_ioctl+0x40> <== NOT EXECUTED
bfa4: e59f3058 ldr r3, [pc, #88] ; c004 <rtems_blkdev_ioctl+0x84><== NOT EXECUTED
bfa8: e1510003 cmp r1, r3 <== NOT EXECUTED
bfac: 0a00000a beq bfdc <rtems_blkdev_ioctl+0x5c> <== NOT EXECUTED
bfb0: e2433107 sub r3, r3, #-1073741823 ; 0xc0000001 <== NOT EXECUTED
bfb4: e1510003 cmp r1, r3 <== NOT EXECUTED
bfb8: 1a00000b bne bfec <rtems_blkdev_ioctl+0x6c> <== NOT EXECUTED
bfbc: ea000003 b bfd0 <rtems_blkdev_ioctl+0x50> <== NOT EXECUTED
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*arg_size = dd->media_block_size;
bfc0: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED
bfc4: ea000005 b bfe0 <rtems_blkdev_ioctl+0x60> <== NOT EXECUTED
break;
case RTEMS_BLKIO_GETBLKSIZE:
*arg_size = dd->block_size;
bfc8: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED
bfcc: ea000003 b bfe0 <rtems_blkdev_ioctl+0x60> <== NOT EXECUTED
break;
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *arg_size;
bfd0: e5923000 ldr r3, [r2] <== NOT EXECUTED
bfd4: e5803020 str r3, [r0, #32] <== NOT EXECUTED
bfd8: ea000001 b bfe4 <rtems_blkdev_ioctl+0x64> <== NOT EXECUTED
break;
case RTEMS_BLKIO_GETSIZE:
*arg_size = dd->size;
bfdc: e590301c ldr r3, [r0, #28] <== NOT EXECUTED
bfe0: e5823000 str r3, [r2] <== NOT EXECUTED
bfe4: e3a00000 mov r0, #0 <== NOT EXECUTED
break;
bfe8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
default:
errno = EINVAL;
bfec: eb0013d7 bl 10f50 <__errno>
bff0: e3a03016 mov r3, #22
bff4: e5803000 str r3, [r0]
bff8: e3e00000 mvn r0, #0
rc = -1;
break;
}
return rc;
}
bffc: e49df004 pop {pc} ; (ldr pc, [sp], #4)
00001868 <rtems_bsp_cmdline_get_param>:
size_t length
)
{
const char *p;
if ( !name )
1868: e3500000 cmp r0, #0
const char *rtems_bsp_cmdline_get_param(
const char *name,
char *value,
size_t length
)
{
186c: e92d4070 push {r4, r5, r6, lr}
1870: e1a04001 mov r4, r1
1874: e1a05002 mov r5, r2
const char *p;
if ( !name )
1878: 0a00001c beq 18f0 <rtems_bsp_cmdline_get_param+0x88>
return NULL;
if ( !value )
187c: e3510000 cmp r1, #0
1880: 0a00001b beq 18f4 <rtems_bsp_cmdline_get_param+0x8c>
return NULL;
if ( !length )
1884: e3520000 cmp r2, #0
1888: 0a000018 beq 18f0 <rtems_bsp_cmdline_get_param+0x88>
return NULL;
value[0] = '\0';
188c: e3a06000 mov r6, #0
1890: e5c16000 strb r6, [r1]
p = rtems_bsp_cmdline_get_param_raw( name );
1894: eb000018 bl 18fc <rtems_bsp_cmdline_get_param_raw>
if ( !p )
1898: e3500000 cmp r0, #0
189c: 0a000013 beq 18f0 <rtems_bsp_cmdline_get_param+0x88>
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
18a0: e2455001 sub r5, r5, #1
value[0] = '\0';
p = rtems_bsp_cmdline_get_param_raw( name );
if ( !p )
18a4: e1a03006 mov r3, r6
if ( *p == '\"' ) {
quotes++;
} else if ( ((quotes % 2) == 0) && *p == ' ' )
break;
value[i++] = *p++;
value[i] = '\0';
18a8: e1a01006 mov r1, r6
18ac: ea000009 b 18d8 <rtems_bsp_cmdline_get_param+0x70>
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
if ( *p == '\"' ) {
18b0: e3520022 cmp r2, #34 ; 0x22
quotes++;
18b4: 02866001 addeq r6, r6, #1
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
if ( *p == '\"' ) {
18b8: 0a000003 beq 18cc <rtems_bsp_cmdline_get_param+0x64>
quotes++;
} else if ( ((quotes % 2) == 0) && *p == ' ' )
18bc: e3160001 tst r6, #1
18c0: 1a000001 bne 18cc <rtems_bsp_cmdline_get_param+0x64>
18c4: e3520020 cmp r2, #32
18c8: 0a000009 beq 18f4 <rtems_bsp_cmdline_get_param+0x8c>
break;
value[i++] = *p++;
18cc: e7c42003 strb r2, [r4, r3]
18d0: e2833001 add r3, r3, #1
value[i] = '\0';
18d4: e7c41003 strb r1, [r4, r3]
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
18d8: e7d02003 ldrb r2, [r0, r3]
18dc: e3520000 cmp r2, #0
18e0: 0a000003 beq 18f4 <rtems_bsp_cmdline_get_param+0x8c>
18e4: e1530005 cmp r3, r5
18e8: 3afffff0 bcc 18b0 <rtems_bsp_cmdline_get_param+0x48>
18ec: ea000000 b 18f4 <rtems_bsp_cmdline_get_param+0x8c> <== NOT EXECUTED
18f0: e3a04000 mov r4, #0
return NULL;
copy_string( p, value, length );
return value;
}
18f4: e1a00004 mov r0, r4
18f8: e8bd8070 pop {r4, r5, r6, pc}
0000247c <rtems_cpu_usage_report_with_plugin>:
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
247c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
Timestamp_Control uptime, total, ran;
#else
uint32_t total_units = 0;
#endif
if ( !print )
2480: e251a000 subs sl, r1, #0
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
2484: e24dd040 sub sp, sp, #64 ; 0x40
2488: e1a08000 mov r8, r0
Timestamp_Control uptime, total, ran;
#else
uint32_t total_units = 0;
#endif
if ( !print )
248c: 0a000059 beq 25f8 <rtems_cpu_usage_report_with_plugin+0x17c>
* When not using nanosecond CPU usage resolution, we have to count
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &uptime );
2490: e28d4030 add r4, sp, #48 ; 0x30
2494: e1a00004 mov r0, r4
_Timestamp_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total );
2498: e28d5028 add r5, sp, #40 ; 0x28
* When not using nanosecond CPU usage resolution, we have to count
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &uptime );
249c: eb0014e0 bl 7824 <_TOD_Get_uptime>
_Timestamp_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total );
24a0: e1a01004 mov r1, r4
24a4: e1a02005 mov r2, r5
24a8: e59f0150 ldr r0, [pc, #336] ; 2600 <rtems_cpu_usage_report_with_plugin+0x184>
24ac: eb001dc3 bl 9bc0 <_Timespec_Subtract>
}
}
}
#endif
(*print)(
24b0: e1a00008 mov r0, r8
24b4: e59f1148 ldr r1, [pc, #328] ; 2604 <rtems_cpu_usage_report_with_plugin+0x188>
24b8: e1a0e00f mov lr, pc
24bc: e12fff1a bx sl
24c0: e59f4140 ldr r4, [pc, #320] ; 2608 <rtems_cpu_usage_report_with_plugin+0x18c>
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
24c4: e59fb140 ldr fp, [pc, #320] ; 260c <rtems_cpu_usage_report_with_plugin+0x190>
);
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
24c8: e5943004 ldr r3, [r4, #4]
24cc: e3530000 cmp r3, #0
24d0: 0a00003b beq 25c4 <rtems_cpu_usage_report_with_plugin+0x148>
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
24d4: e5936004 ldr r6, [r3, #4]
if ( information ) {
24d8: e3560000 cmp r6, #0
24dc: 13a07001 movne r7, #1
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
Timestamp_Control used;
_Timestamp_Subtract(
24e0: 128d9018 addne r9, sp, #24
24e4: 11a05004 movne r5, r4
api_index <= OBJECTS_APIS_LAST ;
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
24e8: 1a00002f bne 25ac <rtems_cpu_usage_report_with_plugin+0x130>
24ec: ea000034 b 25c4 <rtems_cpu_usage_report_with_plugin+0x148> <== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
24f0: e596301c ldr r3, [r6, #28]
24f4: e7934107 ldr r4, [r3, r7, lsl #2]
if ( !the_thread )
24f8: e3540000 cmp r4, #0
24fc: 0a000029 beq 25a8 <rtems_cpu_usage_report_with_plugin+0x12c>
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
2500: e5940008 ldr r0, [r4, #8]
2504: eb001041 bl 6610 <rtems_object_get_name>
(*print)(
2508: e28d3008 add r3, sp, #8
250c: e5942008 ldr r2, [r4, #8]
2510: e1a00008 mov r0, r8
2514: e59f10f4 ldr r1, [pc, #244] ; 2610 <rtems_cpu_usage_report_with_plugin+0x194>
2518: e1a0e00f mov lr, pc
251c: e12fff1a bx sl
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
2520: e2843084 add r3, r4, #132 ; 0x84
2524: e893000c ldm r3, {r2, r3}
2528: e58d2020 str r2, [sp, #32]
252c: e58d3024 str r3, [sp, #36] ; 0x24
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
2530: e59b2000 ldr r2, [fp]
2534: e5943008 ldr r3, [r4, #8]
2538: e5922008 ldr r2, [r2, #8]
253c: e1520003 cmp r2, r3
2540: 1a000006 bne 2560 <rtems_cpu_usage_report_with_plugin+0xe4>
Timestamp_Control used;
_Timestamp_Subtract(
2544: e59f00c8 ldr r0, [pc, #200] ; 2614 <rtems_cpu_usage_report_with_plugin+0x198>
2548: e28d1030 add r1, sp, #48 ; 0x30
254c: e1a02009 mov r2, r9
2550: eb001d9a bl 9bc0 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch, &uptime, &used
);
_Timestamp_Add_to( &ran, &used );
2554: e28d0020 add r0, sp, #32
2558: e1a01009 mov r1, r9
255c: eb001d5c bl 9ad4 <_Timespec_Add_to>
};
_Timestamp_Divide( &ran, &total, &ival, &fval );
2560: e28d203c add r2, sp, #60 ; 0x3c
2564: e28d3038 add r3, sp, #56 ; 0x38
2568: e28d0020 add r0, sp, #32
256c: e28d1028 add r1, sp, #40 ; 0x28
2570: eb001d6c bl 9b28 <_Timespec_Divide>
/*
* Print the information
*/
(*print)( context,
2574: e3a01ffa mov r1, #1000 ; 0x3e8
2578: e59d0024 ldr r0, [sp, #36] ; 0x24
257c: eb0065a7 bl 1bc20 <__aeabi_uidiv>
2580: e59d203c ldr r2, [sp, #60] ; 0x3c
2584: e58d2000 str r2, [sp]
2588: e59d2038 ldr r2, [sp, #56] ; 0x38
258c: e1a03000 mov r3, r0
2590: e58d2004 str r2, [sp, #4]
2594: e1a00008 mov r0, r8
2598: e59f1078 ldr r1, [pc, #120] ; 2618 <rtems_cpu_usage_report_with_plugin+0x19c>
259c: e59d2020 ldr r2, [sp, #32]
25a0: e1a0e00f mov lr, pc
25a4: e12fff1a bx sl
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
25a8: e2877001 add r7, r7, #1
25ac: e1d631b0 ldrh r3, [r6, #16]
25b0: e1570003 cmp r7, r3
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
25b4: e3a0100d mov r1, #13
25b8: e28d2008 add r2, sp, #8
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
25bc: 9affffcb bls 24f0 <rtems_cpu_usage_report_with_plugin+0x74>
25c0: e1a04005 mov r4, r5
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ;
25c4: e59f3050 ldr r3, [pc, #80] ; 261c <rtems_cpu_usage_report_with_plugin+0x1a0>
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
25c8: e2844004 add r4, r4, #4
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ;
25cc: e1540003 cmp r4, r3
25d0: 1affffbc bne 24c8 <rtems_cpu_usage_report_with_plugin+0x4c>
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)(
25d4: e3a01ffa mov r1, #1000 ; 0x3e8
25d8: e59d002c ldr r0, [sp, #44] ; 0x2c
25dc: eb00658f bl 1bc20 <__aeabi_uidiv>
25e0: e59f1038 ldr r1, [pc, #56] ; 2620 <rtems_cpu_usage_report_with_plugin+0x1a4>
25e4: e1a03000 mov r3, r0
25e8: e59d2028 ldr r2, [sp, #40] ; 0x28
25ec: e1a00008 mov r0, r8
25f0: e1a0e00f mov lr, pc
25f4: e12fff1a bx sl
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
25f8: e28dd040 add sp, sp, #64 ; 0x40
25fc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000d310 <rtems_deviceio_errno>:
{ 0, 0, 0 },
};
int
rtems_deviceio_errno(rtems_status_code code)
{
d310: e92d4010 push {r4, lr} <== NOT EXECUTED
d314: e1a01000 mov r1, r0 <== NOT EXECUTED
int rc;
if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t ) code)))
d318: e59f0018 ldr r0, [pc, #24] ; d338 <rtems_deviceio_errno+0x28><== NOT EXECUTED
d31c: eb000006 bl d33c <rtems_assoc_remote_by_local> <== NOT EXECUTED
d320: e2504000 subs r4, r0, #0 <== NOT EXECUTED
d324: 0a000001 beq d330 <rtems_deviceio_errno+0x20> <== NOT EXECUTED
{
errno = rc;
d328: eb000025 bl d3c4 <__errno> <== NOT EXECUTED
d32c: e5804000 str r4, [r0] <== NOT EXECUTED
return -1;
}
return -1;
}
d330: e3e00000 mvn r0, #0 <== NOT EXECUTED
d334: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00001ef8 <rtems_disk_delete>:
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
{
1ef8: e92d4ff7 push {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}
1efc: e1a05000 mov r5, r0
1f00: e1a06001 mov r6, r1
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
sc = disk_lock();
1f04: ebffff91 bl 1d50 <disk_lock>
if (sc != RTEMS_SUCCESSFUL) {
1f08: e2504000 subs r4, r0, #0
1f0c: 1a000057 bne 2070 <rtems_disk_delete+0x178>
return sc;
}
dd = get_disk_entry(dev, true);
1f10: e1a00005 mov r0, r5
1f14: e1a01006 mov r1, r6
1f18: e3a02001 mov r2, #1
1f1c: ebffff12 bl 1b6c <get_disk_entry>
if (dd == NULL) {
1f20: e2503000 subs r3, r0, #0
1f24: 1a000002 bne 1f34 <rtems_disk_delete+0x3c>
disk_unlock();
1f28: ebffff94 bl 1d80 <disk_unlock> <== NOT EXECUTED
1f2c: e3a04004 mov r4, #4 <== NOT EXECUTED
return RTEMS_INVALID_ID;
1f30: ea00004e b 2070 <rtems_disk_delete+0x178> <== NOT EXECUTED
}
dd->deleted = true;
1f34: e3a0b001 mov fp, #1
1f38: e5c3b030 strb fp, [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;
1f3c: e5935008 ldr r5, [r3, #8]
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
1f40: e5d52030 ldrb r2, [r5, #48] ; 0x30
1f44: e3520000 cmp r2, #0
1f48: 0a00003a beq 2038 <rtems_disk_delete+0x140>
dev_t dev = physical_disk->dev;
1f4c: e895000c ldm r5, {r2, r3}
1f50: e98d000c stmib sp, {r2, r3}
1f54: e1a07004 mov r7, r4
1f58: e1a08004 mov r8, r4
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
1f5c: e59fa114 ldr sl, [pc, #276] ; 2078 <rtems_disk_delete+0x180>
1f60: ea000024 b 1ff8 <rtems_disk_delete+0x100>
rtems_disk_device_table *dtab = disktab + major;
1f64: e59a9004 ldr r9, [sl, #4]
1f68: e3a06000 mov r6, #0
1f6c: e0899187 add r9, r9, r7, lsl #3
1f70: ea00001c b 1fe8 <rtems_disk_delete+0xf0>
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
1f74: e5993000 ldr r3, [r9]
1f78: e7930106 ldr r0, [r3, r6, lsl #2]
1f7c: e1a0c106 lsl ip, r6, #2
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
1f80: 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];
1f84: e58dc000 str ip, [sp]
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
1f88: 0a000015 beq 1fe4 <rtems_disk_delete+0xec>
1f8c: e5901008 ldr r1, [r0, #8]
1f90: e59d2004 ldr r2, [sp, #4]
1f94: e591c000 ldr ip, [r1]
1f98: e050e005 subs lr, r0, r5
1f9c: 13a0e001 movne lr, #1
1fa0: e15c0002 cmp ip, r2
1fa4: e3a02000 mov r2, #0
1fa8: 1a000003 bne 1fbc <rtems_disk_delete+0xc4>
1fac: e5911004 ldr r1, [r1, #4]
1fb0: e59dc008 ldr ip, [sp, #8]
1fb4: e151000c cmp r1, ip
1fb8: 03a02001 moveq r2, #1
1fbc: e11e0002 tst lr, r2
1fc0: 0a000007 beq 1fe4 <rtems_disk_delete+0xec>
if (dd->uses == 0) {
1fc4: e5902014 ldr r2, [r0, #20]
1fc8: e3520000 cmp r2, #0
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
} else {
dd->deleted = true;
1fcc: 11a0200b movne r2, fp
1fd0: 15c02030 strbne r2, [r0, #48] ; 0x30
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;
1fd4: 059d1000 ldreq r1, [sp]
1fd8: 07832001 streq r2, [r3, r1]
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;
1fdc: 02888001 addeq r8, r8, #1
dtab->minor [minor] = NULL;
free_disk_device(dd);
1fe0: 0bfffefe bleq 1be0 <free_disk_device>
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) {
1fe4: e2866001 add r6, r6, #1
1fe8: e5993004 ldr r3, [r9, #4]
1fec: e1560003 cmp r6, r3
1ff0: 3affffdf bcc 1f74 <rtems_disk_delete+0x7c>
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
1ff4: e2877001 add r7, r7, #1
1ff8: e59a3000 ldr r3, [sl]
1ffc: e1570003 cmp r7, r3
2000: 3affffd7 bcc 1f64 <rtems_disk_delete+0x6c>
}
}
}
}
physical_disk->uses -= deleted_count;
2004: e5953014 ldr r3, [r5, #20]
2008: e0688003 rsb r8, r8, r3
if (physical_disk->uses == 0) {
200c: e3580000 cmp r8, #0
}
}
}
}
physical_disk->uses -= deleted_count;
2010: e5858014 str r8, [r5, #20]
if (physical_disk->uses == 0) {
2014: 1a000014 bne 206c <rtems_disk_delete+0x174>
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
disktab [major].minor [minor] = NULL;
2018: e59f3058 ldr r3, [pc, #88] ; 2078 <rtems_disk_delete+0x180>
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
201c: e5952000 ldr r2, [r5]
disktab [major].minor [minor] = NULL;
2020: e5933004 ldr r3, [r3, #4]
2024: e7933182 ldr r3, [r3, r2, lsl #3]
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
2028: e5952004 ldr r2, [r5, #4]
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
202c: e1a00005 mov r0, r5
}
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;
2030: e7838102 str r8, [r3, r2, lsl #2]
2034: ea00000b b 2068 <rtems_disk_delete+0x170>
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
2038: e5932014 ldr r2, [r3, #20]
203c: e3520000 cmp r2, #0
2040: 1a000009 bne 206c <rtems_disk_delete+0x174>
--physical_disk->uses;
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
2044: e59f202c ldr r2, [pc, #44] ; 2078 <rtems_disk_delete+0x180>
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);
2048: e593c000 ldr ip, [r3]
disktab [major].minor [minor] = NULL;
204c: 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;
2050: e5951014 ldr r1, [r5, #20]
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
2054: 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);
2058: e5933004 ldr r3, [r3, #4]
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
205c: e2411001 sub r1, r1, #1
2060: e5851014 str r1, [r5, #20]
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
2064: e7824103 str r4, [r2, r3, lsl #2]
free_disk_device(disk_to_remove);
2068: ebfffedc bl 1be0 <free_disk_device>
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
206c: ebffff43 bl 1d80 <disk_unlock>
return RTEMS_SUCCESSFUL;
}
2070: e1a00004 mov r0, r4
2074: e8bd8ffe pop {r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
00001cb0 <rtems_disk_io_initialize>:
}
}
rtems_status_code
rtems_disk_io_initialize(void)
{
1cb0: e92d4031 push {r0, r4, r5, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
1cb4: e59f408c ldr r4, [pc, #140] ; 1d48 <rtems_disk_io_initialize+0x98>
1cb8: e5945000 ldr r5, [r4]
1cbc: e3550000 cmp r5, #0
1cc0: 13a00000 movne r0, #0
1cc4: 1a00001e bne 1d44 <rtems_disk_io_initialize+0x94>
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
1cc8: e3a00008 mov r0, #8
1ccc: e1a01000 mov r1, r0
1cd0: eb0003b1 bl 2b9c <calloc>
if (disktab == NULL) {
1cd4: e3500000 cmp r0, #0
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
1cd8: e5840004 str r0, [r4, #4]
if (disktab == NULL) {
1cdc: 0280001a addeq r0, r0, #26
1ce0: 0a000017 beq 1d44 <rtems_disk_io_initialize+0x94>
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
sc = rtems_semaphore_create(
1ce4: e284c008 add ip, r4, #8
1ce8: e1a03005 mov r3, r5
1cec: e59f0058 ldr r0, [pc, #88] ; 1d4c <rtems_disk_io_initialize+0x9c>
1cf0: e3a01001 mov r1, #1
1cf4: e3a02010 mov r2, #16
1cf8: e58dc000 str ip, [sp]
disktab = calloc(size, sizeof(rtems_disk_device_table));
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
1cfc: e5c4500c strb r5, [r4, #12]
sc = rtems_semaphore_create(
1d00: eb00110d bl 613c <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) {
1d04: e3500000 cmp r0, #0
1d08: 0a000003 beq 1d1c <rtems_disk_io_initialize+0x6c>
free(disktab);
1d0c: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED
1d10: eb000429 bl 2dbc <free> <== NOT EXECUTED
1d14: e3a0001a mov r0, #26 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
1d18: ea000009 b 1d44 <rtems_disk_io_initialize+0x94> <== NOT EXECUTED
}
sc = rtems_bdbuf_init();
1d1c: eb002163 bl a2b0 <rtems_bdbuf_init>
if (sc != RTEMS_SUCCESSFUL) {
1d20: e3500000 cmp r0, #0
free(disktab);
return RTEMS_UNSATISFIED;
}
disktab_size = size;
1d24: 03a03008 moveq r3, #8
1d28: 05843000 streq r3, [r4]
return RTEMS_NO_MEMORY;
}
sc = rtems_bdbuf_init();
if (sc != RTEMS_SUCCESSFUL) {
1d2c: 0a000004 beq 1d44 <rtems_disk_io_initialize+0x94>
rtems_semaphore_delete(diskdevs_mutex);
1d30: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
1d34: eb00116b bl 62e8 <rtems_semaphore_delete> <== NOT EXECUTED
free(disktab);
1d38: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED
1d3c: eb00041e bl 2dbc <free> <== NOT EXECUTED
1d40: e3a0000d mov r0, #13 <== NOT EXECUTED
}
disktab_size = size;
return RTEMS_SUCCESSFUL;
}
1d44: e8bd8038 pop {r3, r4, r5, pc}
00001db0 <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) {
1db0: e3700001 cmn r0, #1
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
1db4: 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) {
1db8: 1a000003 bne 1dcc <rtems_disk_next+0x1c>
1dbc: e3710001 cmn r1, #1
1dc0: 03a04000 moveq r4, #0
1dc4: 01a05004 moveq r5, r4
1dc8: 0a000005 beq 1de4 <rtems_disk_next+0x34>
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
1dcc: e2914001 adds r4, r1, #1
1dd0: 31a05000 movcc r5, r0
1dd4: 3a000002 bcc 1de4 <rtems_disk_next+0x34>
/* If major wraps around */
if ((major + 1) < major) {
1dd8: e2905001 adds r5, r0, #1 <== NOT EXECUTED
1ddc: 2a000027 bcs 1e80 <rtems_disk_next+0xd0> <== NOT EXECUTED
1de0: e3a04000 mov r4, #0 <== NOT EXECUTED
} else {
++minor;
}
}
sc = disk_lock();
1de4: ebffffd9 bl 1d50 <disk_lock>
if (sc != RTEMS_SUCCESSFUL) {
1de8: e2506000 subs r6, r0, #0
1dec: 1a000023 bne 1e80 <rtems_disk_next+0xd0>
return NULL;
}
if (major >= disktab_size) {
1df0: e59f3090 ldr r3, [pc, #144] ; 1e88 <rtems_disk_next+0xd8>
1df4: e5931000 ldr r1, [r3]
1df8: e1550001 cmp r5, r1
disk_unlock();
return NULL;
}
dtab = disktab + major;
1dfc: 35932004 ldrcc r2, [r3, #4]
1e00: 30826185 addcc r6, r2, r5, lsl #3
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return NULL;
}
if (major >= disktab_size) {
1e04: 3a000002 bcc 1e14 <rtems_disk_next+0x64>
disk_unlock();
1e08: ebffffdc bl 1d80 <disk_unlock> <== NOT EXECUTED
1e0c: e1a00006 mov r0, r6 <== NOT EXECUTED
return NULL;
1e10: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
1e14: e5963000 ldr r3, [r6]
1e18: e3530000 cmp r3, #0
1e1c: 0a000002 beq 1e2c <rtems_disk_next+0x7c>
1e20: e5960004 ldr r0, [r6, #4]
1e24: e1540000 cmp r4, r0
1e28: 3a000008 bcc 1e50 <rtems_disk_next+0xa0>
minor = 0;
++major;
1e2c: e2855001 add r5, r5, #1
if (major >= disktab_size) {
1e30: e1550001 cmp r5, r1
1e34: 3a000002 bcc 1e44 <rtems_disk_next+0x94>
disk_unlock();
1e38: ebffffd0 bl 1d80 <disk_unlock>
1e3c: e3a00000 mov r0, #0
return NULL;
1e40: e8bd80f0 pop {r4, r5, r6, r7, pc}
}
dtab = disktab + major;
1e44: e0826185 add r6, r2, r5, lsl #3
1e48: e3a04000 mov r4, #0
return NULL;
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
1e4c: eafffff0 b 1e14 <rtems_disk_next+0x64>
disk_unlock();
return NULL;
}
dtab = disktab + major;
} else if (dtab->minor [minor] == NULL) {
1e50: e7933104 ldr r3, [r3, r4, lsl #2]
1e54: e3530000 cmp r3, #0
1e58: e1a07104 lsl r7, r4, #2
++minor;
1e5c: 02844001 addeq r4, r4, #1
1e60: 0affffeb beq 1e14 <rtems_disk_next+0x64>
} else {
++dtab->minor [minor]->uses;
1e64: e5932014 ldr r2, [r3, #20]
1e68: e2822001 add r2, r2, #1
1e6c: e5832014 str r2, [r3, #20]
disk_unlock();
1e70: ebffffc2 bl 1d80 <disk_unlock>
return dtab->minor [minor];
1e74: e5963000 ldr r3, [r6]
1e78: e7930007 ldr r0, [r3, r7]
1e7c: e8bd80f0 pop {r4, r5, r6, r7, pc}
1e80: e3a00000 mov r0, #0 <== NOT EXECUTED
}
}
}
1e84: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00001e8c <rtems_disk_obtain>:
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
1e8c: e92d4070 push {r4, r5, r6, lr}
1e90: e1a05000 mov r5, r0
1e94: e1a06001 mov r6, r1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
1e98: e10f4000 mrs r4, CPSR
1e9c: e3843080 orr r3, r4, #128 ; 0x80
1ea0: 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) {
1ea4: e59f3048 ldr r3, [pc, #72] ; 1ef4 <rtems_disk_obtain+0x68>
1ea8: e5d3200c ldrb r2, [r3, #12]
1eac: e21220ff ands r2, r2, #255 ; 0xff
1eb0: 1a000003 bne 1ec4 <rtems_disk_obtain+0x38>
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
1eb4: ebffff2c bl 1b6c <get_disk_entry>
1eb8: e1a05000 mov r5, r0
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
1ebc: e129f004 msr CPSR_fc, r4
1ec0: ea000009 b 1eec <rtems_disk_obtain+0x60>
1ec4: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
rtems_interrupt_enable(level);
} else {
rtems_interrupt_enable(level);
sc = disk_lock();
1ec8: ebffffa0 bl 1d50 <disk_lock> <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL) {
1ecc: e2502000 subs r2, r0, #0 <== NOT EXECUTED
1ed0: 13a05000 movne r5, #0 <== NOT EXECUTED
1ed4: 1a000004 bne 1eec <rtems_disk_obtain+0x60> <== NOT EXECUTED
dd = get_disk_entry(dev, false);
1ed8: e1a00005 mov r0, r5 <== NOT EXECUTED
1edc: e1a01006 mov r1, r6 <== NOT EXECUTED
1ee0: ebffff21 bl 1b6c <get_disk_entry> <== NOT EXECUTED
1ee4: e1a05000 mov r5, r0 <== NOT EXECUTED
disk_unlock();
1ee8: ebffffa4 bl 1d80 <disk_unlock> <== NOT EXECUTED
}
}
return dd;
}
1eec: e1a00005 mov r0, r5
1ef0: e8bd8070 pop {r4, r5, r6, pc}
0001d1fc <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,
1d1fc: e59f1008 ldr r1, [pc, #8] ; 1d20c <rtems_dosfs_initialize+0x10><== NOT EXECUTED
1d200: e59f2008 ldr r2, [pc, #8] ; 1d210 <rtems_dosfs_initialize+0x14><== NOT EXECUTED
1d204: e59f3008 ldr r3, [pc, #8] ; 1d214 <rtems_dosfs_initialize+0x18><== NOT EXECUTED
1d208: ea000002 b 1d218 <msdos_initialize_support> <== NOT EXECUTED
00006680 <rtems_error>:
int rtems_error(
rtems_error_code_t error_flag,
const char *printf_format,
...
)
{
6680: e92d000e push {r1, r2, r3} <== NOT EXECUTED
6684: e92d4001 push {r0, lr} <== NOT EXECUTED
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
6688: e28d300c add r3, sp, #12 <== NOT EXECUTED
chars_written = rtems_verror(error_flag, printf_format, arglist);
668c: e1a02003 mov r2, r3 <== NOT EXECUTED
6690: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED
)
{
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
6694: e58d3000 str r3, [sp] <== NOT EXECUTED
chars_written = rtems_verror(error_flag, printf_format, arglist);
6698: ebffff84 bl 64b0 <rtems_verror> <== NOT EXECUTED
va_end(arglist);
return chars_written;
}
669c: e8bd4008 pop {r3, lr} <== NOT EXECUTED
66a0: e28dd00c add sp, sp, #12 <== NOT EXECUTED
66a4: e12fff1e bx lr <== NOT EXECUTED
00001e58 <rtems_filesystem_evaluate_path>:
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc,
int follow_link
)
{
1e58: e92d40f3 push {r0, r1, r4, r5, r6, r7, lr}
int i = 0;
1e5c: e3a0c000 mov ip, #0
/*
* Verify Input parameters.
*/
if ( !pathname )
1e60: e2505000 subs r5, r0, #0
int flags,
rtems_filesystem_location_info_t *pathloc,
int follow_link
)
{
int i = 0;
1e64: e58dc004 str ip, [sp, #4]
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc,
int follow_link
)
{
1e68: e1a06001 mov r6, r1
1e6c: e1a04002 mov r4, r2
1e70: e1a07003 mov r7, r3
/*
* Verify Input parameters.
*/
if ( !pathname )
1e74: 1a000002 bne 1e84 <rtems_filesystem_evaluate_path+0x2c>
rtems_set_errno_and_return_minus_one( EFAULT );
1e78: eb002d51 bl d3c4 <__errno> <== NOT EXECUTED
1e7c: e3a0300e mov r3, #14 <== NOT EXECUTED
1e80: ea000003 b 1e94 <rtems_filesystem_evaluate_path+0x3c> <== NOT EXECUTED
if ( !pathloc )
1e84: e3530000 cmp r3, #0
1e88: 1a000004 bne 1ea0 <rtems_filesystem_evaluate_path+0x48>
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
1e8c: eb002d4c bl d3c4 <__errno> <== NOT EXECUTED
1e90: e3a03005 mov r3, #5 <== NOT EXECUTED
1e94: e5803000 str r3, [r0] <== NOT EXECUTED
1e98: e3e00000 mvn r0, #0 <== NOT EXECUTED
1e9c: ea00000a b 1ecc <rtems_filesystem_evaluate_path+0x74> <== NOT EXECUTED
/*
* Evaluate the path using the optable evalpath.
*/
rtems_filesystem_get_start_loc( pathname, &i, pathloc );
1ea0: e1a02003 mov r2, r3
1ea4: e28d1004 add r1, sp, #4
1ea8: eb0003a6 bl 2d48 <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],
1eac: e59d0004 ldr r0, [sp, #4]
1eb0: e59dc01c ldr ip, [sp, #28]
1eb4: e0601006 rsb r1, r0, r6
1eb8: e1a02004 mov r2, r4
1ebc: e0850000 add r0, r5, r0
1ec0: e1a03007 mov r3, r7
1ec4: e58dc000 str ip, [sp]
1ec8: ebffffaa bl 1d78 <rtems_filesystem_evaluate_relative_path>
pathnamelen - i,
flags,
pathloc,
follow_link );
}
1ecc: e8bd80fc pop {r2, r3, r4, r5, r6, r7, pc}
00001d78 <rtems_filesystem_evaluate_relative_path>:
/*
* Verify Input parameters.
*/
if ( !pathname )
1d78: e3500000 cmp r0, #0
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc,
int follow_link
)
{
1d7c: e92d4030 push {r4, r5, lr}
1d80: e1a05002 mov r5, r2
1d84: e1a04003 mov r4, r3
/*
* Verify Input parameters.
*/
if ( !pathname )
1d88: 1a000002 bne 1d98 <rtems_filesystem_evaluate_relative_path+0x20>
rtems_set_errno_and_return_minus_one( EFAULT );
1d8c: eb002d8c bl d3c4 <__errno> <== NOT EXECUTED
1d90: e3a0300e mov r3, #14 <== NOT EXECUTED
1d94: ea000027 b 1e38 <rtems_filesystem_evaluate_relative_path+0xc0><== NOT EXECUTED
if ( !pathloc )
1d98: e3530000 cmp r3, #0
1d9c: 1a000002 bne 1dac <rtems_filesystem_evaluate_relative_path+0x34>
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
1da0: eb002d87 bl d3c4 <__errno> <== NOT EXECUTED
1da4: e3a03005 mov r3, #5 <== NOT EXECUTED
1da8: ea000022 b 1e38 <rtems_filesystem_evaluate_relative_path+0xc0><== NOT EXECUTED
if ( !pathloc->ops->evalpath_h )
1dac: e593c00c ldr ip, [r3, #12]
1db0: e59cc000 ldr ip, [ip]
1db4: e35c0000 cmp ip, #0
1db8: 0a00001c beq 1e30 <rtems_filesystem_evaluate_relative_path+0xb8>
rtems_set_errno_and_return_minus_one( ENOTSUP );
result = (*pathloc->ops->evalpath_h)( pathname, pathnamelen, flags, pathloc );
1dbc: e1a0e00f mov lr, pc
1dc0: e12fff1c bx ip
/*
* Get the Node type and determine if you need to follow the link or
* not.
*/
if ( (result == 0) && follow_link ) {
1dc4: e59d200c ldr r2, [sp, #12]
1dc8: e2703001 rsbs r3, r0, #1
1dcc: 33a03000 movcc r3, #0
1dd0: e3520000 cmp r2, #0
1dd4: 03a03000 moveq r3, #0
1dd8: e3530000 cmp r3, #0
1ddc: 08bd8030 popeq {r4, r5, pc}
if ( !pathloc->ops->node_type_h ){
1de0: e594200c ldr r2, [r4, #12]
1de4: e5923010 ldr r3, [r2, #16]
1de8: e3530000 cmp r3, #0
1dec: 0a00000a beq 1e1c <rtems_filesystem_evaluate_relative_path+0xa4>
rtems_filesystem_freenode( pathloc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
type = (*pathloc->ops->node_type_h)( pathloc );
1df0: e1a00004 mov r0, r4
1df4: e1a0e00f mov lr, pc
1df8: e12fff13 bx r3
if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) ||
1dfc: e2400003 sub r0, r0, #3
1e00: e3500001 cmp r0, #1
1e04: 83a00000 movhi r0, #0
1e08: 88bd8030 pophi {r4, r5, pc}
( type == RTEMS_FILESYSTEM_SYM_LINK ) ) {
if ( !pathloc->ops->eval_link_h ){
1e0c: e594200c ldr r2, [r4, #12]
1e10: e5923034 ldr r3, [r2, #52] ; 0x34
1e14: e3530000 cmp r3, #0
1e18: 1a000009 bne 1e44 <rtems_filesystem_evaluate_relative_path+0xcc>
rtems_filesystem_freenode( pathloc );
1e1c: e592301c ldr r3, [r2, #28] <== NOT EXECUTED
1e20: e3530000 cmp r3, #0 <== NOT EXECUTED
1e24: 11a00004 movne r0, r4 <== NOT EXECUTED
1e28: 11a0e00f movne lr, pc <== NOT EXECUTED
1e2c: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
1e30: eb002d63 bl d3c4 <__errno> <== NOT EXECUTED
1e34: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
1e38: e5803000 str r3, [r0] <== NOT EXECUTED
1e3c: e3e00000 mvn r0, #0 <== NOT EXECUTED
1e40: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
* 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 );
1e44: e1a00004 mov r0, r4
1e48: e1a01005 mov r1, r5
1e4c: e1a0e00f mov lr, pc
1e50: e12fff13 bx r3
}
}
return result;
}
1e54: e8bd8030 pop {r4, r5, pc}
00001b9c <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 )
{
1b9c: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
1ba0: e59f20e4 ldr r2, [pc, #228] ; 1c8c <rtems_filesystem_initialize+0xf0>
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
1ba4: e59f60e4 ldr r6, [pc, #228] ; 1c90 <rtems_filesystem_initialize+0xf4>
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
1ba8: e5922000 ldr r2, [r2]
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
1bac: e5963000 ldr r3, [r6]
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
1bb0: e3520000 cmp r2, #0
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
1bb4: 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 )
{
1bb8: e24dd018 sub sp, sp, #24
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
1bbc: e583202c str r2, [r3, #44] ; 0x2c
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
rtems_fatal_error_occurred( 0xABCD0001 );
1bc0: 059f00cc ldreq r0, [pc, #204] ; 1c94 <rtems_filesystem_initialize+0xf8>
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
1bc4: 0a00000b beq 1bf8 <rtems_filesystem_initialize+0x5c>
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
1bc8: e59f30c8 ldr r3, [pc, #200] ; 1c98 <rtems_filesystem_initialize+0xfc>
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
1bcc: e3a05000 mov r5, #0
*/
if ( rtems_filesystem_mount_table_size == 0 )
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
1bd0: e5932000 ldr r2, [r3]
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
1bd4: e58d5000 str r5, [sp]
1bd8: e5923004 ldr r3, [r2, #4]
1bdc: e2820008 add r0, r2, #8
1be0: e8900003 ldm r0, {r0, r1}
1be4: e5922000 ldr r2, [r2]
1be8: eb000231 bl 24b4 <mount>
if ( status == -1 )
1bec: e3700001 cmn r0, #1
1bf0: 1a000001 bne 1bfc <rtems_filesystem_initialize+0x60>
rtems_fatal_error_occurred( 0xABCD0002 );
1bf4: e59f00a0 ldr r0, [pc, #160] ; 1c9c <rtems_filesystem_initialize+0x100><== NOT EXECUTED
1bf8: eb000eea bl 57a8 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_filesystem_link_counts = 0;
1bfc: e5963000 ldr r3, [r6]
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
1c00: 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;
1c04: 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);
1c08: e3a01001 mov r1, #1
1c0c: e1a03004 mov r3, r4
1c10: e1a02005 mov r2, r5
1c14: e59f0084 ldr r0, [pc, #132] ; 1ca0 <rtems_filesystem_initialize+0x104>
rtems_filesystem_root = loc;
1c18: e1a07004 mov r7, r4
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
1c1c: e58d5000 str r5, [sp]
1c20: eb00008c bl 1e58 <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
1c24: e596c000 ldr ip, [r6]
1c28: e8b7000f ldm r7!, {r0, r1, r2, r3}
1c2c: e28cc018 add ip, ip, #24
1c30: e8ac000f stmia ip!, {r0, r1, r2, r3}
1c34: e5973000 ldr r3, [r7]
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
1c38: 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;
1c3c: e58c3000 str r3, [ip]
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
1c40: e3a01001 mov r1, #1
1c44: e1a03004 mov r3, r4
1c48: e59f0050 ldr r0, [pc, #80] ; 1ca0 <rtems_filesystem_initialize+0x104>
1c4c: e58d5000 str r5, [sp]
1c50: eb000080 bl 1e58 <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
1c54: e596c000 ldr ip, [r6]
1c58: e8b4000f ldm r4!, {r0, r1, r2, r3}
1c5c: e28cc004 add ip, ip, #4
1c60: e8ac000f stmia ip!, {r0, r1, r2, r3}
1c64: 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);
1c68: e59f0034 ldr r0, [pc, #52] ; 1ca4 <rtems_filesystem_initialize+0x108>
/* 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;
1c6c: 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);
1c70: e59f1030 ldr r1, [pc, #48] ; 1ca8 <rtems_filesystem_initialize+0x10c>
1c74: eb00019f bl 22f8 <mkdir>
if ( status != 0 )
1c78: e3500000 cmp r0, #0
rtems_fatal_error_occurred( 0xABCD0003 );
1c7c: 159f0028 ldrne r0, [pc, #40] ; 1cac <rtems_filesystem_initialize+0x110>
* 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);
if ( status != 0 )
1c80: 1affffdc bne 1bf8 <rtems_filesystem_initialize+0x5c>
* 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.
*/
}
1c84: e28dd018 add sp, sp, #24
1c88: e8bd80f0 pop {r4, r5, r6, r7, pc}
0000a628 <rtems_filesystem_register>:
int
rtems_filesystem_register(
const char *type,
rtems_filesystem_fsmount_me_t mount_h
)
{
a628: e92d41f0 push {r4, r5, r6, r7, r8, lr}
a62c: e1a08001 mov r8, r1
a630: e1a06000 mov r6, r0
size_t fsn_size = sizeof( filesystem_node ) + strlen(type) + 1;
a634: eb000f67 bl e3d8 <strlen>
filesystem_node *fsn = malloc( fsn_size );
a638: e2800011 add r0, r0, #17
a63c: ebffdeef bl 2200 <malloc>
char *type_storage = (char *) fsn + sizeof( filesystem_node );
if ( fsn == NULL )
a640: e2504000 subs r4, r0, #0
a644: 1a000004 bne a65c <rtems_filesystem_register+0x34>
rtems_set_errno_and_return_minus_one( ENOMEM );
a648: eb000b5d bl d3c4 <__errno> <== NOT EXECUTED
a64c: e3a0300c mov r3, #12 <== NOT EXECUTED
a650: e5803000 str r3, [r0] <== NOT EXECUTED
a654: e3e00000 mvn r0, #0 <== NOT EXECUTED
a658: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
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 );
a65c: e2847010 add r7, r4, #16
if ( fsn == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
strcpy(type_storage, type);
a660: e1a01006 mov r1, r6
a664: 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 );
a668: e59f5068 ldr r5, [pc, #104] ; a6d8 <rtems_filesystem_register+0xb0>
a66c: eb000f09 bl e298 <strcpy>
a670: e3a01000 mov r1, #0
a674: e1a02001 mov r2, r1
fsn->entry.type = type_storage;
a678: e5847008 str r7, [r4, #8]
fsn->entry.mount_h = mount_h;
a67c: e584800c str r8, [r4, #12]
a680: e5950000 ldr r0, [r5]
a684: ebffeac4 bl 519c <rtems_semaphore_obtain>
rtems_libio_lock();
if ( rtems_filesystem_get_mount_handler( type ) == NULL ) {
a688: e1a00006 mov r0, r6
a68c: ebffffdb bl a600 <rtems_filesystem_get_mount_handler>
a690: e2506000 subs r6, r0, #0
a694: 1a000006 bne a6b4 <rtems_filesystem_register+0x8c>
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
a698: e1a01004 mov r1, r4
a69c: e59f0038 ldr r0, [pc, #56] ; a6dc <rtems_filesystem_register+0xb4>
a6a0: ebffece8 bl 5a48 <_Chain_Append>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
a6a4: e5950000 ldr r0, [r5]
a6a8: ebffeb01 bl 52b4 <rtems_semaphore_release>
a6ac: e1a00006 mov r0, r6
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_unlock();
return 0;
a6b0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
a6b4: e5950000 ldr r0, [r5] <== NOT EXECUTED
a6b8: ebffeafd bl 52b4 <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 );
a6bc: e1a00004 mov r0, r4 <== NOT EXECUTED
a6c0: ebffde02 bl 1ed0 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
a6c4: eb000b3e bl d3c4 <__errno> <== NOT EXECUTED
a6c8: e3a03016 mov r3, #22 <== NOT EXECUTED
a6cc: e5803000 str r3, [r0] <== NOT EXECUTED
a6d0: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
rtems_libio_unlock();
return 0;
}
a6d4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
0000a4a0 <rtems_filesystem_unregister>:
int
rtems_filesystem_unregister(
const char *type
)
{
a4a0: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_chain_node *node = NULL;
if ( type == NULL ) {
a4a4: e2505000 subs r5, r0, #0 <== NOT EXECUTED
a4a8: 1a000004 bne a4c0 <rtems_filesystem_unregister+0x20> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
a4ac: eb000bc4 bl d3c4 <__errno> <== NOT EXECUTED
a4b0: e3a03016 mov r3, #22 <== NOT EXECUTED
a4b4: e5803000 str r3, [r0] <== NOT EXECUTED
a4b8: e3e00000 mvn r0, #0 <== NOT EXECUTED
a4bc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== 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 );
a4c0: e59f307c ldr r3, [pc, #124] ; a544 <rtems_filesystem_unregister+0xa4><== NOT EXECUTED
a4c4: e3a01000 mov r1, #0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return the_chain->first;
a4c8: e59f4078 ldr r4, [pc, #120] ; a548 <rtems_filesystem_unregister+0xa8><== NOT EXECUTED
a4cc: e5930000 ldr r0, [r3] <== NOT EXECUTED
a4d0: e1a02001 mov r2, r1 <== NOT EXECUTED
a4d4: ebffeb30 bl 519c <rtems_semaphore_obtain> <== NOT EXECUTED
a4d8: e4946004 ldr r6, [r4], #4 <== NOT EXECUTED
}
rtems_libio_lock();
for (
a4dc: ea00000d b a518 <rtems_filesystem_unregister+0x78> <== 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 ) {
a4e0: e5960008 ldr r0, [r6, #8] <== NOT EXECUTED
a4e4: eb000edf bl e068 <strcmp> <== NOT EXECUTED
a4e8: e2507000 subs r7, r0, #0 <== NOT EXECUTED
a4ec: 1a000008 bne a514 <rtems_filesystem_unregister+0x74> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
a4f0: e1a00006 mov r0, r6 <== NOT EXECUTED
a4f4: ebffed5e bl 5a74 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract( node );
free( fsn );
a4f8: e1a00006 mov r0, r6 <== NOT EXECUTED
a4fc: ebffde73 bl 1ed0 <free> <== NOT EXECUTED
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
a500: e59f303c ldr r3, [pc, #60] ; a544 <rtems_filesystem_unregister+0xa4><== NOT EXECUTED
a504: e5930000 ldr r0, [r3] <== NOT EXECUTED
a508: ebffeb69 bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
a50c: e1a00007 mov r0, r7 <== NOT EXECUTED
rtems_libio_unlock();
return 0;
a510: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
a514: e5966000 ldr r6, [r6] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
a518: e1560004 cmp r6, r4 <== 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 ) {
a51c: e1a01005 mov r1, r5 <== NOT EXECUTED
a520: 1affffee bne a4e0 <rtems_filesystem_unregister+0x40> <== NOT EXECUTED
a524: e59f3018 ldr r3, [pc, #24] ; a544 <rtems_filesystem_unregister+0xa4><== NOT EXECUTED
a528: e5930000 ldr r0, [r3] <== NOT EXECUTED
a52c: ebffeb60 bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
return 0;
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
a530: eb000ba3 bl d3c4 <__errno> <== NOT EXECUTED
a534: e3a03002 mov r3, #2 <== NOT EXECUTED
a538: e5803000 str r3, [r0] <== NOT EXECUTED
a53c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
a540: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00006828 <rtems_fsmount>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
6828: e92d4ff3 push {r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
682c: e1a0a001 mov sl, r1 <== NOT EXECUTED
6830: e1a08002 mov r8, r2 <== NOT EXECUTED
6834: e2804014 add r4, r0, #20 <== NOT EXECUTED
6838: e3a05000 mov r5, #0 <== NOT EXECUTED
rc = tmp_rc;
}
}
else {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_OK)) {
fprintf(stdout,"fsmount: mounting of \"%s\" to"
683c: e59f6118 ldr r6, [pc, #280] ; 695c <rtems_fsmount+0x134> <== NOT EXECUTED
6840: ea000036 b 6920 <rtems_fsmount+0xf8> <== 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);
6844: e5140010 ldr r0, [r4, #-16] <== NOT EXECUTED
6848: e59f1110 ldr r1, [pc, #272] ; 6960 <rtems_fsmount+0x138> <== NOT EXECUTED
684c: eb000914 bl 8ca4 <rtems_mkdir> <== NOT EXECUTED
if (tmp_rc != 0) {
6850: e2507000 subs r7, r0, #0 <== NOT EXECUTED
6854: 0a000038 beq 693c <rtems_fsmount+0x114> <== NOT EXECUTED
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNTPNT_CRTERR)) {
6858: e15430b4 ldrh r3, [r4, #-4] <== NOT EXECUTED
685c: e3130002 tst r3, #2 <== NOT EXECUTED
6860: 0a00000a beq 6890 <rtems_fsmount+0x68> <== NOT EXECUTED
fprintf(stdout,"fsmount: creation of mount point \"%s\" failed: %s\n",
6864: e5963000 ldr r3, [r6] <== NOT EXECUTED
6868: e5149010 ldr r9, [r4, #-16] <== NOT EXECUTED
686c: e593b008 ldr fp, [r3, #8] <== NOT EXECUTED
6870: eb00d9a2 bl 3cf00 <__errno> <== NOT EXECUTED
6874: e5900000 ldr r0, [r0] <== NOT EXECUTED
6878: eb00f311 bl 434c4 <strerror> <== NOT EXECUTED
687c: e1a02009 mov r2, r9 <== NOT EXECUTED
6880: e1a03000 mov r3, r0 <== NOT EXECUTED
6884: e59f10d8 ldr r1, [pc, #216] ; 6964 <rtems_fsmount+0x13c> <== NOT EXECUTED
6888: e1a0000b mov r0, fp <== NOT EXECUTED
688c: eb00dc12 bl 3d8dc <fprintf> <== NOT EXECUTED
fstab_ptr->target,
strerror(errno));
}
if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNTPNT_CRTERR)) {
6890: e15430b2 ldrh r3, [r4, #-2] <== NOT EXECUTED
6894: e3130002 tst r3, #2 <== NOT EXECUTED
6898: ea000011 b 68e4 <rtems_fsmount+0xbc> <== NOT EXECUTED
fstab_ptr->target,
fstab_ptr->type,
fstab_ptr->options,
NULL);
if (tmp_rc != 0) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_FAILED)) {
689c: e3130004 tst r3, #4 <== NOT EXECUTED
68a0: 0a00000d beq 68dc <rtems_fsmount+0xb4> <== NOT EXECUTED
fprintf(stdout,"fsmount: mounting of \"%s\" to"
68a4: e5963000 ldr r3, [r6] <== NOT EXECUTED
68a8: e5142014 ldr r2, [r4, #-20] <== NOT EXECUTED
68ac: e593b008 ldr fp, [r3, #8] <== NOT EXECUTED
68b0: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
68b4: e5149010 ldr r9, [r4, #-16] <== NOT EXECUTED
68b8: eb00d990 bl 3cf00 <__errno> <== NOT EXECUTED
68bc: e5900000 ldr r0, [r0] <== NOT EXECUTED
68c0: eb00f2ff bl 434c4 <strerror> <== NOT EXECUTED
68c4: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED
68c8: e58d0000 str r0, [sp] <== NOT EXECUTED
68cc: e1a03009 mov r3, r9 <== NOT EXECUTED
68d0: e1a0000b mov r0, fp <== NOT EXECUTED
68d4: e59f108c ldr r1, [pc, #140] ; 6968 <rtems_fsmount+0x140> <== NOT EXECUTED
68d8: eb00dbff bl 3d8dc <fprintf> <== NOT EXECUTED
" \"%s\" failed: %s\n",
fstab_ptr->source,
fstab_ptr->target,
strerror(errno));
}
if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNT_FAILED)) {
68dc: e15430b2 ldrh r3, [r4, #-2] <== NOT EXECUTED
68e0: e3130004 tst r3, #4 <== NOT EXECUTED
68e4: 0a00000b beq 6918 <rtems_fsmount+0xf0> <== NOT EXECUTED
68e8: ea00000f b 692c <rtems_fsmount+0x104> <== NOT EXECUTED
terminate = true;
rc = tmp_rc;
}
}
else {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_OK)) {
68ec: e3130001 tst r3, #1 <== NOT EXECUTED
68f0: 0a000005 beq 690c <rtems_fsmount+0xe4> <== NOT EXECUTED
fprintf(stdout,"fsmount: mounting of \"%s\" to"
68f4: e5963000 ldr r3, [r6] <== NOT EXECUTED
68f8: e59f106c ldr r1, [pc, #108] ; 696c <rtems_fsmount+0x144> <== NOT EXECUTED
68fc: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
6900: e2442014 sub r2, r4, #20 <== NOT EXECUTED
6904: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
6908: eb00dbf3 bl 3d8dc <fprintf> <== NOT EXECUTED
" \"%s\" succeeded\n",
fstab_ptr->source,
fstab_ptr->target);
}
if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNT_OK)) {
690c: e15430b2 ldrh r3, [r4, #-2] <== NOT EXECUTED
6910: e3130001 tst r3, #1 <== NOT EXECUTED
6914: 1a000003 bne 6928 <rtems_fsmount+0x100> <== NOT EXECUTED
/*
* proceed to next entry
*/
if (!terminate) {
fstab_ptr++;
fstab_idx++;
6918: e2855001 add r5, r5, #1 <== NOT EXECUTED
691c: e2844014 add r4, r4, #20 <== NOT EXECUTED
bool terminate = false;
/*
* scan through all fstab entries;
*/
while (!terminate &&
6920: e155000a cmp r5, sl <== NOT EXECUTED
6924: 3affffc6 bcc 6844 <rtems_fsmount+0x1c> <== NOT EXECUTED
6928: e3a07000 mov r7, #0 <== NOT EXECUTED
if (!terminate) {
fstab_ptr++;
fstab_idx++;
}
}
if (fail_idx != NULL) {
692c: e3580000 cmp r8, #0 <== NOT EXECUTED
*fail_idx = fstab_idx;
6930: 15885000 strne r5, [r8] <== NOT EXECUTED
}
return rc;
}
6934: e1a00007 mov r0, r7 <== NOT EXECUTED
6938: e8bd8ffc pop {r2, r3, 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,
693c: e58d7000 str r7, [sp] <== NOT EXECUTED
6940: e2440014 sub r0, r4, #20 <== NOT EXECUTED
6944: e890000f ldm r0, {r0, r1, r2, r3} <== NOT EXECUTED
6948: eb0005df bl 80cc <mount> <== NOT EXECUTED
fstab_ptr->target,
fstab_ptr->type,
fstab_ptr->options,
NULL);
if (tmp_rc != 0) {
694c: e2507000 subs r7, r0, #0 <== NOT EXECUTED
6950: e15430b4 ldrh r3, [r4, #-4] <== NOT EXECUTED
6954: 1affffd0 bne 689c <rtems_fsmount+0x74> <== NOT EXECUTED
6958: eaffffe3 b 68ec <rtems_fsmount+0xc4> <== NOT EXECUTED
00001a5c <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
1a5c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
1a60: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
1a64: e1a05001 mov r5, r1 <== NOT EXECUTED
1a68: e1a06000 mov r6, 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 );
1a6c: eb003259 bl e3d8 <strlen> <== NOT EXECUTED
1a70: e28d4004 add r4, sp, #4 <== NOT EXECUTED
1a74: e1a01000 mov r1, r0 <== NOT EXECUTED
1a78: e3a02000 mov r2, #0 <== NOT EXECUTED
1a7c: e1a03004 mov r3, r4 <== NOT EXECUTED
1a80: e3a0c001 mov ip, #1 <== NOT EXECUTED
1a84: e1a00006 mov r0, r6 <== NOT EXECUTED
1a88: e58dc000 str ip, [sp] <== NOT EXECUTED
1a8c: eb0000f1 bl 1e58 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
the_jnode = loc.node_access;
if ( !loc.ops->node_type_h ) {
1a90: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED
1a94: e5923010 ldr r3, [r2, #16] <== NOT EXECUTED
1a98: 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 );
1a9c: e1a07000 mov r7, r0 <== NOT EXECUTED
the_jnode = loc.node_access;
1aa0: e59d8004 ldr r8, [sp, #4] <== NOT EXECUTED
if ( !loc.ops->node_type_h ) {
1aa4: 1a000009 bne 1ad0 <rtems_io_lookup_name+0x74> <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
1aa8: e592301c ldr r3, [r2, #28] <== NOT EXECUTED
1aac: e3530000 cmp r3, #0 <== NOT EXECUTED
1ab0: 11a00004 movne r0, r4 <== NOT EXECUTED
1ab4: 11a0e00f movne lr, pc <== NOT EXECUTED
1ab8: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
1abc: eb002e40 bl d3c4 <__errno> <== NOT EXECUTED
1ac0: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
1ac4: e5803000 str r3, [r0] <== NOT EXECUTED
1ac8: e3e00000 mvn r0, #0 <== NOT EXECUTED
1acc: ea000026 b 1b6c <rtems_io_lookup_name+0x110> <== NOT EXECUTED
}
node_type = (*loc.ops->node_type_h)( &loc );
1ad0: e1a00004 mov r0, r4 <== NOT EXECUTED
1ad4: e1a0e00f mov lr, pc <== NOT EXECUTED
1ad8: e12fff13 bx r3 <== NOT EXECUTED
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
1adc: e3570000 cmp r7, #0 <== NOT EXECUTED
1ae0: 03500002 cmpeq r0, #2 <== NOT EXECUTED
1ae4: 03a0a000 moveq sl, #0 <== NOT EXECUTED
1ae8: 13a0a001 movne sl, #1 <== NOT EXECUTED
1aec: e59d7010 ldr r7, [sp, #16] <== NOT EXECUTED
1af0: 0a000008 beq 1b18 <rtems_io_lookup_name+0xbc> <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
1af4: e3570000 cmp r7, #0 <== NOT EXECUTED
1af8: 0a000018 beq 1b60 <rtems_io_lookup_name+0x104> <== NOT EXECUTED
1afc: e597301c ldr r3, [r7, #28] <== NOT EXECUTED
1b00: e3530000 cmp r3, #0 <== NOT EXECUTED
1b04: 0a000015 beq 1b60 <rtems_io_lookup_name+0x104> <== NOT EXECUTED
1b08: e1a00004 mov r0, r4 <== NOT EXECUTED
1b0c: e1a0e00f mov lr, pc <== NOT EXECUTED
1b10: e12fff13 bx r3 <== NOT EXECUTED
1b14: ea000011 b 1b60 <rtems_io_lookup_name+0x104> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
device_info->device_name = (char *) name;
1b18: e5856000 str r6, [r5] <== NOT EXECUTED
device_info->device_name_length = strlen( name );
1b1c: e1a00006 mov r0, r6 <== NOT EXECUTED
1b20: eb00322c bl e3d8 <strlen> <== NOT EXECUTED
1b24: e5850004 str r0, [r5, #4] <== NOT EXECUTED
device_info->major = the_jnode->info.device.major;
1b28: e5983050 ldr r3, [r8, #80] ; 0x50 <== NOT EXECUTED
1b2c: e5853008 str r3, [r5, #8] <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
1b30: e5983054 ldr r3, [r8, #84] ; 0x54 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
1b34: e3570000 cmp r7, #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;
1b38: e585300c str r3, [r5, #12] <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
1b3c: 0a000009 beq 1b68 <rtems_io_lookup_name+0x10c> <== NOT EXECUTED
1b40: e597301c ldr r3, [r7, #28] <== NOT EXECUTED
1b44: e3530000 cmp r3, #0 <== NOT EXECUTED
1b48: 0a000006 beq 1b68 <rtems_io_lookup_name+0x10c> <== NOT EXECUTED
1b4c: e1a00004 mov r0, r4 <== NOT EXECUTED
1b50: e1a0e00f mov lr, pc <== NOT EXECUTED
1b54: e12fff13 bx r3 <== NOT EXECUTED
1b58: e1a0000a mov r0, sl <== NOT EXECUTED
1b5c: ea000002 b 1b6c <rtems_io_lookup_name+0x110> <== NOT EXECUTED
1b60: e3a0000d mov r0, #13 <== NOT EXECUTED
1b64: ea000000 b 1b6c <rtems_io_lookup_name+0x110> <== NOT EXECUTED
1b68: e3a00000 mov r0, #0 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
1b6c: e28dd018 add sp, sp, #24 <== NOT EXECUTED
1b70: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
00001fdc <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
1fdc: e92d4011 push {r0, r4, lr}
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
1fe0: e59f4098 ldr r4, [pc, #152] ; 2080 <rtems_libio_init+0xa4>
1fe4: e5940000 ldr r0, [r4]
1fe8: e3500000 cmp r0, #0
1fec: 0a000013 beq 2040 <rtems_libio_init+0x64>
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
1ff0: e3a01040 mov r1, #64 ; 0x40
1ff4: ebffff2d bl 1cb0 <calloc>
1ff8: e59f3084 ldr r3, [pc, #132] ; 2084 <rtems_libio_init+0xa8>
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
1ffc: 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,
2000: e5830000 str r0, [r3]
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
2004: 0280001a addeq r0, r0, #26
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)
2008: 0a000015 beq 2064 <rtems_libio_init+0x88>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
200c: e59f3074 ldr r3, [pc, #116] ; 2088 <rtems_libio_init+0xac>
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
2010: 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;
2014: e5830000 str r0, [r3]
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
2018: e3a03000 mov r3, #0
201c: ea000000 b 2024 <rtems_libio_init+0x48>
iop->data1 = iop + 1;
2020: e500000c str r0, [r0, #-12]
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++)
2024: e2833001 add r3, r3, #1
2028: e1530001 cmp r3, r1
iop->data1 = iop + 1;
202c: e1a02000 mov r2, r0
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++)
2030: e2800040 add r0, r0, #64 ; 0x40
2034: 3afffff9 bcc 2020 <rtems_libio_init+0x44>
iop->data1 = iop + 1;
iop->data1 = NULL;
2038: e3a03000 mov r3, #0
203c: e5823034 str r3, [r2, #52] ; 0x34
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
2040: e59fc044 ldr ip, [pc, #68] ; 208c <rtems_libio_init+0xb0>
2044: e59f0044 ldr r0, [pc, #68] ; 2090 <rtems_libio_init+0xb4>
2048: e3a01001 mov r1, #1
204c: e3a02054 mov r2, #84 ; 0x54
2050: e3a03000 mov r3, #0
2054: e58dc000 str ip, [sp]
2058: eb000bbd bl 4f54 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
205c: e3500000 cmp r0, #0
2060: 0a000000 beq 2068 <rtems_libio_init+0x8c>
rtems_fatal_error_occurred( rc );
2064: eb000dcf bl 57a8 <rtems_fatal_error_occurred> <== NOT EXECUTED
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
2068: e59f3024 ldr r3, [pc, #36] ; 2094 <rtems_libio_init+0xb8>
206c: e5933000 ldr r3, [r3]
2070: e3530000 cmp r3, #0
(* rtems_fs_init_helper)();
2074: 11a0e00f movne lr, pc
2078: 112fff13 bxne r3
}
207c: e8bd8018 pop {r3, r4, pc}
000265f0 <rtems_libio_set_private_env>:
rtems_filesystem_freenode( &env->root_directory);
free(env);
}
}
rtems_status_code rtems_libio_set_private_env(void) {
265f0: e92d41f0 push {r4, r5, r6, r7, r8, lr}
rtems_status_code sc;
rtems_id task_id;
rtems_filesystem_location_info_t loc;
sc=rtems_task_ident(RTEMS_SELF,0,&task_id);
265f4: e3a00000 mov r0, #0
rtems_filesystem_freenode( &env->root_directory);
free(env);
}
}
rtems_status_code rtems_libio_set_private_env(void) {
265f8: 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);
265fc: e1a01000 mov r1, r0
26600: e28d2018 add r2, sp, #24
26604: eb000470 bl 277cc <rtems_task_ident>
if (sc != RTEMS_SUCCESSFUL) return sc;
26608: e2508000 subs r8, r0, #0
2660c: 1a000037 bne 266f0 <rtems_libio_set_private_env+0x100>
/* Only for the first time a malloc is necesary */
if (rtems_current_user_env==&rtems_global_user_env) {
26610: e59f40e4 ldr r4, [pc, #228] ; 266fc <rtems_libio_set_private_env+0x10c>
26614: e59f30e4 ldr r3, [pc, #228] ; 26700 <rtems_libio_set_private_env+0x110>
26618: e5942000 ldr r2, [r4]
2661c: e1520003 cmp r2, r3
26620: 1a00000f bne 26664 <rtems_libio_set_private_env+0x74>
rtems_user_env_t *tmp = malloc(sizeof(rtems_user_env_t));
26624: e2800048 add r0, r0, #72 ; 0x48
26628: ebff85c8 bl 7d50 <malloc>
if (!tmp)
2662c: e2505000 subs r5, r0, #0
26630: 03a0801a moveq r8, #26
26634: 0a00002d beq 266f0 <rtems_libio_set_private_env+0x100>
#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);
26638: e1a00008 mov r0, r8
2663c: e1a01004 mov r1, r4
26640: e59f20bc ldr r2, [pc, #188] ; 26704 <rtems_libio_set_private_env+0x114>
26644: eb000500 bl 27a4c <rtems_task_variable_add>
if (sc != RTEMS_SUCCESSFUL) {
26648: e2506000 subs r6, r0, #0
* not initialized yet
*/
free(tmp);
return sc;
}
rtems_current_user_env = tmp;
2664c: 05845000 streq r5, [r4]
#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) {
26650: 0a000003 beq 26664 <rtems_libio_set_private_env+0x74>
/* don't use free_user_env because the pathlocs are
* not initialized yet
*/
free(tmp);
26654: e1a00005 mov r0, r5 <== NOT EXECUTED
26658: ebff8415 bl 76b4 <free> <== NOT EXECUTED
2665c: e1a08006 mov r8, r6 <== NOT EXECUTED
return sc;
26660: ea000022 b 266f0 <rtems_libio_set_private_env+0x100> <== NOT EXECUTED
}
rtems_current_user_env = tmp;
};
*rtems_current_user_env = rtems_global_user_env; /* get the global values*/
26664: e59f6090 ldr r6, [pc, #144] ; 266fc <rtems_libio_set_private_env+0x10c>
26668: e5967000 ldr r7, [r6]
2666c: e59f108c ldr r1, [pc, #140] ; 26700 <rtems_libio_set_private_env+0x110>
26670: e3a02048 mov r2, #72 ; 0x48
26674: e1a00007 mov r0, r7
26678: eb0066d0 bl 401c0 <memcpy>
rtems_current_user_env->task_id=task_id; /* mark the local values*/
2667c: 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);
26680: e28d4004 add r4, sp, #4
26684: e3a05000 mov r5, #0
}
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*/
26688: e5873000 str r3, [r7]
* 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);
2668c: e3a01001 mov r1, #1
26690: e1a03004 mov r3, r4
26694: e1a02005 mov r2, r5
26698: e59f0068 ldr r0, [pc, #104] ; 26708 <rtems_libio_set_private_env+0x118>
rtems_filesystem_root = loc;
2669c: e1a07004 mov r7, 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);
266a0: e58d5000 str r5, [sp]
266a4: ebff83e4 bl 763c <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
266a8: e596c000 ldr ip, [r6]
266ac: e8b7000f ldm r7!, {r0, r1, r2, r3}
266b0: e28cc018 add ip, ip, #24
266b4: e8ac000f stmia ip!, {r0, r1, r2, r3}
266b8: e5973000 ldr r3, [r7]
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
266bc: e1a02005 mov r2, r5
* 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;
266c0: e58c3000 str r3, [ip]
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
266c4: e3a01001 mov r1, #1
266c8: e1a03004 mov r3, r4
266cc: e59f0034 ldr r0, [pc, #52] ; 26708 <rtems_libio_set_private_env+0x118>
266d0: e58d5000 str r5, [sp]
266d4: ebff83d8 bl 763c <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
266d8: e596c000 ldr ip, [r6]
266dc: e8b4000f ldm r4!, {r0, r1, r2, r3}
266e0: e28cc004 add ip, ip, #4
266e4: e8ac000f stmia ip!, {r0, r1, r2, r3}
266e8: e5973000 ldr r3, [r7]
266ec: e58c3000 str r3, [ip]
return RTEMS_SUCCESSFUL;
}
266f0: e1a00008 mov r0, r8
266f4: e28dd01c add sp, sp, #28
266f8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
0002654c <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) {
2654c: e92d4033 push {r0, r1, r4, r5, lr} <== NOT EXECUTED
26550: e1a05000 mov r5, r0 <== 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);
26554: e3a00000 mov r0, #0 <== NOT EXECUTED
26558: e1a01000 mov r1, r0 <== NOT EXECUTED
2655c: e1a0200d mov r2, sp <== NOT EXECUTED
26560: eb000499 bl 277cc <rtems_task_ident> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) return sc;
26564: e2503000 subs r3, r0, #0 <== NOT EXECUTED
26568: 1a00001b bne 265dc <rtems_libio_share_private_env+0x90> <== NOT EXECUTED
if (rtems_current_user_env->task_id==current_task_id) {
2656c: e59f1070 ldr r1, [pc, #112] ; 265e4 <rtems_libio_share_private_env+0x98><== NOT EXECUTED
26570: e5914000 ldr r4, [r1] <== NOT EXECUTED
26574: e59d3000 ldr r3, [sp] <== NOT EXECUTED
26578: e5942000 ldr r2, [r4] <== NOT EXECUTED
2657c: e1520003 cmp r2, r3 <== NOT EXECUTED
26580: 1a000004 bne 26598 <rtems_libio_share_private_env+0x4c> <== NOT EXECUTED
/* 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);
26584: eb000559 bl 27af0 <rtems_task_variable_delete> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) return sc;
26588: e2503000 subs r3, r0, #0 <== NOT EXECUTED
2658c: 1a000012 bne 265dc <rtems_libio_share_private_env+0x90> <== NOT EXECUTED
free_user_env(tmp);
26590: e1a00004 mov r0, r4 <== NOT EXECUTED
26594: ebffffd3 bl 264e8 <free_user_env> <== NOT EXECUTED
};
/* AT THIS POINT, rtems_current_user_env is DANGLING */
sc = rtems_task_variable_get(task_id,(void*)&rtems_current_user_env,
26598: e59f4044 ldr r4, [pc, #68] ; 265e4 <rtems_libio_share_private_env+0x98><== NOT EXECUTED
2659c: e1a00005 mov r0, r5 <== NOT EXECUTED
265a0: e1a01004 mov r1, r4 <== NOT EXECUTED
265a4: e28d2004 add r2, sp, #4 <== NOT EXECUTED
265a8: eb00056d bl 27b64 <rtems_task_variable_get> <== NOT EXECUTED
(void*)&shared_user_env );
if (sc != RTEMS_SUCCESSFUL)
265ac: e2503000 subs r3, r0, #0 <== NOT EXECUTED
265b0: 1a000006 bne 265d0 <rtems_libio_share_private_env+0x84> <== NOT EXECUTED
goto bailout;
sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,free_user_env);
265b4: e59f202c ldr r2, [pc, #44] ; 265e8 <rtems_libio_share_private_env+0x9c><== NOT EXECUTED
265b8: e1a01004 mov r1, r4 <== NOT EXECUTED
265bc: eb000522 bl 27a4c <rtems_task_variable_add> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
265c0: e2503000 subs r3, r0, #0 <== NOT EXECUTED
goto bailout;
/* the current_user_env is the same pointer that remote env */
rtems_current_user_env = shared_user_env;
265c4: 059d2004 ldreq r2, [sp, #4] <== NOT EXECUTED
265c8: 05842000 streq r2, [r4] <== NOT EXECUTED
(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);
if (sc != RTEMS_SUCCESSFUL)
265cc: 0a000002 beq 265dc <rtems_libio_share_private_env+0x90> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
bailout:
/* fallback to the global env */
rtems_current_user_env = &rtems_global_user_env;
265d0: e59f1014 ldr r1, [pc, #20] ; 265ec <rtems_libio_share_private_env+0xa0><== NOT EXECUTED
265d4: e59f2008 ldr r2, [pc, #8] ; 265e4 <rtems_libio_share_private_env+0x98><== NOT EXECUTED
265d8: e5821000 str r1, [r2] <== NOT EXECUTED
return sc;
}
265dc: e1a00003 mov r0, r3 <== NOT EXECUTED
265e0: e8bd803c pop {r2, r3, r4, r5, pc} <== NOT EXECUTED
00007e48 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
7e48: e92d4801 push {r0, fp, lr} <== NOT EXECUTED
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
7e4c: e59f3038 ldr r3, [pc, #56] ; 7e8c <rtems_malloc_statistics_at_free+0x44><== NOT EXECUTED
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
7e50: e1a01000 mov r1, r0 <== NOT EXECUTED
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
7e54: e1a0200d mov r2, sp <== NOT EXECUTED
7e58: e5930000 ldr r0, [r3] <== NOT EXECUTED
7e5c: eb0015ce bl d59c <_Protected_heap_Get_block_size> <== NOT EXECUTED
7e60: e3500000 cmp r0, #0 <== NOT EXECUTED
7e64: 0a000007 beq 7e88 <rtems_malloc_statistics_at_free+0x40> <== NOT EXECUTED
MSBUMP(lifetime_freed, size);
7e68: e59f3020 ldr r3, [pc, #32] ; 7e90 <rtems_malloc_statistics_at_free+0x48><== NOT EXECUTED
7e6c: e59d0000 ldr r0, [sp] <== NOT EXECUTED
7e70: e283c024 add ip, r3, #36 ; 0x24 <== NOT EXECUTED
7e74: e89c1800 ldm ip, {fp, ip} <== NOT EXECUTED
7e78: e09b1000 adds r1, fp, r0 <== NOT EXECUTED
7e7c: e2ac2000 adc r2, ip, #0 <== NOT EXECUTED
7e80: e5831024 str r1, [r3, #36] ; 0x24 <== NOT EXECUTED
7e84: e5832028 str r2, [r3, #40] ; 0x28 <== NOT EXECUTED
}
}
7e88: e8bd8808 pop {r3, fp, pc} <== NOT EXECUTED
00008ca4 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
8ca4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
8ca8: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED
8cac: e1a0b001 mov fp, r1 <== NOT EXECUTED
int success = 0;
char *dup_path = strdup(path);
8cb0: eb00e9ef bl 43474 <strdup> <== NOT EXECUTED
if (dup_path != NULL) {
8cb4: e2506000 subs r6, r0, #0 <== NOT EXECUTED
8cb8: 0a000057 beq 8e1c <rtems_mkdir+0x178> <== NOT EXECUTED
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
8cbc: e5d63000 ldrb r3, [r6] <== NOT EXECUTED
++p;
8cc0: e3a07000 mov r7, #0 <== NOT EXECUTED
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
8cc4: e353002f cmp r3, #47 ; 0x2f <== NOT EXECUTED
8cc8: 11a05006 movne r5, r6 <== NOT EXECUTED
++p;
8ccc: 02865001 addeq r5, r6, #1 <== NOT EXECUTED
8cd0: e3a03001 mov r3, #1 <== NOT EXECUTED
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
8cd4: e1a09007 mov r9, r7 <== NOT EXECUTED
retval = 0;
break;
}
}
if (!last)
*p = '/';
8cd8: e3a0a02f mov sl, #47 ; 0x2f <== 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) {
8cdc: e1a0800d mov r8, sp <== NOT EXECUTED
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
8ce0: e5d52000 ldrb r2, [r5] <== NOT EXECUTED
8ce4: e3520000 cmp r2, #0 <== NOT EXECUTED
8ce8: 02822001 addeq r2, r2, #1 <== NOT EXECUTED
8cec: 0a000002 beq 8cfc <rtems_mkdir+0x58> <== NOT EXECUTED
last = 1;
else if (p[0] != '/')
8cf0: e352002f cmp r2, #47 ; 0x2f <== NOT EXECUTED
8cf4: 1a00003c bne 8dec <rtems_mkdir+0x148> <== NOT EXECUTED
8cf8: e3a02000 mov r2, #0 <== NOT EXECUTED
continue;
*p = '\0';
if (!last && p[1] == '\0')
8cfc: e3520000 cmp r2, #0 <== NOT EXECUTED
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
8d00: e5c59000 strb r9, [r5] <== NOT EXECUTED
if (!last && p[1] == '\0')
8d04: 13a04001 movne r4, #1 <== NOT EXECUTED
8d08: 1a000002 bne 8d18 <rtems_mkdir+0x74> <== NOT EXECUTED
8d0c: e5d54001 ldrb r4, [r5, #1] <== NOT EXECUTED
8d10: e2744001 rsbs r4, r4, #1 <== NOT EXECUTED
8d14: 33a04000 movcc r4, #0 <== NOT EXECUTED
last = 1;
if (first) {
8d18: e3530000 cmp r3, #0 <== NOT EXECUTED
8d1c: 0a000004 beq 8d34 <rtems_mkdir+0x90> <== NOT EXECUTED
* mkdir [-m mode] dir
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
8d20: e3a00000 mov r0, #0 <== NOT EXECUTED
8d24: eb000755 bl aa80 <umask> <== NOT EXECUTED
8d28: e1a07000 mov r7, r0 <== NOT EXECUTED
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
8d2c: e3c000c0 bic r0, r0, #192 ; 0xc0 <== NOT EXECUTED
8d30: eb000752 bl aa80 <umask> <== NOT EXECUTED
first = 0;
}
if (last)
8d34: e3540000 cmp r4, #0 <== NOT EXECUTED
8d38: 059f10f0 ldreq r1, [pc, #240] ; 8e30 <rtems_mkdir+0x18c> <== NOT EXECUTED
8d3c: 0a000002 beq 8d4c <rtems_mkdir+0xa8> <== NOT EXECUTED
(void)umask(oumask);
8d40: e1a00007 mov r0, r7 <== NOT EXECUTED
8d44: eb00074d bl aa80 <umask> <== NOT EXECUTED
8d48: e1a0100b mov r1, fp <== NOT EXECUTED
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
8d4c: e1a00006 mov r0, r6 <== NOT EXECUTED
8d50: ebfffc6e bl 7f10 <mkdir> <== NOT EXECUTED
8d54: e3500000 cmp r0, #0 <== NOT EXECUTED
8d58: aa00001f bge 8ddc <rtems_mkdir+0x138> <== NOT EXECUTED
if (errno == EEXIST || errno == EISDIR) {
8d5c: eb00d067 bl 3cf00 <__errno> <== NOT EXECUTED
8d60: e5903000 ldr r3, [r0] <== NOT EXECUTED
8d64: e3530011 cmp r3, #17 <== NOT EXECUTED
8d68: 0a000003 beq 8d7c <rtems_mkdir+0xd8> <== NOT EXECUTED
8d6c: eb00d063 bl 3cf00 <__errno> <== NOT EXECUTED
8d70: e5903000 ldr r3, [r0] <== NOT EXECUTED
8d74: e3530015 cmp r3, #21 <== NOT EXECUTED
8d78: 1a00001d bne 8df4 <rtems_mkdir+0x150> <== NOT EXECUTED
if (stat(path, &sb) < 0) {
8d7c: e1a00006 mov r0, r6 <== NOT EXECUTED
8d80: e1a0100d mov r1, sp <== NOT EXECUTED
8d84: eb00002a bl 8e34 <stat> <== NOT EXECUTED
8d88: e3500000 cmp r0, #0 <== NOT EXECUTED
8d8c: ba000018 blt 8df4 <rtems_mkdir+0x150> <== NOT EXECUTED
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
8d90: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
8d94: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
8d98: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED
8d9c: 0a00000a beq 8dcc <rtems_mkdir+0x128> <== NOT EXECUTED
if (last)
8da0: e3540000 cmp r4, #0 <== NOT EXECUTED
8da4: 0a000004 beq 8dbc <rtems_mkdir+0x118> <== NOT EXECUTED
errno = EEXIST;
8da8: eb00d054 bl 3cf00 <__errno> <== NOT EXECUTED
8dac: e3a03011 mov r3, #17 <== NOT EXECUTED
8db0: e5803000 str r3, [r0] <== NOT EXECUTED
8db4: e3a04000 mov r4, #0 <== NOT EXECUTED
8db8: ea000012 b 8e08 <rtems_mkdir+0x164> <== NOT EXECUTED
else
errno = ENOTDIR;
8dbc: eb00d04f bl 3cf00 <__errno> <== NOT EXECUTED
8dc0: e3a03014 mov r3, #20 <== NOT EXECUTED
8dc4: e5803000 str r3, [r0] <== NOT EXECUTED
8dc8: ea00000c b 8e00 <rtems_mkdir+0x15c> <== NOT EXECUTED
retval = 0;
break;
}
if (last)
8dcc: e3540000 cmp r4, #0 <== NOT EXECUTED
8dd0: 0a000003 beq 8de4 <rtems_mkdir+0x140> <== NOT EXECUTED
8dd4: e3a04002 mov r4, #2 <== NOT EXECUTED
8dd8: ea00000a b 8e08 <rtems_mkdir+0x164> <== NOT EXECUTED
} else {
retval = 0;
break;
}
}
if (!last)
8ddc: e3540000 cmp r4, #0 <== NOT EXECUTED
8de0: 1a000010 bne 8e28 <rtems_mkdir+0x184> <== NOT EXECUTED
*p = '/';
8de4: e5c5a000 strb sl, [r5] <== NOT EXECUTED
8de8: e3a03000 mov r3, #0 <== NOT EXECUTED
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
8dec: e2855001 add r5, r5, #1 <== NOT EXECUTED
8df0: eaffffba b 8ce0 <rtems_mkdir+0x3c> <== NOT EXECUTED
}
}
if (!last)
*p = '/';
}
if (!first && !last)
8df4: e3540000 cmp r4, #0 <== NOT EXECUTED
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
8df8: e3a04000 mov r4, #0 <== NOT EXECUTED
}
}
if (!last)
*p = '/';
}
if (!first && !last)
8dfc: 1a000001 bne 8e08 <rtems_mkdir+0x164> <== NOT EXECUTED
(void)umask(oumask);
8e00: e1a00007 mov r0, r7 <== NOT EXECUTED
8e04: eb00071d bl aa80 <umask> <== NOT EXECUTED
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
8e08: e1a00006 mov r0, r6 <== NOT EXECUTED
8e0c: ebfffa28 bl 76b4 <free> <== NOT EXECUTED
}
return success != 0 ? 0 : -1;
8e10: e3540000 cmp r4, #0 <== NOT EXECUTED
8e14: 13a00000 movne r0, #0 <== NOT EXECUTED
8e18: 1a000000 bne 8e20 <rtems_mkdir+0x17c> <== NOT EXECUTED
8e1c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
8e20: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
8e24: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
}
return success != 0 ? 0 : -1;
8e28: e3a04001 mov r4, #1 <== NOT EXECUTED
8e2c: eafffff5 b 8e08 <rtems_mkdir+0x164> <== NOT EXECUTED
0001dbb0 <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)
{
1dbb0: e92d4010 push {r4, lr} <== NOT EXECUTED
1dbb4: e1a04800 lsl r4, r0, #16 <== NOT EXECUTED
uint32_t b;
rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
1dbb8: e3a00c02 mov r0, #512 ; 0x200 <== NOT EXECUTED
1dbbc: ebffa863 bl 7d50 <malloc> <== NOT EXECUTED
1dbc0: e59f3054 ldr r3, [pc, #84] ; 1dc1c <rtems_nvdisk_crc16_gen_factors+0x6c><== NOT EXECUTED
if (!rtems_nvdisk_crc16_factor)
1dbc4: 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);
1dbc8: 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)
{
1dbcc: e1a04824 lsr r4, r4, #16 <== NOT EXECUTED
uint32_t b;
rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_nvdisk_crc16_factor)
1dbd0: 0280001a addeq r0, r0, #26 <== NOT EXECUTED
1dbd4: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
1dbd8: e3a03000 mov r3, #0 <== NOT EXECUTED
1dbdc: e1a02803 lsl r2, r3, #16 <== NOT EXECUTED
1dbe0: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED
1dbe4: e3a01008 mov r1, #8 <== NOT EXECUTED
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
1dbe8: ea000002 b 1dbf8 <rtems_nvdisk_crc16_gen_factors+0x48> <== NOT EXECUTED
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
1dbec: e3120001 tst r2, #1 <== NOT EXECUTED
1dbf0: e1a020a2 lsr r2, r2, #1 <== NOT EXECUTED
1dbf4: 10222004 eorne r2, r2, r4 <== NOT EXECUTED
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
1dbf8: e2511001 subs r1, r1, #1 <== NOT EXECUTED
1dbfc: 2afffffa bcs 1dbec <rtems_nvdisk_crc16_gen_factors+0x3c> <== NOT EXECUTED
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
rtems_nvdisk_crc16_factor[b] = v & 0xffff;
1dc00: e1a01083 lsl r1, r3, #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++)
1dc04: e2833001 add r3, r3, #1 <== NOT EXECUTED
1dc08: e3530c01 cmp r3, #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;
1dc0c: e18020b1 strh r2, [r0, r1] <== 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++)
1dc10: 1afffff1 bne 1dbdc <rtems_nvdisk_crc16_gen_factors+0x2c> <== NOT EXECUTED
1dc14: e3a00000 mov r0, #0 <== NOT EXECUTED
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
rtems_nvdisk_crc16_factor[b] = v & 0xffff;
}
return RTEMS_SUCCESSFUL;
}
1dc18: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0001d540 <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, ...)
{
1d540: e92d000f push {r0, r1, r2, r3} <== NOT EXECUTED
1d544: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "nvdisk:error:");
1d548: e59f4058 ldr r4, [pc, #88] ; 1d5a8 <rtems_nvdisk_error+0x68><== NOT EXECUTED
1d54c: e5943000 ldr r3, [r4] <== NOT EXECUTED
1d550: e59f0054 ldr r0, [pc, #84] ; 1d5ac <rtems_nvdisk_error+0x6c><== NOT EXECUTED
1d554: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
static int
rtems_nvdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
1d558: e28d3014 add r3, sp, #20 <== NOT EXECUTED
1d55c: e58d3000 str r3, [sp] <== NOT EXECUTED
fprintf (stderr, "nvdisk:error:");
1d560: eb00813e bl 3da60 <fputs> <== NOT EXECUTED
ret = vfprintf (stderr, format, args);
1d564: e5943000 ldr r3, [r4] <== NOT EXECUTED
1d568: e59d2000 ldr r2, [sp] <== NOT EXECUTED
1d56c: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
1d570: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
1d574: eb00b97e bl 4bb74 <vfprintf> <== NOT EXECUTED
fprintf (stderr, "\n");
1d578: e5943000 ldr r3, [r4] <== NOT EXECUTED
{
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "nvdisk:error:");
ret = vfprintf (stderr, format, args);
1d57c: e1a05000 mov r5, r0 <== NOT EXECUTED
fprintf (stderr, "\n");
1d580: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
1d584: e3a0000a mov r0, #10 <== NOT EXECUTED
1d588: eb0080ef bl 3d94c <fputc> <== NOT EXECUTED
fflush (stderr);
1d58c: e5943000 ldr r3, [r4] <== NOT EXECUTED
1d590: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
1d594: eb007f4c bl 3d2cc <fflush> <== NOT EXECUTED
va_end (args);
return ret;
}
1d598: e1a00005 mov r0, r5 <== NOT EXECUTED
1d59c: e8bd4038 pop {r3, r4, r5, lr} <== NOT EXECUTED
1d5a0: e28dd010 add sp, sp, #16 <== NOT EXECUTED
1d5a4: e12fff1e bx lr <== NOT EXECUTED
0001d5b0 <rtems_nvdisk_get_device>:
/**
* Map a block to a device.
*/
static rtems_nvdisk_device_ctl*
rtems_nvdisk_get_device (rtems_nvdisk* nvd, uint32_t block)
{
1d5b0: e1a02000 mov r2, r0 <== NOT EXECUTED
uint32_t device;
if (block >= nvd->block_count)
1d5b4: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
1d5b8: e1510000 cmp r1, r0 <== NOT EXECUTED
/**
* Map a block to a device.
*/
static rtems_nvdisk_device_ctl*
rtems_nvdisk_get_device (rtems_nvdisk* nvd, uint32_t block)
{
1d5bc: e1a03001 mov r3, r1 <== NOT EXECUTED
{
rtems_nvdisk_error ("read-block: bad block: %d", block);
return NULL;
}
for (device = 0; device < nvd->device_count; device++)
1d5c0: 33a01000 movcc r1, #0 <== NOT EXECUTED
/**
* Map a block to a device.
*/
static rtems_nvdisk_device_ctl*
rtems_nvdisk_get_device (rtems_nvdisk* nvd, uint32_t block)
{
1d5c4: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
{
rtems_nvdisk_error ("read-block: bad block: %d", block);
return NULL;
}
for (device = 0; device < nvd->device_count; device++)
1d5c8: 31a0c001 movcc ip, r1 <== NOT EXECUTED
1d5cc: 35925018 ldrcc r5, [r2, #24] <== NOT EXECUTED
static rtems_nvdisk_device_ctl*
rtems_nvdisk_get_device (rtems_nvdisk* nvd, uint32_t block)
{
uint32_t device;
if (block >= nvd->block_count)
1d5d0: 3a000010 bcc 1d618 <rtems_nvdisk_get_device+0x68> <== NOT EXECUTED
{
rtems_nvdisk_error ("read-block: bad block: %d", block);
1d5d4: e59f0058 ldr r0, [pc, #88] ; 1d634 <rtems_nvdisk_get_device+0x84><== NOT EXECUTED
1d5d8: ebffffd8 bl 1d540 <rtems_nvdisk_error> <== NOT EXECUTED
1d5dc: e3a00000 mov r0, #0 <== NOT EXECUTED
return NULL;
1d5e0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
}
for (device = 0; device < nvd->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
1d5e4: e5920014 ldr r0, [r2, #20] <== NOT EXECUTED
1d5e8: e0800001 add r0, r0, r1 <== NOT EXECUTED
if ((block >= dc->block_base) &&
1d5ec: e590400c ldr r4, [r0, #12] <== NOT EXECUTED
1d5f0: e1530004 cmp r3, r4 <== NOT EXECUTED
1d5f4: 3a000005 bcc 1d610 <rtems_nvdisk_get_device+0x60> <== NOT EXECUTED
(block < (dc->block_base + dc->pages - dc->pages_desc)))
1d5f8: e5907004 ldr r7, [r0, #4] <== NOT EXECUTED
1d5fc: e5906008 ldr r6, [r0, #8] <== NOT EXECUTED
1d600: e0844007 add r4, r4, r7 <== NOT EXECUTED
1d604: e0664004 rsb r4, r6, r4 <== NOT EXECUTED
1d608: e1530004 cmp r3, r4 <== NOT EXECUTED
1d60c: 38bd80f0 popcc {r4, r5, r6, r7, pc} <== NOT EXECUTED
{
rtems_nvdisk_error ("read-block: bad block: %d", block);
return NULL;
}
for (device = 0; device < nvd->device_count; device++)
1d610: e28cc001 add ip, ip, #1 <== NOT EXECUTED
1d614: e2811014 add r1, r1, #20 <== NOT EXECUTED
1d618: e15c0005 cmp ip, r5 <== NOT EXECUTED
1d61c: 3afffff0 bcc 1d5e4 <rtems_nvdisk_get_device+0x34> <== 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);
1d620: e1a01003 mov r1, r3 <== NOT EXECUTED
1d624: e59f000c ldr r0, [pc, #12] ; 1d638 <rtems_nvdisk_get_device+0x88><== NOT EXECUTED
1d628: ebffffc4 bl 1d540 <rtems_nvdisk_error> <== NOT EXECUTED
1d62c: e3a00000 mov r0, #0 <== NOT EXECUTED
return NULL;
}
1d630: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
0001dc20 <rtems_nvdisk_initialize>:
*/
rtems_device_driver
rtems_nvdisk_initialize (rtems_device_major_number major,
rtems_device_minor_number minor,
void* arg __attribute__((unused)))
{
1dc20: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
1dc24: e24dd038 sub sp, sp, #56 ; 0x38 <== NOT EXECUTED
1dc28: e58d0018 str r0, [sp, #24] <== NOT EXECUTED
const rtems_nvdisk_config* c = rtems_nvdisk_configuration;
rtems_nvdisk* nvd;
rtems_status_code sc;
sc = rtems_disk_io_initialize ();
1dc2c: ebffa123 bl 60c0 <rtems_disk_io_initialize> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
1dc30: e2508000 subs r8, r0, #0 <== NOT EXECUTED
1dc34: 1a000080 bne 1de3c <rtems_nvdisk_initialize+0x21c> <== NOT EXECUTED
return sc;
sc = rtems_nvdisk_crc16_gen_factors (0x8408);
1dc38: e59f0208 ldr r0, [pc, #520] ; 1de48 <rtems_nvdisk_initialize+0x228><== NOT EXECUTED
1dc3c: ebffffdb bl 1dbb0 <rtems_nvdisk_crc16_gen_factors> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
1dc40: e2506000 subs r6, r0, #0 <== NOT EXECUTED
1dc44: 11a08006 movne r8, r6 <== NOT EXECUTED
1dc48: 1a00007b bne 1de3c <rtems_nvdisk_initialize+0x21c> <== NOT EXECUTED
return sc;
rtems_nvdisks = calloc (rtems_nvdisk_configuration_size,
1dc4c: e59f41f8 ldr r4, [pc, #504] ; 1de4c <rtems_nvdisk_initialize+0x22c><== NOT EXECUTED
1dc50: e3a01028 mov r1, #40 ; 0x28 <== NOT EXECUTED
1dc54: e5940000 ldr r0, [r4] <== NOT EXECUTED
1dc58: ebffa525 bl 70f4 <calloc> <== NOT EXECUTED
1dc5c: e59f31ec ldr r3, [pc, #492] ; 1de50 <rtems_nvdisk_initialize+0x230><== NOT EXECUTED
sizeof (rtems_nvdisk));
if (!rtems_nvdisks)
1dc60: 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,
1dc64: e5830004 str r0, [r3, #4] <== NOT EXECUTED
sizeof (rtems_nvdisk));
if (!rtems_nvdisks)
1dc68: 159f51e4 ldrne r5, [pc, #484] ; 1de54 <rtems_nvdisk_initialize+0x234><== NOT EXECUTED
1dc6c: 11a07006 movne r7, r6 <== NOT EXECUTED
1dc70: 1a000068 bne 1de18 <rtems_nvdisk_initialize+0x1f8> <== NOT EXECUTED
1dc74: ea00006f b 1de38 <rtems_nvdisk_initialize+0x218> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
1dc78: e59f11d8 ldr r1, [pc, #472] ; 1de58 <rtems_nvdisk_initialize+0x238><== NOT EXECUTED
1dc7c: e3a0200a mov r2, #10 <== NOT EXECUTED
1dc80: e28d0024 add r0, sp, #36 ; 0x24 <== NOT EXECUTED
1dc84: eb00894d bl 401c0 <memcpy> <== NOT EXECUTED
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
nvd = &rtems_nvdisks[minor];
1dc88: e59f11c0 ldr r1, [pc, #448] ; 1de50 <rtems_nvdisk_initialize+0x230><== NOT EXECUTED
name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor;
1dc8c: e5dd202d ldrb r2, [sp, #45] ; 0x2d <== 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];
1dc90: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
1dc94: e59dc018 ldr ip, [sp, #24] <== NOT EXECUTED
temp.__overlay.minor = _minor;
1dc98: e58d7034 str r7, [sp, #52] ; 0x34 <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
1dc9c: e58dc030 str ip, [sp, #48] ; 0x30 <== NOT EXECUTED
1dca0: e0834006 add r4, r3, r6 <== NOT EXECUTED
name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor;
1dca4: e0872002 add r2, r7, r2 <== NOT EXECUTED
1dca8: e5cd202d strb r2, [sp, #45] ; 0x2d <== NOT EXECUTED
temp.__overlay.minor = _minor;
return temp.device;
1dcac: e28d2030 add r2, sp, #48 ; 0x30 <== NOT EXECUTED
1dcb0: e8920006 ldm r2, {r1, r2} <== NOT EXECUTED
nvd->major = major;
1dcb4: e783c006 str ip, [r3, r6] <== NOT EXECUTED
nvd->minor = minor;
1dcb8: e5847004 str r7, [r4, #4] <== NOT EXECUTED
nvd->flags = c->flags;
1dcbc: e5953000 ldr r3, [r5] <== NOT EXECUTED
1dcc0: e5843008 str r3, [r4, #8] <== NOT EXECUTED
nvd->block_size = c->block_size;
1dcc4: e515300c ldr r3, [r5, #-12] <== NOT EXECUTED
1dcc8: e584300c str r3, [r4, #12] <== NOT EXECUTED
nvd->info_level = c->info_level;
1dccc: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED
1dcd0: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
1dcd4: e58d101c str r1, [sp, #28] <== NOT EXECUTED
1dcd8: e58d2020 str r2, [sp, #32] <== NOT EXECUTED
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
1dcdc: e5150008 ldr r0, [r5, #-8] <== NOT EXECUTED
1dce0: e3a01014 mov r1, #20 <== NOT EXECUTED
1dce4: ebffa502 bl 70f4 <calloc> <== NOT EXECUTED
if (!nvd->devices)
1dce8: 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));
1dcec: e5840014 str r0, [r4, #20] <== NOT EXECUTED
if (!nvd->devices)
1dcf0: 0a000050 beq 1de38 <rtems_nvdisk_initialize+0x218> <== NOT EXECUTED
1dcf4: e3a08000 mov r8, #0 <== NOT EXECUTED
1dcf8: e1a0a008 mov sl, r8 <== NOT EXECUTED
1dcfc: e1a09008 mov r9, r8 <== NOT EXECUTED
1dd00: e1a03006 mov r3, r6 <== NOT EXECUTED
1dd04: ea00001f b 1dd88 <rtems_nvdisk_initialize+0x168> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
for (device = 0; device < c->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
1dd08: e5946014 ldr r6, [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;
1dd0c: e515b004 ldr fp, [r5, #-4] <== NOT EXECUTED
for (device = 0; device < c->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
dc->device = device;
1dd10: e7869008 str r9, [r6, r8] <== 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;
1dd14: e08bb209 add fp, fp, r9, lsl #4 <== NOT EXECUTED
1dd18: e594100c ldr r1, [r4, #12] <== NOT EXECUTED
1dd1c: e59b0008 ldr r0, [fp, #8] <== NOT EXECUTED
1dd20: e58d300c str r3, [sp, #12] <== NOT EXECUTED
1dd24: eb00dc33 bl 54df8 <__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];
1dd28: e0866008 add r6, r6, r8 <== NOT EXECUTED
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
1dd2c: e5860004 str r0, [r6, #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;
1dd30: e594c00c ldr ip, [r4, #12] <== NOT EXECUTED
1dd34: e1a02000 mov r2, 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;
1dd38: e1a0100c mov r1, ip <== NOT EXECUTED
1dd3c: e59b0008 ldr r0, [fp, #8] <== NOT EXECUTED
1dd40: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
1dd44: e58dc014 str ip, [sp, #20] <== NOT EXECUTED
1dd48: eb00dc2a bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
1dd4c: e59dc014 ldr ip, [sp, #20] <== NOT EXECUTED
1dd50: e1a00080 lsl r0, r0, #1 <== NOT EXECUTED
1dd54: e2400001 sub r0, r0, #1 <== NOT EXECUTED
1dd58: e1a0100c mov r1, ip <== NOT EXECUTED
1dd5c: eb00dc25 bl 54df8 <__aeabi_uidiv> <== 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;
1dd60: e59d2010 ldr r2, [sp, #16] <== 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;
1dd64: e2800001 add r0, r0, #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;
1dd68: e0602002 rsb r2, r0, r2 <== NOT EXECUTED
dc->descriptor = &c->devices[device];
1dd6c: e586b010 str fp, [r6, #16] <== 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]);
1dd70: e5860008 str r0, [r6, #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++)
1dd74: e59d300c ldr r3, [sp, #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]);
dc->block_base = blocks;
1dd78: e586a00c str sl, [r6, #12] <== 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++)
1dd7c: e2899001 add r9, r9, #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;
1dd80: e08aa002 add sl, sl, r2 <== 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++)
1dd84: e2888014 add r8, r8, #20 <== NOT EXECUTED
1dd88: e5152008 ldr r2, [r5, #-8] <== NOT EXECUTED
1dd8c: e1590002 cmp r9, r2 <== NOT EXECUTED
1dd90: 3affffdc bcc 1dd08 <rtems_nvdisk_initialize+0xe8> <== NOT EXECUTED
blocks += dc->pages - dc->pages_desc;
dc->descriptor = &c->devices[device];
}
nvd->block_count = blocks;
1dd94: e584a010 str sl, [r4, #16] <== NOT EXECUTED
1dd98: e1a06003 mov r6, r3 <== NOT EXECUTED
nvd->device_count = c->device_count;
1dd9c: e5153008 ldr r3, [r5, #-8] <== NOT EXECUTED
sc = rtems_disk_create_phys(dev, c->block_size, blocks,
1dda0: e59fc0b4 ldr ip, [pc, #180] ; 1de5c <rtems_nvdisk_initialize+0x23c><== NOT EXECUTED
dc->descriptor = &c->devices[device];
}
nvd->block_count = blocks;
nvd->device_count = c->device_count;
1dda4: e5843018 str r3, [r4, #24] <== NOT EXECUTED
sc = rtems_disk_create_phys(dev, c->block_size, blocks,
1dda8: e58dc000 str ip, [sp] <== NOT EXECUTED
1ddac: e3a0c000 mov ip, #0 <== NOT EXECUTED
1ddb0: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
1ddb4: e28d101c add r1, sp, #28 <== NOT EXECUTED
1ddb8: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
1ddbc: e28dc024 add ip, sp, #36 ; 0x24 <== NOT EXECUTED
1ddc0: e1a0300a mov r3, sl <== NOT EXECUTED
1ddc4: e515200c ldr r2, [r5, #-12] <== NOT EXECUTED
1ddc8: e58dc008 str ip, [sp, #8] <== NOT EXECUTED
1ddcc: ebffa268 bl 6774 <rtems_disk_create_phys> <== NOT EXECUTED
rtems_nvdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
1ddd0: e2508000 subs r8, r0, #0 <== NOT EXECUTED
{
rtems_nvdisk_error ("disk create phy failed");
1ddd4: 159f0084 ldrne r0, [pc, #132] ; 1de60 <rtems_nvdisk_initialize+0x240><== NOT EXECUTED
1ddd8: 1a00000b bne 1de0c <rtems_nvdisk_initialize+0x1ec> <== NOT EXECUTED
return sc;
}
sc = rtems_semaphore_create (rtems_build_name ('N', 'V', 'D', 'K'), 1,
1dddc: e2844020 add r4, r4, #32 <== NOT EXECUTED
1dde0: e59f007c ldr r0, [pc, #124] ; 1de64 <rtems_nvdisk_initialize+0x244><== NOT EXECUTED
1dde4: e3a01001 mov r1, #1 <== NOT EXECUTED
1dde8: e3a02054 mov r2, #84 ; 0x54 <== NOT EXECUTED
1ddec: e3a03000 mov r3, #0 <== NOT EXECUTED
1ddf0: e58d4000 str r4, [sp] <== NOT EXECUTED
1ddf4: ebffb608 bl b61c <rtems_semaphore_create> <== NOT EXECUTED
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &nvd->lock);
if (sc != RTEMS_SUCCESSFUL)
1ddf8: e2508000 subs r8, r0, #0 <== NOT EXECUTED
{
rtems_nvdisk_error ("disk create phy failed");
return sc;
}
sc = rtems_semaphore_create (rtems_build_name ('N', 'V', 'D', 'K'), 1,
1ddfc: e2866028 add r6, r6, #40 ; 0x28 <== NOT EXECUTED
1de00: e2855014 add r5, r5, #20 <== NOT EXECUTED
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &nvd->lock);
if (sc != RTEMS_SUCCESSFUL)
1de04: 0a000002 beq 1de14 <rtems_nvdisk_initialize+0x1f4> <== NOT EXECUTED
{
rtems_nvdisk_error ("disk lock create failed");
1de08: e59f0058 ldr r0, [pc, #88] ; 1de68 <rtems_nvdisk_initialize+0x248><== NOT EXECUTED
1de0c: ebfffdcb bl 1d540 <rtems_nvdisk_error> <== NOT EXECUTED
return sc;
1de10: ea000009 b 1de3c <rtems_nvdisk_initialize+0x21c> <== NOT EXECUTED
sizeof (rtems_nvdisk));
if (!rtems_nvdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)
1de14: e2877001 add r7, r7, #1 <== NOT EXECUTED
1de18: e59f102c ldr r1, [pc, #44] ; 1de4c <rtems_nvdisk_initialize+0x22c><== NOT EXECUTED
1de1c: e5913000 ldr r3, [r1] <== NOT EXECUTED
1de20: e1570003 cmp r7, r3 <== NOT EXECUTED
1de24: 3affff93 bcc 1dc78 <rtems_nvdisk_initialize+0x58> <== NOT EXECUTED
rtems_nvdisk_error ("disk lock create failed");
return sc;
}
}
rtems_nvdisk_count = rtems_nvdisk_configuration_size;
1de28: e59f2020 ldr r2, [pc, #32] ; 1de50 <rtems_nvdisk_initialize+0x230><== NOT EXECUTED
1de2c: e3a08000 mov r8, #0 <== NOT EXECUTED
1de30: e5823000 str r3, [r2] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
1de34: ea000000 b 1de3c <rtems_nvdisk_initialize+0x21c> <== NOT EXECUTED
1de38: e3a0801a mov r8, #26 <== NOT EXECUTED
}
1de3c: e1a00008 mov r0, r8 <== NOT EXECUTED
1de40: e28dd038 add sp, sp, #56 ; 0x38 <== NOT EXECUTED
1de44: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0001d63c <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)
{
1d63c: 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)
1d640: e59f6550 ldr r6, [pc, #1360] ; 1db98 <rtems_nvdisk_ioctl+0x55c><== NOT EXECUTED
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
1d644: 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)
{
1d648: e1a07000 mov r7, 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)
1d64c: e5960000 ldr r0, [r6] <== NOT EXECUTED
1d650: e1530000 cmp r3, r0 <== 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)
{
1d654: e24dd01c sub sp, sp, #28 <== NOT EXECUTED
1d658: e1a05001 mov r5, r1 <== NOT EXECUTED
1d65c: e1a04002 mov r4, r2 <== 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)
1d660: 2a000006 bcs 1d680 <rtems_nvdisk_ioctl+0x44> <== NOT EXECUTED
{
errno = ENODEV;
return -1;
}
if (rtems_nvdisks[minor].device_count == 0)
1d664: e3a02028 mov r2, #40 ; 0x28 <== NOT EXECUTED
1d668: e0090392 mul r9, r2, r3 <== NOT EXECUTED
1d66c: e5963004 ldr r3, [r6, #4] <== NOT EXECUTED
1d670: e0833009 add r3, r3, r9 <== NOT EXECUTED
1d674: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED
1d678: e3530000 cmp r3, #0 <== NOT EXECUTED
1d67c: 1a000004 bne 1d694 <rtems_nvdisk_ioctl+0x58> <== NOT EXECUTED
{
errno = ENODEV;
1d680: eb007e1e bl 3cf00 <__errno> <== NOT EXECUTED
1d684: e3a03013 mov r3, #19 <== NOT EXECUTED
1d688: e5803000 str r3, [r0] <== NOT EXECUTED
1d68c: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
1d690: ea00013a b 1db80 <rtems_nvdisk_ioctl+0x544> <== NOT EXECUTED
}
errno = 0;
1d694: eb007e19 bl 3cf00 <__errno> <== NOT EXECUTED
sc = rtems_semaphore_obtain (rtems_nvdisks[minor].lock, RTEMS_WAIT, 0);
1d698: e5962004 ldr r2, [r6, #4] <== NOT EXECUTED
{
errno = ENODEV;
return -1;
}
errno = 0;
1d69c: e3a03000 mov r3, #0 <== NOT EXECUTED
sc = rtems_semaphore_obtain (rtems_nvdisks[minor].lock, RTEMS_WAIT, 0);
1d6a0: e0822009 add r2, r2, r9 <== NOT EXECUTED
{
errno = ENODEV;
return -1;
}
errno = 0;
1d6a4: e5803000 str r3, [r0] <== NOT EXECUTED
sc = rtems_semaphore_obtain (rtems_nvdisks[minor].lock, RTEMS_WAIT, 0);
1d6a8: e1a01003 mov r1, r3 <== NOT EXECUTED
1d6ac: e5920020 ldr r0, [r2, #32] <== NOT EXECUTED
1d6b0: e1a02003 mov r2, r3 <== NOT EXECUTED
1d6b4: ebffb881 bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
1d6b8: e2508000 subs r8, r0, #0 <== NOT EXECUTED
1d6bc: 1a000128 bne 1db64 <rtems_nvdisk_ioctl+0x528> <== NOT EXECUTED
errno = EIO;
else
{
errno = 0;
1d6c0: eb007e0e bl 3cf00 <__errno> <== NOT EXECUTED
switch (req)
1d6c4: e59f34d0 ldr r3, [pc, #1232] ; 1db9c <rtems_nvdisk_ioctl+0x560><== NOT EXECUTED
1d6c8: e1550003 cmp r5, r3 <== NOT EXECUTED
case RTEMS_NVDISK_IOCTL_ERASE_DISK:
errno = rtems_nvdisk_erase_disk (&rtems_nvdisks[minor]);
break;
case RTEMS_NVDISK_IOCTL_INFO_LEVEL:
rtems_nvdisks[minor].info_level = (uintptr_t) argp;
1d6cc: 05963004 ldreq r3, [r6, #4] <== NOT EXECUTED
1d6d0: 00833009 addeq r3, r3, r9 <== NOT EXECUTED
sc = rtems_semaphore_obtain (rtems_nvdisks[minor].lock, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
errno = EIO;
else
{
errno = 0;
1d6d4: e5808000 str r8, [r0] <== NOT EXECUTED
case RTEMS_NVDISK_IOCTL_ERASE_DISK:
errno = rtems_nvdisk_erase_disk (&rtems_nvdisks[minor]);
break;
case RTEMS_NVDISK_IOCTL_INFO_LEVEL:
rtems_nvdisks[minor].info_level = (uintptr_t) argp;
1d6d8: 05834024 streq r4, [r3, #36] ; 0x24 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
errno = EIO;
else
{
errno = 0;
switch (req)
1d6dc: 0a000119 beq 1db48 <rtems_nvdisk_ioctl+0x50c> <== NOT EXECUTED
1d6e0: e59f34b8 ldr r3, [pc, #1208] ; 1dba0 <rtems_nvdisk_ioctl+0x564><== NOT EXECUTED
1d6e4: e1550003 cmp r5, r3 <== NOT EXECUTED
1d6e8: 0a000003 beq 1d6fc <rtems_nvdisk_ioctl+0xc0> <== NOT EXECUTED
1d6ec: e59f34b0 ldr r3, [pc, #1200] ; 1dba4 <rtems_nvdisk_ioctl+0x568><== NOT EXECUTED
1d6f0: e1550003 cmp r5, r3 <== NOT EXECUTED
1d6f4: 1a00010f bne 1db38 <rtems_nvdisk_ioctl+0x4fc> <== NOT EXECUTED
1d6f8: ea0000e3 b 1da8c <rtems_nvdisk_ioctl+0x450> <== NOT EXECUTED
{
case RTEMS_BLKIO_REQUEST:
switch (r->req)
1d6fc: e5947000 ldr r7, [r4] <== NOT EXECUTED
1d700: e3570000 cmp r7, #0 <== NOT EXECUTED
1d704: 0a000002 beq 1d714 <rtems_nvdisk_ioctl+0xd8> <== NOT EXECUTED
1d708: e3570001 cmp r7, #1 <== NOT EXECUTED
1d70c: 1a0000da bne 1da7c <rtems_nvdisk_ioctl+0x440> <== NOT EXECUTED
1d710: ea000070 b 1d8d8 <rtems_nvdisk_ioctl+0x29c> <== NOT EXECUTED
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);
1d714: eb007df9 bl 3cf00 <__errno> <== NOT EXECUTED
1d718: e5965004 ldr r5, [r6, #4] <== NOT EXECUTED
1d71c: e58d0014 str r0, [sp, #20] <== NOT EXECUTED
* @retval int The ioctl return value.
*/
static int
rtems_nvdisk_read (rtems_nvdisk* nvd, rtems_blkdev_request* req)
{
rtems_blkdev_sg_buffer* sg = req->bufs;
1d720: e58d700c str r7, [sp, #12] <== NOT EXECUTED
{
case RTEMS_BLKIO_REQUEST:
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);
1d724: e0855009 add r5, r5, r9 <== NOT EXECUTED
* @retval int The ioctl return value.
*/
static int
rtems_nvdisk_read (rtems_nvdisk* nvd, rtems_blkdev_request* req)
{
rtems_blkdev_sg_buffer* sg = req->bufs;
1d728: e2846018 add r6, r4, #24 <== NOT EXECUTED
1d72c: ea00005c b 1d8a4 <rtems_nvdisk_ioctl+0x268> <== NOT EXECUTED
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
1d730: e5960004 ldr r0, [r6, #4] <== NOT EXECUTED
1d734: e595100c ldr r1, [r5, #12] <== NOT EXECUTED
1d738: eb00ddae bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
data = sg->buffer;
1d73c: e3a0a000 mov sl, #0 <== NOT EXECUTED
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
1d740: e58d0010 str r0, [sp, #16] <== NOT EXECUTED
data = sg->buffer;
1d744: e5967008 ldr r7, [r6, #8] <== NOT EXECUTED
1d748: e1a08004 mov r8, r4 <== NOT EXECUTED
1d74c: ea00004c b 1d884 <rtems_nvdisk_ioctl+0x248> <== NOT EXECUTED
for (b = 0; b < nvb; b++, data += nvd->block_size)
{
ret = rtems_nvdisk_read_block (nvd, sg->block + b, data);
1d750: e5963000 ldr r3, [r6] <== NOT EXECUTED
1d754: e08a3003 add r3, sl, r3 <== NOT EXECUTED
uint32_t page;
uint16_t crc;
uint16_t cs;
int ret;
dc = rtems_nvdisk_get_device (nvd, block);
1d758: e1a00005 mov r0, r5 <== NOT EXECUTED
1d75c: e1a01003 mov r1, r3 <== NOT EXECUTED
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
{
ret = rtems_nvdisk_read_block (nvd, sg->block + b, data);
1d760: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
uint32_t page;
uint16_t crc;
uint16_t cs;
int ret;
dc = rtems_nvdisk_get_device (nvd, block);
1d764: ebffff91 bl 1d5b0 <rtems_nvdisk_get_device> <== NOT EXECUTED
if (!dc)
1d768: e2504000 subs r4, r0, #0 <== NOT EXECUTED
1d76c: 01a04008 moveq r4, r8 <== NOT EXECUTED
1d770: 0a00003d beq 1d86c <rtems_nvdisk_ioctl+0x230> <== 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;
1d774: e5952014 ldr r2, [r5, #20] <== 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);
1d778: 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;
1d77c: e3a03014 mov r3, #20 <== NOT EXECUTED
1d780: e0232390 mla r3, r0, r3, r2 <== NOT EXECUTED
1d784: 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;
1d788: e594b00c ldr fp, [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);
1d78c: e28d101a add r1, sp, #26 <== NOT EXECUTED
1d790: e3a02002 mov r2, #2 <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,
uint32_t block)
{
return block - dc->block_base;
1d794: e59de008 ldr lr, [sp, #8] <== 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);
1d798: e593c00c ldr ip, [r3, #12] <== NOT EXECUTED
1d79c: e88d0006 stm sp, {r1, r2} <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,
uint32_t block)
{
return block - dc->block_base;
1d7a0: e06bb00e rsb fp, fp, lr <== 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);
1d7a4: e8930006 ldm r3, {r1, r2} <== NOT EXECUTED
1d7a8: e1a0308b lsl r3, fp, #1 <== NOT EXECUTED
1d7ac: e1a0e00f mov lr, pc <== NOT EXECUTED
1d7b0: e59cf000 ldr pc, [ip] <== NOT EXECUTED
block, dc->device, page, crc);
#endif
ret = rtems_nvdisk_read_checksum (nvd, dc->device, page, &crc);
if (ret)
1d7b4: e2501000 subs r1, r0, #0 <== NOT EXECUTED
1d7b8: 1a00002d bne 1d874 <rtems_nvdisk_ioctl+0x238> <== NOT EXECUTED
return ret;
if (crc == 0xffff)
1d7bc: e59f23e4 ldr r2, [pc, #996] ; 1dba8 <rtems_nvdisk_ioctl+0x56c><== NOT EXECUTED
1d7c0: e1dd31ba ldrh r3, [sp, #26] <== NOT EXECUTED
1d7c4: e1530002 cmp r3, r2 <== NOT EXECUTED
1d7c8: e595200c ldr r2, [r5, #12] <== NOT EXECUTED
1d7cc: 1a000002 bne 1d7dc <rtems_nvdisk_ioctl+0x1a0> <== NOT EXECUTED
{
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_warning (nvd, "read-block: crc not set: %d", block);
#endif
memset (buffer, 0, nvd->block_size);
1d7d0: e1a00007 mov r0, r7 <== NOT EXECUTED
1d7d4: eb008b00 bl 403dc <memset> <== NOT EXECUTED
1d7d8: ea0000ea b 1db88 <rtems_nvdisk_ioctl+0x54c> <== 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;
1d7dc: e5951014 ldr r1, [r5, #20] <== NOT EXECUTED
#endif
memset (buffer, 0, nvd->block_size);
return 0;
}
ret = rtems_nvdisk_read_page (nvd, dc->device, page + dc->pages_desc, buffer);
1d7e0: 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;
1d7e4: e3a03014 mov r3, #20 <== NOT EXECUTED
1d7e8: e0231390 mla r3, r0, r3, r1 <== NOT EXECUTED
1d7ec: e5931010 ldr r1, [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);
1d7f0: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
1d7f4: e591c00c ldr ip, [r1, #12] <== NOT EXECUTED
1d7f8: e58d7000 str r7, [sp] <== NOT EXECUTED
1d7fc: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
1d800: e08b3003 add r3, fp, r3 <== NOT EXECUTED
1d804: e0030392 mul r3, r2, r3 <== NOT EXECUTED
1d808: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
1d80c: e1a0e00f mov lr, pc <== NOT EXECUTED
1d810: e59cf000 ldr pc, [ip] <== NOT EXECUTED
return 0;
}
ret = rtems_nvdisk_read_page (nvd, dc->device, page + dc->pages_desc, buffer);
if (ret)
1d814: e2501000 subs r1, r0, #0 <== NOT EXECUTED
1d818: 1a000015 bne 1d874 <rtems_nvdisk_ioctl+0x238> <== NOT EXECUTED
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
1d81c: e59fe374 ldr lr, [pc, #884] ; 1db98 <rtems_nvdisk_ioctl+0x55c><== NOT EXECUTED
ret = rtems_nvdisk_read_page (nvd, dc->device, page + dc->pages_desc, buffer);
if (ret)
return ret;
cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);
1d820: e595000c ldr r0, [r5, #12] <== NOT EXECUTED
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
1d824: e59e3008 ldr r3, [lr, #8] <== NOT EXECUTED
1d828: e59f2378 ldr r2, [pc, #888] ; 1dba8 <rtems_nvdisk_ioctl+0x56c><== NOT EXECUTED
1d82c: ea000005 b 1d848 <rtems_nvdisk_ioctl+0x20c> <== NOT EXECUTED
1d830: e7d7c001 ldrb ip, [r7, r1] <== NOT EXECUTED
1d834: e022200c eor r2, r2, ip <== NOT EXECUTED
1d838: e20220ff and r2, r2, #255 ; 0xff <== NOT EXECUTED
1d83c: e1a02082 lsl r2, r2, #1 <== NOT EXECUTED
1d840: 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++)
1d844: e2811001 add r1, r1, #1 <== NOT EXECUTED
1d848: e1510000 cmp r1, r0 <== NOT EXECUTED
1d84c: 3afffff7 bcc 1d830 <rtems_nvdisk_ioctl+0x1f4> <== NOT EXECUTED
if (ret)
return ret;
cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);
if (cs != crc)
1d850: e1dd31ba ldrh r3, [sp, #26] <== NOT EXECUTED
1d854: e1520003 cmp r2, r3 <== NOT EXECUTED
1d858: 0a0000ca beq 1db88 <rtems_nvdisk_ioctl+0x54c> <== NOT EXECUTED
{
rtems_nvdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
1d85c: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED
1d860: e59f0344 ldr r0, [pc, #836] ; 1dbac <rtems_nvdisk_ioctl+0x570><== NOT EXECUTED
1d864: e1a04008 mov r4, r8 <== NOT EXECUTED
1d868: ebffff34 bl 1d540 <rtems_nvdisk_error> <== NOT EXECUTED
1d86c: e3a0b005 mov fp, #5 <== NOT EXECUTED
1d870: ea000001 b 1d87c <rtems_nvdisk_ioctl+0x240> <== NOT EXECUTED
1d874: e1a0b001 mov fp, r1 <== NOT EXECUTED
1d878: e1a04008 mov r4, r8 <== NOT EXECUTED
1d87c: e3a0101b mov r1, #27 <== NOT EXECUTED
1d880: ea00000d b 1d8bc <rtems_nvdisk_ioctl+0x280> <== 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)
1d884: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
1d888: e15a0001 cmp sl, r1 <== NOT EXECUTED
1d88c: 3affffaf bcc 1d750 <rtems_nvdisk_ioctl+0x114> <== 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++)
1d890: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
1d894: e2833001 add r3, r3, #1 <== NOT EXECUTED
1d898: e58d300c str r3, [sp, #12] <== NOT EXECUTED
1d89c: e1a04008 mov r4, r8 <== NOT EXECUTED
1d8a0: e2866010 add r6, r6, #16 <== NOT EXECUTED
1d8a4: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
1d8a8: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
1d8ac: e1520003 cmp r2, r3 <== NOT EXECUTED
1d8b0: 3affff9e bcc 1d730 <rtems_nvdisk_ioctl+0xf4> <== NOT EXECUTED
1d8b4: e3a0b000 mov fp, #0 <== NOT EXECUTED
1d8b8: e1a0100b mov r1, fp <== NOT EXECUTED
if (ret)
break;
}
}
req->status = ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL;
1d8bc: e584100c str r1, [r4, #12] <== NOT EXECUTED
req->req_done (req->done_arg, req->status);
1d8c0: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
1d8c4: e1a0e00f mov lr, pc <== NOT EXECUTED
1d8c8: e594f004 ldr pc, [r4, #4] <== NOT EXECUTED
{
case RTEMS_BLKIO_REQUEST:
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);
1d8cc: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED
1d8d0: e583b000 str fp, [r3] <== NOT EXECUTED
break;
1d8d4: ea00009b b 1db48 <rtems_nvdisk_ioctl+0x50c> <== NOT EXECUTED
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_nvdisk_write (&rtems_nvdisks[minor], r);
1d8d8: eb007d88 bl 3cf00 <__errno> <== NOT EXECUTED
1d8dc: e5965004 ldr r5, [r6, #4] <== NOT EXECUTED
1d8e0: e58d0014 str r0, [sp, #20] <== NOT EXECUTED
* @retval int The ioctl return value.
*/
static int
rtems_nvdisk_write (rtems_nvdisk* nvd, rtems_blkdev_request* req)
{
rtems_blkdev_sg_buffer* sg = req->bufs;
1d8e4: e58d8008 str r8, [sp, #8] <== 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);
1d8e8: e0855009 add r5, r5, r9 <== NOT EXECUTED
* @retval int The ioctl return value.
*/
static int
rtems_nvdisk_write (rtems_nvdisk* nvd, rtems_blkdev_request* req)
{
rtems_blkdev_sg_buffer* sg = req->bufs;
1d8ec: e2846018 add r6, r4, #24 <== NOT EXECUTED
1d8f0: e1a0b009 mov fp, r9 <== NOT EXECUTED
1d8f4: ea000052 b 1da44 <rtems_nvdisk_ioctl+0x408> <== NOT EXECUTED
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
1d8f8: e5960004 ldr r0, [r6, #4] <== NOT EXECUTED
1d8fc: e595100c ldr r1, [r5, #12] <== NOT EXECUTED
1d900: eb00dd3c bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
data = sg->buffer;
1d904: e3a0a000 mov sl, #0 <== NOT EXECUTED
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
1d908: e58d0010 str r0, [sp, #16] <== NOT EXECUTED
data = sg->buffer;
1d90c: e5968008 ldr r8, [r6, #8] <== NOT EXECUTED
1d910: e1a09004 mov r9, r4 <== NOT EXECUTED
1d914: ea00003d b 1da10 <rtems_nvdisk_ioctl+0x3d4> <== NOT EXECUTED
for (b = 0; b < nvb; b++, data += nvd->block_size)
{
ret = rtems_nvdisk_write_block (nvd, sg->block + b, data);
1d918: e5967000 ldr r7, [r6] <== NOT EXECUTED
1d91c: e08a7007 add r7, sl, r7 <== NOT EXECUTED
rtems_nvdisk_device_ctl* dc;
uint32_t page;
uint16_t cs;
int ret;
dc = rtems_nvdisk_get_device (nvd, block);
1d920: e1a00005 mov r0, r5 <== NOT EXECUTED
1d924: e1a01007 mov r1, r7 <== NOT EXECUTED
1d928: ebffff20 bl 1d5b0 <rtems_nvdisk_get_device> <== NOT EXECUTED
if (!dc)
1d92c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
1d930: 0a00003f beq 1da34 <rtems_nvdisk_ioctl+0x3f8> <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,
uint32_t block)
{
return block - dc->block_base;
1d934: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
1d938: e59fe258 ldr lr, [pc, #600] ; 1db98 <rtems_nvdisk_ioctl+0x55c><== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,
uint32_t block)
{
return block - dc->block_base;
1d93c: e0633007 rsb r3, r3, r7 <== NOT EXECUTED
1d940: e58d300c str r3, [sp, #12] <== NOT EXECUTED
if (!dc)
return EIO;
page = rtems_nvdisk_get_page (dc, block);
cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);
1d944: e595200c ldr r2, [r5, #12] <== NOT EXECUTED
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
1d948: e59e1008 ldr r1, [lr, #8] <== NOT EXECUTED
1d94c: e3a03000 mov r3, #0 <== NOT EXECUTED
1d950: e59f7250 ldr r7, [pc, #592] ; 1dba8 <rtems_nvdisk_ioctl+0x56c><== NOT EXECUTED
1d954: ea000005 b 1d970 <rtems_nvdisk_ioctl+0x334> <== NOT EXECUTED
1d958: e7d80003 ldrb r0, [r8, r3] <== NOT EXECUTED
1d95c: e0270000 eor r0, r7, r0 <== NOT EXECUTED
1d960: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED
1d964: e1a00080 lsl r0, r0, #1 <== NOT EXECUTED
1d968: e19170b0 ldrh r7, [r1, r0] <== 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++)
1d96c: e2833001 add r3, r3, #1 <== NOT EXECUTED
1d970: e1530002 cmp r3, r2 <== NOT EXECUTED
1d974: 3afffff7 bcc 1d958 <rtems_nvdisk_ioctl+0x31c> <== 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;
1d978: e5951014 ldr r1, [r5, #20] <== 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);
1d97c: 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;
1d980: e3a03014 mov r3, #20 <== NOT EXECUTED
1d984: e0231390 mla r3, r0, r3, r1 <== NOT EXECUTED
1d988: e5931010 ldr r1, [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);
1d98c: e59de00c ldr lr, [sp, #12] <== NOT EXECUTED
1d990: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
1d994: e591c00c ldr ip, [r1, #12] <== NOT EXECUTED
1d998: e58d8000 str r8, [sp] <== NOT EXECUTED
1d99c: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
1d9a0: e08e3003 add r3, lr, r3 <== NOT EXECUTED
1d9a4: e0030392 mul r3, r2, r3 <== NOT EXECUTED
1d9a8: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
1d9ac: e1a0e00f mov lr, pc <== NOT EXECUTED
1d9b0: 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)
1d9b4: e3500000 cmp r0, #0 <== NOT EXECUTED
1d9b8: 1a00001d bne 1da34 <rtems_nvdisk_ioctl+0x3f8> <== 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;
1d9bc: e5952014 ldr r2, [r5, #20] <== 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);
1d9c0: 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;
1d9c4: e3a03014 mov r3, #20 <== NOT EXECUTED
1d9c8: e0232390 mla r3, r0, r3, r2 <== NOT EXECUTED
1d9cc: e5931010 ldr r1, [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);
1d9d0: e28d201a add r2, sp, #26 <== NOT EXECUTED
1d9d4: e3a03002 mov r3, #2 <== NOT EXECUTED
1d9d8: e591c00c ldr ip, [r1, #12] <== NOT EXECUTED
1d9dc: e59de00c ldr lr, [sp, #12] <== NOT EXECUTED
1d9e0: e88d000c stm sp, {r2, r3} <== 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);
1d9e4: e1cd71ba strh r7, [sp, #26] <== 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);
1d9e8: e5912004 ldr r2, [r1, #4] <== NOT EXECUTED
1d9ec: e1a0308e lsl r3, lr, #1 <== NOT EXECUTED
1d9f0: e5911000 ldr r1, [r1] <== NOT EXECUTED
1d9f4: e1a0e00f mov lr, pc <== NOT EXECUTED
1d9f8: 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)
1d9fc: e3500000 cmp r0, #0 <== NOT EXECUTED
1da00: 1a00000b bne 1da34 <rtems_nvdisk_ioctl+0x3f8> <== 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)
1da04: e595300c ldr r3, [r5, #12] <== NOT EXECUTED
1da08: e28aa001 add sl, sl, #1 <== NOT EXECUTED
1da0c: e0888003 add r8, r8, r3 <== NOT EXECUTED
1da10: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
1da14: e15a0001 cmp sl, r1 <== NOT EXECUTED
1da18: 3affffbe bcc 1d918 <rtems_nvdisk_ioctl+0x2dc> <== 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++)
1da1c: e59de008 ldr lr, [sp, #8] <== NOT EXECUTED
1da20: e28ee001 add lr, lr, #1 <== NOT EXECUTED
1da24: e1a04009 mov r4, r9 <== NOT EXECUTED
1da28: e58de008 str lr, [sp, #8] <== NOT EXECUTED
1da2c: e2866010 add r6, r6, #16 <== NOT EXECUTED
1da30: ea000003 b 1da44 <rtems_nvdisk_ioctl+0x408> <== NOT EXECUTED
1da34: e1a04009 mov r4, r9 <== 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)
1da38: e3a0101b mov r1, #27 <== NOT EXECUTED
1da3c: e1a0900b mov r9, fp <== NOT EXECUTED
1da40: ea000005 b 1da5c <rtems_nvdisk_ioctl+0x420> <== 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++)
1da44: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
1da48: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED
1da4c: e1520003 cmp r2, r3 <== NOT EXECUTED
1da50: 3affffa8 bcc 1d8f8 <rtems_nvdisk_ioctl+0x2bc> <== NOT EXECUTED
1da54: e1a0900b mov r9, fp <== NOT EXECUTED
1da58: e3a01000 mov r1, #0 <== NOT EXECUTED
if (ret)
break;
}
}
req->status = ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL;
1da5c: e584100c str r1, [r4, #12] <== NOT EXECUTED
req->req_done (req->done_arg, req->status);
1da60: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
1da64: e1a0e00f mov lr, pc <== NOT EXECUTED
1da68: e594f004 ldr pc, [r4, #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);
1da6c: e59de014 ldr lr, [sp, #20] <== NOT EXECUTED
1da70: e3a03000 mov r3, #0 <== NOT EXECUTED
1da74: e58e3000 str r3, [lr] <== NOT EXECUTED
break;
1da78: ea000032 b 1db48 <rtems_nvdisk_ioctl+0x50c> <== NOT EXECUTED
default:
errno = EINVAL;
1da7c: eb007d1f bl 3cf00 <__errno> <== NOT EXECUTED
1da80: e3a03016 mov r3, #22 <== NOT EXECUTED
1da84: e5803000 str r3, [r0] <== NOT EXECUTED
1da88: ea00002e b 1db48 <rtems_nvdisk_ioctl+0x50c> <== NOT EXECUTED
break;
}
break;
case RTEMS_NVDISK_IOCTL_ERASE_DISK:
errno = rtems_nvdisk_erase_disk (&rtems_nvdisks[minor]);
1da8c: eb007d1b bl 3cf00 <__errno> <== NOT EXECUTED
1da90: e5966004 ldr r6, [r6, #4] <== NOT EXECUTED
1da94: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
1da98: e1a04008 mov r4, r8 <== NOT EXECUTED
1da9c: e0866009 add r6, r6, r9 <== 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;
1daa0: e3a0a014 mov sl, #20 <== 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);
1daa4: e28db01a add fp, sp, #26 <== NOT EXECUTED
1daa8: ea00001b b 1db1c <rtems_nvdisk_ioctl+0x4e0> <== 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];
1daac: e5967014 ldr r7, [r6, #20] <== NOT EXECUTED
1dab0: e3a05000 mov r5, #0 <== NOT EXECUTED
1dab4: e0877004 add r7, r7, r4 <== NOT EXECUTED
1dab8: ea000010 b 1db00 <rtems_nvdisk_ioctl+0x4c4> <== 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;
1dabc: e5961014 ldr r1, [r6, #20] <== 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);
1dac0: e5970000 ldr r0, [r7] <== 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;
1dac4: e022109a mla r2, sl, r0, r1 <== NOT EXECUTED
1dac8: e5921010 ldr r1, [r2, #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);
1dacc: e3a02002 mov r2, #2 <== NOT EXECUTED
1dad0: e591c00c ldr ip, [r1, #12] <== NOT EXECUTED
1dad4: e58db000 str fp, [sp] <== NOT EXECUTED
1dad8: e58d2004 str r2, [sp, #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);
1dadc: 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);
1dae0: e5912004 ldr r2, [r1, #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);
1dae4: e1cde1ba strh lr, [sp, #26] <== 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);
1dae8: e5911000 ldr r1, [r1] <== NOT EXECUTED
1daec: e1a0e00f mov lr, pc <== NOT EXECUTED
1daf0: 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)
1daf4: e3500000 cmp r0, #0 <== NOT EXECUTED
1daf8: 1a00000b bne 1db2c <rtems_nvdisk_ioctl+0x4f0> <== 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++)
1dafc: e2855001 add r5, r5, #1 <== NOT EXECUTED
1db00: e9970006 ldmib r7, {r1, r2} <== NOT EXECUTED
1db04: e0412002 sub r2, r1, r2 <== NOT EXECUTED
1db08: e1550002 cmp r5, r2 <== 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);
1db0c: e1a03085 lsl r3, r5, #1 <== 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++)
1db10: 3affffe9 bcc 1dabc <rtems_nvdisk_ioctl+0x480> <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "erase-disk");
#endif
for (device = 0; device < nvd->device_count; device++)
1db14: e2888001 add r8, r8, #1 <== NOT EXECUTED
1db18: e2844014 add r4, r4, #20 <== NOT EXECUTED
1db1c: e5963018 ldr r3, [r6, #24] <== NOT EXECUTED
1db20: e1580003 cmp r8, r3 <== NOT EXECUTED
1db24: 3affffe0 bcc 1daac <rtems_nvdisk_ioctl+0x470> <== NOT EXECUTED
1db28: e3a00000 mov r0, #0 <== NOT EXECUTED
break;
}
break;
case RTEMS_NVDISK_IOCTL_ERASE_DISK:
errno = rtems_nvdisk_erase_disk (&rtems_nvdisks[minor]);
1db2c: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED
1db30: e5820000 str r0, [r2] <== NOT EXECUTED
break;
1db34: ea000003 b 1db48 <rtems_nvdisk_ioctl+0x50c> <== NOT EXECUTED
case RTEMS_NVDISK_IOCTL_INFO_LEVEL:
rtems_nvdisks[minor].info_level = (uintptr_t) argp;
break;
default:
rtems_blkdev_ioctl (dd, req, argp);
1db38: e1a00007 mov r0, r7 <== NOT EXECUTED
1db3c: e1a01005 mov r1, r5 <== NOT EXECUTED
1db40: e1a02004 mov r2, r4 <== NOT EXECUTED
1db44: ebff9f1d bl 57c0 <rtems_blkdev_ioctl> <== NOT EXECUTED
break;
}
sc = rtems_semaphore_release (rtems_nvdisks[minor].lock);
1db48: e59f3048 ldr r3, [pc, #72] ; 1db98 <rtems_nvdisk_ioctl+0x55c><== NOT EXECUTED
1db4c: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
1db50: e0839009 add r9, r3, r9 <== NOT EXECUTED
1db54: e5990020 ldr r0, [r9, #32] <== NOT EXECUTED
1db58: ebffb79e bl b9d8 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
1db5c: e3500000 cmp r0, #0 <== NOT EXECUTED
1db60: 0a000002 beq 1db70 <rtems_nvdisk_ioctl+0x534> <== NOT EXECUTED
errno = EIO;
1db64: eb007ce5 bl 3cf00 <__errno> <== NOT EXECUTED
1db68: e3a03005 mov r3, #5 <== NOT EXECUTED
1db6c: e5803000 str r3, [r0] <== NOT EXECUTED
}
return errno == 0 ? 0 : -1;
1db70: eb007ce2 bl 3cf00 <__errno> <== NOT EXECUTED
1db74: e5900000 ldr r0, [r0] <== NOT EXECUTED
1db78: e3500000 cmp r0, #0 <== NOT EXECUTED
1db7c: 13e00000 mvnne r0, #0 <== NOT EXECUTED
}
1db80: e28dd01c add sp, sp, #28 <== NOT EXECUTED
1db84: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== 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)
1db88: e595300c ldr r3, [r5, #12] <== NOT EXECUTED
1db8c: e28aa001 add sl, sl, #1 <== NOT EXECUTED
1db90: e0877003 add r7, r7, r3 <== NOT EXECUTED
1db94: eaffff3a b 1d884 <rtems_nvdisk_ioctl+0x248> <== NOT EXECUTED
0001dea4 <rtems_nvdisk_sram_read>:
uint32_t flags __attribute__((unused)),
void* base,
uint32_t offset,
void* buffer,
size_t size)
{
1dea4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
memcpy (buffer, (base + offset), size);
1dea8: e0821003 add r1, r2, r3 <== NOT EXECUTED
1deac: e99d0005 ldmib sp, {r0, r2} <== NOT EXECUTED
1deb0: eb0088c2 bl 401c0 <memcpy> <== NOT EXECUTED
return 0;
}
1deb4: e3a00000 mov r0, #0 <== NOT EXECUTED
1deb8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
0001de6c <rtems_nvdisk_sram_verify>:
uint32_t flags __attribute__((unused)),
void* base,
uint32_t offset,
const void* buffer,
size_t size)
{
1de6c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return memcmp ((base + offset), buffer, size) == 0 ? 0 : EIO;
1de70: e0820003 add r0, r2, r3 <== NOT EXECUTED
1de74: e99d0006 ldmib sp, {r1, r2} <== NOT EXECUTED
1de78: eb0088a6 bl 40118 <memcmp> <== NOT EXECUTED
}
1de7c: e3500000 cmp r0, #0 <== NOT EXECUTED
1de80: 13a00005 movne r0, #5 <== NOT EXECUTED
1de84: 03a00000 moveq r0, #0 <== NOT EXECUTED
1de88: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
0001de8c <rtems_nvdisk_sram_write>:
uint32_t flags __attribute__((unused)),
void* base,
uint32_t offset,
const void* buffer,
size_t size)
{
1de8c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
memcpy ((base + offset), buffer, size);
1de90: e0820003 add r0, r2, r3 <== NOT EXECUTED
1de94: e99d0006 ldmib sp, {r1, r2} <== NOT EXECUTED
1de98: eb0088c8 bl 401c0 <memcpy> <== NOT EXECUTED
return 0;
}
1de9c: e3a00000 mov r0, #0 <== NOT EXECUTED
1dea0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00006654 <rtems_panic>:
void rtems_panic(
const char *printf_format,
...
)
{
6654: e92d000f push {r0, r1, r2, r3} <== NOT EXECUTED
6658: e92d4001 push {r0, lr} <== NOT EXECUTED
va_list arglist;
va_start(arglist, printf_format);
665c: e28d300c add r3, sp, #12 <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
6660: e1a02003 mov r2, r3 <== NOT EXECUTED
6664: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED
6668: e3a00202 mov r0, #536870912 ; 0x20000000 <== NOT EXECUTED
...
)
{
va_list arglist;
va_start(arglist, printf_format);
666c: e58d3000 str r3, [sp] <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
6670: ebffff8e bl 64b0 <rtems_verror> <== NOT EXECUTED
va_end(arglist);
}
6674: e8bd4008 pop {r3, lr} <== NOT EXECUTED
6678: e28dd010 add sp, sp, #16 <== NOT EXECUTED
667c: e12fff1e bx lr <== NOT EXECUTED
000087c4 <rtems_pipe_initialize>:
/*
* Initialization of FIFO/pipe module.
*/
void rtems_pipe_initialize (void)
{
if (!rtems_pipe_configured)
87c4: e59f3048 ldr r3, [pc, #72] ; 8814 <rtems_pipe_initialize+0x50>
87c8: e5d33000 ldrb r3, [r3]
87cc: e3530000 cmp r3, #0
/*
* Initialization of FIFO/pipe module.
*/
void rtems_pipe_initialize (void)
{
87d0: e92d4001 push {r0, lr}
if (!rtems_pipe_configured)
87d4: 0a00000d beq 8810 <rtems_pipe_initialize+0x4c>
return;
if (rtems_pipe_semaphore)
87d8: e59fc038 ldr ip, [pc, #56] ; 8818 <rtems_pipe_initialize+0x54><== NOT EXECUTED
87dc: e59c3000 ldr r3, [ip] <== NOT EXECUTED
87e0: e3530000 cmp r3, #0 <== NOT EXECUTED
87e4: 1a000009 bne 8810 <rtems_pipe_initialize+0x4c> <== NOT EXECUTED
return;
rtems_status_code sc;
sc = rtems_semaphore_create(
87e8: e59f002c ldr r0, [pc, #44] ; 881c <rtems_pipe_initialize+0x58><== NOT EXECUTED
87ec: e3a01001 mov r1, #1 <== NOT EXECUTED
87f0: e3a02054 mov r2, #84 ; 0x54 <== NOT EXECUTED
87f4: e58dc000 str ip, [sp] <== NOT EXECUTED
87f8: ebfff1d5 bl 4f54 <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)
87fc: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
8800: 1bfff3e8 blne 57a8 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_interval now;
now = rtems_clock_get_ticks_since_boot();
8804: ebfff0d8 bl 4b6c <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED
rtems_pipe_no = now;
8808: e59f3010 ldr r3, [pc, #16] ; 8820 <rtems_pipe_initialize+0x5c><== NOT EXECUTED
880c: e1c300b0 strh r0, [r3] <== NOT EXECUTED
}
8810: e8bd8008 pop {r3, pc}
0003c2ac <rtems_rfs_bitmap_close>:
return rtems_rfs_bitmap_create_search (control);
}
int
rtems_rfs_bitmap_close (rtems_rfs_bitmap_control* control)
{
3c2ac: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
free (control->search_bits);
3c2b0: e5900014 ldr r0, [r0, #20] <== NOT EXECUTED
3c2b4: ebff2cfe bl 76b4 <free> <== NOT EXECUTED
return 0;
}
3c2b8: e3a00000 mov r0, #0 <== NOT EXECUTED
3c2bc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
0003c310 <rtems_rfs_bitmap_create_search>:
return 0;
}
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
3c310: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr} <== 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);
3c314: e1a0100d mov r1, sp <== NOT EXECUTED
return 0;
}
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
3c318: 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);
3c31c: ebffffe7 bl 3c2c0 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
3c320: e3500000 cmp r0, #0 <== NOT EXECUTED
3c324: ca000021 bgt 3c3b0 <rtems_rfs_bitmap_create_search+0xa0> <== NOT EXECUTED
return rc;
control->free = 0;
search_map = control->search_bits;
3c328: e594c014 ldr ip, [r4, #20] <== NOT EXECUTED
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
3c32c: e3e02000 mvn r2, #0 <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
control->free = 0;
3c330: e3a03000 mov r3, #0 <== NOT EXECUTED
3c334: e5843010 str r3, [r4, #16] <== NOT EXECUTED
search_map = control->search_bits;
size = control->size;
3c338: e594000c ldr r0, [r4, #12] <== NOT EXECUTED
{
/*
* Use the normal bit operators because we do not change the bits just merge
* the 2 separate parts.
*/
bits1 &= mask;
3c33c: e1a07002 mov r7, r2 <== NOT EXECUTED
control->free = 0;
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
3c340: e58c2000 str r2, [ip] <== NOT EXECUTED
3c344: e59d1000 ldr r1, [sp] <== 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))
3c348: e3a08001 mov r8, #1 <== NOT EXECUTED
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
3c34c: ea000015 b 3c3a8 <rtems_rfs_bitmap_create_search+0x98> <== NOT EXECUTED
{
rtems_rfs_bitmap_element bits;
int available;
if (size < rtems_rfs_bitmap_element_bits ())
3c350: e350001f cmp r0, #31 <== NOT EXECUTED
3c354: e5916000 ldr r6, [r1] <== NOT EXECUTED
{
/*
* Use the normal bit operators because we do not change the bits just merge
* the 2 separate parts.
*/
bits1 &= mask;
3c358: 92602020 rsbls r2, r0, #32 <== NOT EXECUTED
3c35c: 90066237 andls r6, r6, r7, lsr r2 <== 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;
3c360: 91a05000 movls r5, r0 <== NOT EXECUTED
}
else
{
bits = *map;
3c364: 83a05020 movhi r5, #32 <== NOT EXECUTED
available = rtems_rfs_bitmap_element_bits ();
}
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
3c368: e3560000 cmp r6, #0 <== NOT EXECUTED
3c36c: 0a000007 beq 3c390 <rtems_rfs_bitmap_create_search+0x80> <== NOT EXECUTED
3c370: e3a02000 mov r2, #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))
3c374: e016a218 ands sl, r6, r8, lsl r2 <== NOT EXECUTED
control->free++;
3c378: 1594a010 ldrne sl, [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++)
3c37c: e2822001 add r2, r2, #1 <== NOT EXECUTED
if (!rtems_rfs_bitmap_test (bits, b))
control->free++;
3c380: 128aa001 addne sl, sl, #1 <== NOT EXECUTED
3c384: 1584a010 strne sl, [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++)
3c388: e1520005 cmp r2, r5 <== NOT EXECUTED
3c38c: bafffff8 blt 3c374 <rtems_rfs_bitmap_create_search+0x64> <== NOT EXECUTED
control->free++;
}
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
3c390: e3530020 cmp r3, #32 <== NOT EXECUTED
{
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
3c394: 05ac7004 streq r7, [ip, #4]! <== NOT EXECUTED
3c398: 03a03000 moveq r3, #0 <== NOT EXECUTED
}
else
bit++;
3c39c: 12833001 addne r3, r3, #1 <== NOT EXECUTED
for (b = 0; b < available; b++)
if (!rtems_rfs_bitmap_test (bits, b))
control->free++;
}
size -= available;
3c3a0: e0650000 rsb r0, r5, r0 <== NOT EXECUTED
3c3a4: e2811004 add r1, r1, #4 <== NOT EXECUTED
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
3c3a8: e3500000 cmp r0, #0 <== NOT EXECUTED
3c3ac: 1affffe7 bne 3c350 <rtems_rfs_bitmap_create_search+0x40> <== NOT EXECUTED
bit++;
map++;
}
return 0;
}
3c3b0: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
0003c2c0 <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)
3c2c0: e5903000 ldr r3, [r0] <== NOT EXECUTED
3c2c4: 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)
{
3c2c8: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3c2cc: e1a04000 mov r4, r0 <== NOT EXECUTED
3c2d0: e1a05001 mov r5, r1 <== NOT EXECUTED
int rc;
if (!control->buffer)
3c2d4: 03a00006 moveq r0, #6 <== NOT EXECUTED
3c2d8: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
return ENXIO;
*map = NULL;
3c2dc: e3a02000 mov r2, #0 <== NOT EXECUTED
3c2e0: e5812000 str r2, [r1] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (control->fs,
3c2e4: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED
3c2e8: e1a01003 mov r1, r3 <== NOT EXECUTED
3c2ec: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED
3c2f0: e3a03001 mov r3, #1 <== NOT EXECUTED
3c2f4: ebffe0f9 bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
control->buffer,
control->block,
true);
if (rc)
3c2f8: e3500000 cmp r0, #0 <== NOT EXECUTED
return rc;
*map = rtems_rfs_buffer_data (control->buffer);
3c2fc: 05943000 ldreq r3, [r4] <== NOT EXECUTED
3c300: 05933008 ldreq r3, [r3, #8] <== NOT EXECUTED
3c304: 05933020 ldreq r3, [r3, #32] <== NOT EXECUTED
3c308: 05853000 streq r3, [r5] <== NOT EXECUTED
return 0;
}
3c30c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
0003c888 <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)
{
3c888: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3c88c: e1a07002 mov r7, r2 <== NOT EXECUTED
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
3c890: e3a02000 mov r2, #0 <== NOT EXECUTED
3c894: e1a04001 mov r4, r1 <== NOT EXECUTED
3c898: 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)
{
3c89c: e1a06000 mov r6, r0 <== NOT EXECUTED
3c8a0: e1a08003 mov r8, r3 <== NOT EXECUTED
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
3c8a4: e1a05001 mov r5, 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))
3c8a8: ea00001f b 3c92c <rtems_rfs_bitmap_map_alloc+0xa4> <== 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)
3c8ac: e596300c ldr r3, [r6, #12] <== NOT EXECUTED
3c8b0: e1550003 cmp r5, r3 <== NOT EXECUTED
3c8b4: 2a00000a bcs 3c8e4 <rtems_rfs_bitmap_map_alloc+0x5c> <== NOT EXECUTED
{
*bit = upper_seed;
3c8b8: e5885000 str r5, [r8] <== NOT EXECUTED
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
3c8bc: e1a00006 mov r0, r6 <== NOT EXECUTED
3c8c0: e1a01008 mov r1, r8 <== NOT EXECUTED
3c8c4: e1a02007 mov r2, r7 <== NOT EXECUTED
3c8c8: e3a03001 mov r3, #1 <== NOT EXECUTED
3c8cc: ebffff69 bl 3c678 <T.57> <== NOT EXECUTED
window, 1);
if ((rc > 0) || *allocated)
3c8d0: e3500000 cmp r0, #0 <== NOT EXECUTED
3c8d4: ca00001e bgt 3c954 <rtems_rfs_bitmap_map_alloc+0xcc> <== NOT EXECUTED
3c8d8: e5d73000 ldrb r3, [r7] <== NOT EXECUTED
3c8dc: e3530000 cmp r3, #0 <== NOT EXECUTED
3c8e0: 1a00001b bne 3c954 <rtems_rfs_bitmap_map_alloc+0xcc> <== NOT EXECUTED
break;
}
if (lower_seed >= 0)
3c8e4: e3540000 cmp r4, #0 <== NOT EXECUTED
3c8e8: ba00000a blt 3c918 <rtems_rfs_bitmap_map_alloc+0x90> <== NOT EXECUTED
{
*bit = lower_seed;
3c8ec: e5884000 str r4, [r8] <== NOT EXECUTED
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
3c8f0: e1a00006 mov r0, r6 <== NOT EXECUTED
3c8f4: e1a01008 mov r1, r8 <== NOT EXECUTED
3c8f8: e1a02007 mov r2, r7 <== NOT EXECUTED
3c8fc: e3e03000 mvn r3, #0 <== NOT EXECUTED
3c900: ebffff5c bl 3c678 <T.57> <== NOT EXECUTED
window, -1);
if ((rc > 0) || *allocated)
3c904: e3500000 cmp r0, #0 <== NOT EXECUTED
3c908: ca000011 bgt 3c954 <rtems_rfs_bitmap_map_alloc+0xcc> <== NOT EXECUTED
3c90c: e5d73000 ldrb r3, [r7] <== NOT EXECUTED
3c910: e3530000 cmp r3, #0 <== NOT EXECUTED
3c914: 1a00000e bne 3c954 <rtems_rfs_bitmap_map_alloc+0xcc> <== 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)
3c918: e596300c ldr r3, [r6, #12] <== NOT EXECUTED
3c91c: e1550003 cmp r5, r3 <== NOT EXECUTED
upper_seed += window;
3c920: 32855b02 addcc r5, r5, #2048 ; 0x800 <== NOT EXECUTED
if (lower_seed >= 0)
3c924: e3540000 cmp r4, #0 <== NOT EXECUTED
lower_seed -= window;
3c928: a2444b02 subge r4, r4, #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))
3c92c: e3550000 cmp r5, #0 <== NOT EXECUTED
3c930: ba000002 blt 3c940 <rtems_rfs_bitmap_map_alloc+0xb8> <== NOT EXECUTED
3c934: e596300c ldr r3, [r6, #12] <== NOT EXECUTED
3c938: e1550003 cmp r5, r3 <== NOT EXECUTED
3c93c: 3affffda bcc 3c8ac <rtems_rfs_bitmap_map_alloc+0x24> <== NOT EXECUTED
3c940: e3540000 cmp r4, #0 <== NOT EXECUTED
3c944: ba000002 blt 3c954 <rtems_rfs_bitmap_map_alloc+0xcc> <== NOT EXECUTED
|| ((lower_seed >= 0) && (lower_seed < control->size)))
3c948: e596300c ldr r3, [r6, #12] <== NOT EXECUTED
3c94c: e1540003 cmp r4, r3 <== NOT EXECUTED
3c950: 3affffd5 bcc 3c8ac <rtems_rfs_bitmap_map_alloc+0x24> <== NOT EXECUTED
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
3c954: e3a00000 mov r0, #0 <== NOT EXECUTED
3c958: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
0003c578 <rtems_rfs_bitmap_map_clear>:
}
int
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
3c578: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
3c57c: 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);
3c580: e1a0100d mov r1, sp <== NOT EXECUTED
}
int
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
3c584: 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);
3c588: ebffff4c bl 3c2c0 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
3c58c: e3500000 cmp r0, #0 <== NOT EXECUTED
3c590: ca000016 bgt 3c5f0 <rtems_rfs_bitmap_map_clear+0x78> <== NOT EXECUTED
return rc;
if (bit >= control->size)
3c594: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
3c598: e1550003 cmp r5, r3 <== NOT EXECUTED
3c59c: 23a00016 movcs r0, #22 <== NOT EXECUTED
3c5a0: 2a000012 bcs 3c5f0 <rtems_rfs_bitmap_map_clear+0x78> <== 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);
3c5a4: 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);
3c5a8: e1a022c5 asr r2, r5, #5 <== NOT EXECUTED
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
3c5ac: e7910102 ldr r0, [r1, r2, lsl #2] <== NOT EXECUTED
3c5b0: e3a03001 mov r3, #1 <== NOT EXECUTED
3c5b4: e205c01f and ip, r5, #31 <== NOT EXECUTED
3c5b8: e1800c13 orr r0, r0, r3, lsl ip <== NOT EXECUTED
3c5bc: 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;
3c5c0: 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);
3c5c4: e1a05545 asr r5, r5, #10 <== NOT EXECUTED
3c5c8: e7910105 ldr r0, [r1, r5, lsl #2] <== NOT EXECUTED
3c5cc: e202201f and r2, r2, #31 <== NOT EXECUTED
3c5d0: e1802213 orr r2, r0, r3, lsl r2 <== NOT EXECUTED
3c5d4: e7812105 str r2, [r1, r5, lsl #2] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
control->free++;
3c5d8: 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);
3c5dc: e5941000 ldr r1, [r4] <== NOT EXECUTED
control->free++;
3c5e0: 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);
3c5e4: e5c13000 strb r3, [r1] <== NOT EXECUTED
control->free++;
3c5e8: e5842010 str r2, [r4, #16] <== NOT EXECUTED
3c5ec: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
}
3c5f0: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
0003c3fc <rtems_rfs_bitmap_map_clear_all>:
return 0;
}
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
3c3fc: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
rtems_rfs_bitmap_bit last_search_bit;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
3c400: e1a0100d mov r1, sp <== NOT EXECUTED
return 0;
}
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
3c404: 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);
3c408: ebffffac bl 3c2c0 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
3c40c: e3500000 cmp r0, #0 <== NOT EXECUTED
3c410: ca00001f bgt 3c494 <rtems_rfs_bitmap_map_clear_all+0x98> <== NOT EXECUTED
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
3c414: e594100c ldr r1, [r4, #12] <== NOT EXECUTED
3c418: e2411001 sub r1, r1, #1 <== NOT EXECUTED
3c41c: e1a012a1 lsr r1, r1, #5 <== NOT EXECUTED
3c420: e2813001 add r3, r1, #1 <== NOT EXECUTED
control->free = elements;
3c424: e5843010 str r3, [r4, #16] <== NOT EXECUTED
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
3c428: e59dc000 ldr ip, [sp] <== NOT EXECUTED
3c42c: e3a02000 mov r2, #0 <== NOT EXECUTED
3c430: e3e00000 mvn r0, #0 <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
3c434: ea000001 b 3c440 <rtems_rfs_bitmap_map_clear_all+0x44> <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
3c438: 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++)
3c43c: e2822001 add r2, r2, #1 <== NOT EXECUTED
3c440: e1520003 cmp r2, r3 <== NOT EXECUTED
3c444: 3afffffb bcc 3c438 <rtems_rfs_bitmap_map_clear_all+0x3c> <== 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)
3c448: e213201f ands r2, r3, #31 <== NOT EXECUTED
3c44c: 03a02020 moveq r2, #32 <== NOT EXECUTED
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
3c450: e1a0c2a1 lsr ip, r1, #5 <== NOT EXECUTED
return 0;
}
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
3c454: e3a03000 mov r3, #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;
3c458: e3e00000 mvn r0, #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++)
3c45c: ea000001 b 3c468 <rtems_rfs_bitmap_map_clear_all+0x6c> <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
3c460: e7810103 str r0, [r1, r3, 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++)
3c464: e2833001 add r3, r3, #1 <== NOT EXECUTED
3c468: e153000c cmp r3, ip <== NOT EXECUTED
3c46c: e5941014 ldr r1, [r4, #20] <== NOT EXECUTED
3c470: 1afffffa bne 3c460 <rtems_rfs_bitmap_map_clear_all+0x64> <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
control->search_bits[elements - 1] =
3c474: e3e00000 mvn r0, #0 <== NOT EXECUTED
3c478: e2622020 rsb r2, r2, #32 <== NOT EXECUTED
3c47c: e1a02230 lsr r2, r0, r2 <== 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);
3c480: e5940000 ldr r0, [r4] <== 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] =
3c484: e7812103 str r2, [r1, r3, 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);
3c488: e3a03001 mov r3, #1 <== NOT EXECUTED
3c48c: e5c03000 strb r3, [r0] <== NOT EXECUTED
3c490: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
}
3c494: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
0003c5f4 <rtems_rfs_bitmap_map_set>:
}
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
3c5f4: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
3c5f8: 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);
3c5fc: e1a0100d mov r1, sp <== NOT EXECUTED
}
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
3c600: 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);
3c604: ebffff2d bl 3c2c0 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
3c608: e3500000 cmp r0, #0 <== NOT EXECUTED
3c60c: ca000018 bgt 3c674 <rtems_rfs_bitmap_map_set+0x80> <== NOT EXECUTED
return rc;
if (bit >= control->size)
3c610: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
3c614: e1550003 cmp r5, r3 <== NOT EXECUTED
3c618: 23a00016 movcs r0, #22 <== NOT EXECUTED
3c61c: 2a000014 bcs 3c674 <rtems_rfs_bitmap_map_set+0x80> <== 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);
3c620: 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);
3c624: e1a022c5 asr r2, 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);
3c628: e7910102 ldr r0, [r1, r2, lsl #2] <== NOT EXECUTED
3c62c: e205c01f and ip, r5, #31 <== NOT EXECUTED
3c630: e3a03001 mov r3, #1 <== NOT EXECUTED
3c634: e1c00c13 bic r0, r0, r3, 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))
3c638: 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);
3c63c: 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;
3c640: 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))
3c644: 13a00000 movne r0, #0 <== NOT EXECUTED
3c648: 1a000009 bne 3c674 <rtems_rfs_bitmap_map_set+0x80> <== 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);
3c64c: e1a05545 asr r5, r5, #10 <== NOT EXECUTED
3c650: e791c105 ldr ip, [r1, r5, lsl #2] <== NOT EXECUTED
3c654: e202201f and r2, r2, #31 <== NOT EXECUTED
3c658: e1cc2213 bic r2, ip, r3, lsl r2 <== NOT EXECUTED
3c65c: e7812105 str r2, [r1, r5, lsl #2] <== NOT EXECUTED
control->free--;
3c660: e5942010 ldr r2, [r4, #16] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
3c664: 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--;
3c668: e2422001 sub r2, r2, #1 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
3c66c: e5c13000 strb r3, [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--;
3c670: e5842010 str r2, [r4, #16] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
}
return 0;
}
3c674: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
0003c498 <rtems_rfs_bitmap_map_set_all>:
return 0;
}
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
{
3c498: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
rtems_rfs_bitmap_map map;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
3c49c: e1a0100d mov r1, sp <== NOT EXECUTED
return 0;
}
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
{
3c4a0: 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);
3c4a4: ebffff85 bl 3c2c0 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
3c4a8: e3500000 cmp r0, #0 <== NOT EXECUTED
3c4ac: ca00001a bgt 3c51c <rtems_rfs_bitmap_map_set_all+0x84> <== NOT EXECUTED
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
3c4b0: e594200c ldr r2, [r4, #12] <== NOT EXECUTED
3c4b4: e2422001 sub r2, r2, #1 <== NOT EXECUTED
control->free = 0;
3c4b8: e3a01000 mov r1, #0 <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
3c4bc: e1a022a2 lsr r2, r2, #5 <== NOT EXECUTED
control->free = 0;
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
3c4c0: e1a03001 mov r3, r1 <== NOT EXECUTED
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
control->free = 0;
3c4c4: e5841010 str r1, [r4, #16] <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
3c4c8: e282c001 add ip, r2, #1 <== NOT EXECUTED
control->free = 0;
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
3c4cc: e59d0000 ldr r0, [sp] <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (control->size);
control->free = 0;
for (e = 0; e < elements; e++)
3c4d0: ea000001 b 3c4dc <rtems_rfs_bitmap_map_set_all+0x44> <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
3c4d4: e7801103 str r1, [r0, r3, lsl #2] <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (control->size);
control->free = 0;
for (e = 0; e < elements; e++)
3c4d8: e2833001 add r3, r3, #1 <== NOT EXECUTED
3c4dc: e153000c cmp r3, ip <== NOT EXECUTED
3c4e0: 3afffffb bcc 3c4d4 <rtems_rfs_bitmap_map_set_all+0x3c> <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
elements = rtems_rfs_bitmap_elements (elements);
3c4e4: e1a022a2 lsr r2, r2, #5 <== NOT EXECUTED
3c4e8: e3a03000 mov r3, #0 <== NOT EXECUTED
3c4ec: e2822001 add r2, r2, #1 <== NOT EXECUTED
for (e = 0; e < elements; e++)
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
3c4f0: e1a01003 mov r1, r3 <== 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++)
3c4f4: ea000002 b 3c504 <rtems_rfs_bitmap_map_set_all+0x6c> <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
3c4f8: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED
3c4fc: e7801103 str r1, [r0, r3, 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++)
3c500: e2833001 add r3, r3, #1 <== NOT EXECUTED
3c504: e1530002 cmp r3, r2 <== NOT EXECUTED
3c508: 3afffffa bcc 3c4f8 <rtems_rfs_bitmap_map_set_all+0x60> <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
rtems_rfs_buffer_mark_dirty (control->buffer);
3c50c: e5943000 ldr r3, [r4] <== NOT EXECUTED
3c510: e3a02001 mov r2, #1 <== NOT EXECUTED
3c514: e5c32000 strb r2, [r3] <== NOT EXECUTED
3c518: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
}
3c51c: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
0003c520 <rtems_rfs_bitmap_map_test>:
int
rtems_rfs_bitmap_map_test (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit,
bool* state)
{
3c520: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
3c524: e1a04001 mov r4, r1 <== NOT EXECUTED
rtems_rfs_bitmap_map map;
int index;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
3c528: e1a0100d mov r1, sp <== NOT EXECUTED
int
rtems_rfs_bitmap_map_test (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit,
bool* state)
{
3c52c: e1a05002 mov r5, r2 <== NOT EXECUTED
3c530: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_rfs_bitmap_map map;
int index;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
3c534: ebffff61 bl 3c2c0 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
3c538: e3500000 cmp r0, #0 <== NOT EXECUTED
3c53c: ca00000c bgt 3c574 <rtems_rfs_bitmap_map_test+0x54> <== NOT EXECUTED
return rc;
if (bit >= control->size)
3c540: e596300c ldr r3, [r6, #12] <== NOT EXECUTED
3c544: e1540003 cmp r4, r3 <== NOT EXECUTED
3c548: 23a00016 movcs r0, #22 <== NOT EXECUTED
3c54c: 2a000008 bcs 3c574 <rtems_rfs_bitmap_map_test+0x54> <== NOT EXECUTED
return EINVAL;
index = rtems_rfs_bitmap_map_index (bit);
*state = rtems_rfs_bitmap_test (map[index], bit);
3c550: e59d3000 ldr r3, [sp] <== NOT EXECUTED
3c554: e1a022c4 asr r2, r4, #5 <== NOT EXECUTED
3c558: e7933102 ldr r3, [r3, r2, lsl #2] <== NOT EXECUTED
3c55c: e3a02001 mov r2, #1 <== NOT EXECUTED
3c560: e0133412 ands r3, r3, r2, lsl r4 <== NOT EXECUTED
3c564: 13a03000 movne r3, #0 <== NOT EXECUTED
3c568: 03a03001 moveq r3, #1 <== NOT EXECUTED
3c56c: e5c53000 strb r3, [r5] <== NOT EXECUTED
3c570: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
}
3c574: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
0003c27c <rtems_rfs_bitmap_mask>:
return 0;
}
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
3c27c: e3e03000 mvn r3, #0 <== NOT EXECUTED
3c280: 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;
}
3c284: e1a00033 lsr r0, r3, r0 <== NOT EXECUTED
3c288: e12fff1e bx lr <== NOT EXECUTED
0003c28c <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)
3c28c: e1510000 cmp r1, r0 <== NOT EXECUTED
mask = rtems_rfs_bitmap_mask (end - start) << start;
3c290: 80601001 rsbhi r1, r0, r1 <== NOT EXECUTED
3c294: 82611020 rsbhi r1, r1, #32 <== NOT EXECUTED
3c298: 83e03000 mvnhi r3, #0 <== NOT EXECUTED
3c29c: 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)
3c2a0: 93a00000 movls r0, #0 <== NOT EXECUTED
mask = rtems_rfs_bitmap_mask (end - start) << start;
3c2a4: 81a00011 lslhi r0, r1, r0 <== NOT EXECUTED
return mask;
}
3c2a8: e12fff1e bx lr <== NOT EXECUTED
0003c3b4 <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)
{
3c3b4: 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));
3c3b8: 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)
{
3c3bc: 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));
3c3c0: 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;
3c3c4: e5842000 str r2, [r4] <== NOT EXECUTED
control->fs = fs;
control->block = block;
3c3c8: 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));
3c3cc: 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;
3c3d0: 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));
3c3d4: e1a00100 lsl r0, r0, #2 <== NOT EXECUTED
3c3d8: ebff2e5c bl 7d50 <malloc> <== NOT EXECUTED
if (!control->search_bits)
3c3dc: 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));
3c3e0: e5840014 str r0, [r4, #20] <== NOT EXECUTED
if (!control->search_bits)
3c3e4: 1a000001 bne 3c3f0 <rtems_rfs_bitmap_open+0x3c> <== NOT EXECUTED
return ENOMEM;
return rtems_rfs_bitmap_create_search (control);
}
3c3e8: e280000c add r0, r0, #12 <== NOT EXECUTED
3c3ec: e8bd8010 pop {r4, pc} <== 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);
3c3f0: e1a00004 mov r0, r4 <== NOT EXECUTED
}
3c3f4: 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);
3c3f8: eaffffc4 b 3c310 <rtems_rfs_bitmap_create_search> <== NOT EXECUTED
00033640 <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)
{
33640: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
33644: 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);
33648: 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)
{
3364c: e1a06000 mov r6, r0 <== NOT EXECUTED
33650: e1a07001 mov r7, r1 <== NOT EXECUTED
33654: 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);
33658: eb000420 bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
3365c: e3500000 cmp r0, #0 <== NOT EXECUTED
33660: c8bd80f0 popgt {r4, r5, r6, r7, pc} <== NOT EXECUTED
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
33664: e5973008 ldr r3, [r7, #8] <== NOT EXECUTED
33668: e5932020 ldr r2, [r3, #32] <== NOT EXECUTED
3366c: e0821104 add r1, r2, r4, lsl #2 <== NOT EXECUTED
33670: e7d20104 ldrb r0, [r2, r4, lsl #2] <== NOT EXECUTED
33674: e5d13003 ldrb r3, [r1, #3] <== NOT EXECUTED
33678: e1a04001 mov r4, r1 <== NOT EXECUTED
3367c: e5d11001 ldrb r1, [r1, #1] <== NOT EXECUTED
33680: e5d42002 ldrb r2, [r4, #2] <== NOT EXECUTED
33684: e1833c00 orr r3, r3, r0, lsl #24 <== NOT EXECUTED
33688: e1833801 orr r3, r3, r1, lsl #16 <== NOT EXECUTED
3368c: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
if ((*result + 1) == 0)
33690: e3730001 cmn r3, #1 <== NOT EXECUTED
33694: 03a03000 moveq r3, #0 <== NOT EXECUTED
33698: e5853000 str r3, [r5] <== NOT EXECUTED
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
3369c: e5962004 ldr r2, [r6, #4] <== NOT EXECUTED
336a0: 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;
336a4: 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))
336a8: 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;
336ac: 25850000 strcs r0, [r5] <== NOT EXECUTED
rc = EIO;
}
return 0;
}
336b0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
000335a0 <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)
{
335a0: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
335a4: e1a05002 mov r5, r2 <== NOT EXECUTED
if (pos == 0)
335a8: 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)
{
335ac: e1a06001 mov r6, r1 <== NOT EXECUTED
335b0: e1a04003 mov r4, r3 <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size)
{
size->count = 0;
size->offset = 0;
335b4: 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;
335b8: 05832000 streq r2, [r3] <== NOT EXECUTED
if (pos == 0)
335bc: 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;
335c0: e5907008 ldr r7, [r0, #8] <== NOT EXECUTED
335c4: e3a03000 mov r3, #0 <== NOT EXECUTED
335c8: e1a02007 mov r2, r7 <== NOT EXECUTED
335cc: e1a00001 mov r0, r1 <== NOT EXECUTED
335d0: e1a01005 mov r1, r5 <== NOT EXECUTED
335d4: eb008a21 bl 55e60 <__udivdi3> <== NOT EXECUTED
335d8: e2800001 add r0, r0, #1 <== NOT EXECUTED
335dc: e5840000 str r0, [r4] <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
335e0: e1a01005 mov r1, r5 <== NOT EXECUTED
335e4: e1a00006 mov r0, r6 <== NOT EXECUTED
335e8: e1a02007 mov r2, r7 <== NOT EXECUTED
335ec: e3a03000 mov r3, #0 <== NOT EXECUTED
335f0: eb008b2b bl 562a4 <__umoddi3> <== NOT EXECUTED
335f4: e5840004 str r0, [r4, #4] <== NOT EXECUTED
335f8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00033540 <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)
{
33540: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
bpos->bno = pos / rtems_rfs_fs_block_size (fs);
33544: 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)
{
33548: e1a08002 mov r8, r2 <== NOT EXECUTED
bpos->bno = pos / rtems_rfs_fs_block_size (fs);
3354c: 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)
{
33550: e1a04003 mov r4, r3 <== NOT EXECUTED
33554: e1a07001 mov r7, r1 <== NOT EXECUTED
bpos->bno = pos / rtems_rfs_fs_block_size (fs);
33558: e1a02006 mov r2, r6 <== NOT EXECUTED
3355c: e1a03005 mov r3, r5 <== NOT EXECUTED
33560: e1a00001 mov r0, r1 <== NOT EXECUTED
33564: e1a01008 mov r1, r8 <== NOT EXECUTED
33568: eb008a3c bl 55e60 <__udivdi3> <== NOT EXECUTED
bpos->boff = pos % rtems_rfs_fs_block_size (fs);
3356c: 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);
33570: e5840000 str r0, [r4] <== NOT EXECUTED
bpos->boff = pos % rtems_rfs_fs_block_size (fs);
33574: e1a01008 mov r1, r8 <== NOT EXECUTED
33578: e1a00007 mov r0, r7 <== NOT EXECUTED
3357c: e1a03005 mov r3, r5 <== NOT EXECUTED
33580: eb008b47 bl 562a4 <__umoddi3> <== NOT EXECUTED
33584: e5840004 str r0, [r4, #4] <== NOT EXECUTED
}
33588: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
0003358c <rtems_rfs_block_get_pos>:
rtems_rfs_pos
rtems_rfs_block_get_pos (rtems_rfs_file_system* fs,
rtems_rfs_block_pos* bpos)
{
3358c: e5902008 ldr r2, [r0, #8] <== NOT EXECUTED
33590: e8910009 ldm r1, {r0, r3} <== NOT EXECUTED
return (bpos->bno * rtems_rfs_fs_block_size (fs)) + bpos->boff;
}
33594: e3a01000 mov r1, #0 <== NOT EXECUTED
33598: e0203092 mla r0, r2, r0, r3 <== NOT EXECUTED
3359c: e12fff1e bx lr <== NOT EXECUTED
000335fc <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)
335fc: e5913000 ldr r3, [r1] <== NOT EXECUTED
33600: e3530000 cmp r3, #0 <== NOT EXECUTED
}
rtems_rfs_pos
rtems_rfs_block_get_size (rtems_rfs_file_system* fs,
rtems_rfs_block_size* size)
{
33604: e92d4010 push {r4, lr} <== NOT EXECUTED
uint32_t offset;
uint64_t block_size;
if (size->count == 0)
33608: 03a03000 moveq r3, #0 <== NOT EXECUTED
3360c: 03a04000 moveq r4, #0 <== NOT EXECUTED
33610: 0a000007 beq 33634 <rtems_rfs_block_get_size+0x38> <== NOT EXECUTED
return 0;
if (size->offset == 0)
33614: e5912004 ldr r2, [r1, #4] <== NOT EXECUTED
offset = rtems_rfs_fs_block_size (fs);
else
offset = size->offset;
block_size = rtems_rfs_fs_block_size (fs);
return (((uint64_t) (size->count - 1)) * block_size) + offset;
33618: e590c008 ldr ip, [r0, #8] <== NOT EXECUTED
{
uint32_t offset;
uint64_t block_size;
if (size->count == 0)
return 0;
if (size->offset == 0)
3361c: e3520000 cmp r2, #0 <== NOT EXECUTED
offset = rtems_rfs_fs_block_size (fs);
else
offset = size->offset;
block_size = rtems_rfs_fs_block_size (fs);
return (((uint64_t) (size->count - 1)) * block_size) + offset;
33620: e2433001 sub r3, r3, #1 <== NOT EXECUTED
uint32_t offset;
uint64_t block_size;
if (size->count == 0)
return 0;
if (size->offset == 0)
offset = rtems_rfs_fs_block_size (fs);
33624: 05902008 ldreq r2, [r0, #8] <== NOT EXECUTED
else
offset = size->offset;
block_size = rtems_rfs_fs_block_size (fs);
return (((uint64_t) (size->count - 1)) * block_size) + offset;
33628: e0810c93 umull r0, r1, r3, ip <== NOT EXECUTED
3362c: e0903002 adds r3, r0, r2 <== NOT EXECUTED
33630: e2a14000 adc r4, r1, #0 <== NOT EXECUTED
}
33634: e1a01004 mov r1, r4 <== NOT EXECUTED
33638: e1a00003 mov r0, r3 <== NOT EXECUTED
3363c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
000340d8 <rtems_rfs_block_map_close>:
rtems_rfs_block_map* map)
{
int rc = 0;
int brc;
if (map->dirty && map->inode)
340d8: e5d13000 ldrb r3, [r1] <== NOT EXECUTED
340dc: e3530000 cmp r3, #0 <== NOT EXECUTED
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
340e0: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
340e4: e1a04001 mov r4, r1 <== NOT EXECUTED
340e8: e1a05000 mov r5, r0 <== NOT EXECUTED
int rc = 0;
int brc;
if (map->dirty && map->inode)
340ec: 0a00005a beq 3425c <rtems_rfs_block_map_close+0x184> <== NOT EXECUTED
340f0: e5911004 ldr r1, [r1, #4] <== NOT EXECUTED
340f4: e3510000 cmp r1, #0 <== NOT EXECUTED
340f8: 0a000057 beq 3425c <rtems_rfs_block_map_close+0x184> <== NOT EXECUTED
{
brc = rtems_rfs_inode_load (fs, map->inode);
340fc: eb000e0a bl 3792c <rtems_rfs_inode_load> <== NOT EXECUTED
if (brc > 0)
34100: e2507000 subs r7, r0, #0 <== NOT EXECUTED
34104: ca000055 bgt 34260 <rtems_rfs_block_map_close+0x188> <== NOT EXECUTED
34108: e1a00004 mov r0, r4 <== NOT EXECUTED
3410c: 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);
34110: e3a0c001 mov ip, #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]);
34114: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED
34118: 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);
3411c: e592e00c ldr lr, [r2, #12] <== NOT EXECUTED
34120: e1a06c21 lsr r6, r1, #24 <== NOT EXECUTED
34124: e08ee003 add lr, lr, r3 <== NOT EXECUTED
34128: e5ce601c strb r6, [lr, #28] <== NOT EXECUTED
3412c: e592e00c ldr lr, [r2, #12] <== NOT EXECUTED
34130: e1a06821 lsr r6, r1, #16 <== NOT EXECUTED
34134: e08ee003 add lr, lr, r3 <== NOT EXECUTED
34138: e5ce601d strb r6, [lr, #29] <== NOT EXECUTED
3413c: e592e00c ldr lr, [r2, #12] <== NOT EXECUTED
34140: e1a06421 lsr r6, r1, #8 <== NOT EXECUTED
34144: e08ee003 add lr, lr, r3 <== NOT EXECUTED
34148: e5ce601e strb r6, [lr, #30] <== NOT EXECUTED
3414c: e592e00c ldr lr, [r2, #12] <== NOT EXECUTED
34150: e08ee003 add lr, lr, r3 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
34154: e2833004 add r3, r3, #4 <== NOT EXECUTED
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
34158: 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);
3415c: e5ce101f strb r1, [lr, #31] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
34160: e2800004 add r0, r0, #4 <== NOT EXECUTED
34164: e5c2c010 strb ip, [r2, #16] <== NOT EXECUTED
34168: e3a02001 mov r2, #1 <== NOT EXECUTED
3416c: 1affffe8 bne 34114 <rtems_rfs_block_map_close+0x3c> <== NOT EXECUTED
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
34170: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
34174: 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);
34178: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
3417c: e1a0cc21 lsr ip, r1, #24 <== NOT EXECUTED
34180: e5c0c00c strb ip, [r0, #12] <== NOT EXECUTED
34184: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
34188: e1a0c821 lsr ip, r1, #16 <== NOT EXECUTED
3418c: e5c0c00d strb ip, [r0, #13] <== NOT EXECUTED
34190: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
34194: e1a0c421 lsr ip, r1, #8 <== NOT EXECUTED
34198: e5c0c00e strb ip, [r0, #14] <== NOT EXECUTED
3419c: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
341a0: e5c0100f strb r1, [r0, #15] <== NOT EXECUTED
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
341a4: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED
341a8: 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);
341ac: e590c00c ldr ip, [r0, #12] <== NOT EXECUTED
341b0: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED
341b4: 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);
341b8: 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);
341bc: e5cce00a strb lr, [ip, #10] <== NOT EXECUTED
341c0: e590300c ldr r3, [r0, #12] <== NOT EXECUTED
341c4: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED
341c8: e5c3100b strb r1, [r3, #11] <== NOT EXECUTED
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
341cc: e5941004 ldr r1, [r4, #4] <== NOT EXECUTED
341d0: 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);
341d4: e591c00c ldr ip, [r1, #12] <== NOT EXECUTED
341d8: 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);
341dc: 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);
341e0: e5cce030 strb lr, [ip, #48] ; 0x30 <== NOT EXECUTED
341e4: e591000c ldr r0, [r1, #12] <== NOT EXECUTED
341e8: e1a0c823 lsr ip, r3, #16 <== NOT EXECUTED
341ec: e5c0c031 strb ip, [r0, #49] ; 0x31 <== NOT EXECUTED
341f0: e591000c ldr r0, [r1, #12] <== NOT EXECUTED
341f4: e1a0c423 lsr ip, r3, #8 <== NOT EXECUTED
341f8: e5c0c032 strb ip, [r0, #50] ; 0x32 <== NOT EXECUTED
341fc: e591000c ldr r0, [r1, #12] <== NOT EXECUTED
34200: e5c03033 strb r3, [r0, #51] ; 0x33 <== NOT EXECUTED
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
34204: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
34208: 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);
3420c: e593c00c ldr ip, [r3, #12] <== NOT EXECUTED
34210: 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);
34214: 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);
34218: e5cce034 strb lr, [ip, #52] ; 0x34 <== NOT EXECUTED
3421c: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
34220: e1a0c820 lsr ip, r0, #16 <== NOT EXECUTED
34224: e5c1c035 strb ip, [r1, #53] ; 0x35 <== NOT EXECUTED
34228: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
3422c: e1a0c420 lsr ip, r0, #8 <== NOT EXECUTED
34230: e5c1c036 strb ip, [r1, #54] ; 0x36 <== NOT EXECUTED
34234: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
34238: e5c10037 strb r0, [r1, #55] ; 0x37 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3423c: e5c32010 strb r2, [r3, #16] <== NOT EXECUTED
brc = rtems_rfs_inode_unload (fs, map->inode, true);
34240: e1a00005 mov r0, r5 <== NOT EXECUTED
34244: e5941004 ldr r1, [r4, #4] <== NOT EXECUTED
34248: eb000d80 bl 37850 <rtems_rfs_inode_unload> <== NOT EXECUTED
if (brc > 0)
rc = brc;
map->dirty = false;
3424c: e3a03000 mov r3, #0 <== NOT EXECUTED
34250: 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);
34254: e1c07fc0 bic r7, r0, r0, asr #31 <== NOT EXECUTED
34258: ea000000 b 34260 <rtems_rfs_block_map_close+0x188> <== NOT EXECUTED
if (brc > 0)
rc = brc;
map->dirty = false;
3425c: e3a07000 mov r7, #0 <== NOT EXECUTED
}
}
map->inode = NULL;
34260: 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);
34264: e2841038 add r1, r4, #56 ; 0x38 <== NOT EXECUTED
34268: e5846004 str r6, [r4, #4] <== NOT EXECUTED
3426c: e1a00005 mov r0, r5 <== NOT EXECUTED
34270: eb0000d1 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
34274: e5c46038 strb r6, [r4, #56] ; 0x38 <== NOT EXECUTED
handle->bnum = 0;
34278: e584603c str r6, [r4, #60] ; 0x3c <== NOT EXECUTED
handle->buffer = NULL;
3427c: 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);
34280: e1a00005 mov r0, r5 <== NOT EXECUTED
34284: e2841044 add r1, r4, #68 ; 0x44 <== NOT EXECUTED
34288: eb0000cb bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
handle->buffer = NULL;
3428c: 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;
34290: e5c46044 strb r6, [r4, #68] ; 0x44 <== NOT EXECUTED
handle->bnum = 0;
34294: 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;
}
34298: e1a00007 mov r0, r7 <== NOT EXECUTED
3429c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
000336b4 <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)
{
336b4: e92d4ff3 push {r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
336b8: e1a05003 mov r5, r3 <== NOT EXECUTED
int rc = 0;
*block = 0;
336bc: e3a03000 mov r3, #0 <== NOT EXECUTED
336c0: e5853000 str r3, [r5] <== NOT EXECUTED
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
336c4: e592b000 ldr fp, [r2] <== NOT EXECUTED
336c8: 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)
{
336cc: e1a07002 mov r7, r2 <== NOT EXECUTED
336d0: e1a06000 mov r6, r0 <== NOT EXECUTED
336d4: 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))
336d8: 0a000002 beq 336e8 <rtems_rfs_block_map_find+0x34> <== NOT EXECUTED
336dc: e5913008 ldr r3, [r1, #8] <== NOT EXECUTED
336e0: e3530000 cmp r3, #0 <== NOT EXECUTED
336e4: 0a000046 beq 33804 <rtems_rfs_block_map_find+0x150> <== NOT EXECUTED
336e8: e5948008 ldr r8, [r4, #8] <== NOT EXECUTED
336ec: e15b0008 cmp fp, r8 <== NOT EXECUTED
336f0: 2a000043 bcs 33804 <rtems_rfs_block_map_find+0x150> <== 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))
336f4: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
336f8: e15b0003 cmp fp, r3 <== NOT EXECUTED
336fc: 1a000002 bne 3370c <rtems_rfs_block_map_find+0x58> <== NOT EXECUTED
33700: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED
33704: e3530000 cmp r3, #0 <== NOT EXECUTED
33708: 1a000003 bne 3371c <rtems_rfs_block_map_find+0x68> <== 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)
3370c: e3580005 cmp r8, #5 <== NOT EXECUTED
33710: 8a000003 bhi 33724 <rtems_rfs_block_map_find+0x70> <== NOT EXECUTED
{
*block = map->blocks[bpos->bno];
33714: e28bb009 add fp, fp, #9 <== NOT EXECUTED
33718: e794310b ldr r3, [r4, fp, lsl #2] <== NOT EXECUTED
3371c: e5853000 str r3, [r5] <== NOT EXECUTED
33720: ea00002e b 337e0 <rtems_rfs_block_map_find+0x12c> <== 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;
33724: e5969030 ldr r9, [r6, #48] ; 0x30 <== NOT EXECUTED
33728: e1a0000b mov r0, fp <== NOT EXECUTED
3372c: e1a01009 mov r1, r9 <== NOT EXECUTED
33730: eb008644 bl 55048 <__umodsi3> <== NOT EXECUTED
singly = bpos->bno / fs->blocks_per_block;
33734: 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;
33738: e1a0a000 mov sl, r0 <== NOT EXECUTED
singly = bpos->bno / fs->blocks_per_block;
3373c: e1a0000b mov r0, fp <== NOT EXECUTED
33740: eb0085ac bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
if (map->size.count <= fs->block_map_singly_blocks)
33744: e5963034 ldr r3, [r6, #52] ; 0x34 <== NOT EXECUTED
33748: e1580003 cmp r8, 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;
3374c: e1a0b000 mov fp, r0 <== NOT EXECUTED
33750: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
if (map->size.count <= fs->block_map_singly_blocks)
33754: 8a000005 bhi 33770 <rtems_rfs_block_map_find+0xbc> <== NOT EXECUTED
{
/*
* This is a single indirect table of blocks anchored off a slot in the
* inode.
*/
rc = rtems_rfs_block_find_indirect (fs,
33758: e280b009 add fp, r0, #9 <== NOT EXECUTED
3375c: e794210b ldr r2, [r4, fp, lsl #2] <== NOT EXECUTED
33760: e1a00006 mov r0, r6 <== NOT EXECUTED
33764: e1a0300a mov r3, sl <== NOT EXECUTED
33768: e2841038 add r1, r4, #56 ; 0x38 <== NOT EXECUTED
3376c: ea000017 b 337d0 <rtems_rfs_block_map_find+0x11c> <== 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)
33770: e5963038 ldr r3, [r6, #56] ; 0x38 <== NOT EXECUTED
33774: e1580003 cmp r8, r3 <== NOT EXECUTED
33778: 2a000021 bcs 33804 <rtems_rfs_block_map_find+0x150> <== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
3377c: e1a01009 mov r1, r9 <== NOT EXECUTED
33780: eb008630 bl 55048 <__umodsi3> <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
{
rc = rtems_rfs_block_find_indirect (fs,
33784: 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;
33788: e1a08000 mov r8, r0 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
{
rc = rtems_rfs_block_find_indirect (fs,
3378c: e1a0000b mov r0, fp <== NOT EXECUTED
33790: eb008598 bl 54df8 <__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;
33794: e28dc008 add ip, sp, #8 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
{
rc = rtems_rfs_block_find_indirect (fs,
33798: e2800009 add r0, r0, #9 <== NOT EXECUTED
3379c: 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;
337a0: e52c8004 str r8, [ip, #-4]! <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
{
rc = rtems_rfs_block_find_indirect (fs,
337a4: e1a03008 mov r3, r8 <== NOT EXECUTED
337a8: e1a00006 mov r0, r6 <== NOT EXECUTED
337ac: e2841044 add r1, r4, #68 ; 0x44 <== NOT EXECUTED
337b0: e58dc000 str ip, [sp] <== NOT EXECUTED
337b4: ebffffa1 bl 33640 <rtems_rfs_block_find_indirect> <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
singly, &singly);
if (rc == 0)
337b8: e3500000 cmp r0, #0 <== NOT EXECUTED
337bc: 1a000011 bne 33808 <rtems_rfs_block_map_find+0x154> <== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
337c0: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED
337c4: e1a00006 mov r0, r6 <== NOT EXECUTED
337c8: e1a0300a mov r3, sl <== NOT EXECUTED
337cc: e2841038 add r1, r4, #56 ; 0x38 <== NOT EXECUTED
337d0: e58d5000 str r5, [sp] <== NOT EXECUTED
337d4: ebffff99 bl 33640 <rtems_rfs_block_find_indirect> <== NOT EXECUTED
}
}
}
}
if (rc == 0)
337d8: e3500000 cmp r0, #0 <== NOT EXECUTED
337dc: 1a000009 bne 33808 <rtems_rfs_block_map_find+0x154> <== NOT EXECUTED
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
337e0: e5971008 ldr r1, [r7, #8] <== NOT EXECUTED
337e4: e897000c ldm r7, {r2, r3} <== NOT EXECUTED
337e8: e5841018 str r1, [r4, #24] <== NOT EXECUTED
337ec: e5842010 str r2, [r4, #16] <== NOT EXECUTED
337f0: e5843014 str r3, [r4, #20] <== NOT EXECUTED
map->bpos.block = *block;
337f4: e5953000 ldr r3, [r5] <== NOT EXECUTED
337f8: e3a00000 mov r0, #0 <== NOT EXECUTED
337fc: e5843018 str r3, [r4, #24] <== NOT EXECUTED
33800: ea000000 b 33808 <rtems_rfs_block_map_find+0x154> <== NOT EXECUTED
33804: e3a00006 mov r0, #6 <== NOT EXECUTED
}
return rc;
}
33808: e8bd8ffc pop {r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00033c08 <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);
33c08: e5912008 ldr r2, [r1, #8] <== NOT EXECUTED
33c0c: eaffff4d b 33948 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
00033d28 <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)
{
33d28: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
33d2c: e24dd01c sub sp, sp, #28 <== NOT EXECUTED
33d30: e58d2008 str r2, [sp, #8] <== NOT EXECUTED
33d34: 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))
33d38: 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)
{
33d3c: e1a05000 mov r5, 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))
33d40: e5911008 ldr r1, [r1, #8] <== NOT EXECUTED
33d44: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED
33d48: e0801001 add r1, r0, r1 <== NOT EXECUTED
33d4c: 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)
{
33d50: e58d3010 str r3, [sp, #16] <== 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))
33d54: 23a0a01b movcs sl, #27 <== NOT EXECUTED
33d58: 2a0000db bcs 340cc <rtems_rfs_block_map_grow+0x3a4> <== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
33d5c: e2842044 add r2, r4, #68 ; 0x44 <== NOT EXECUTED
33d60: e3a08000 mov r8, #0 <== NOT EXECUTED
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
33d64: e284b038 add fp, r4, #56 ; 0x38 <== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
33d68: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
33d6c: ea0000d0 b 340b4 <rtems_rfs_block_map_grow+0x38c> <== 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,
33d70: e1a00005 mov r0, r5 <== NOT EXECUTED
33d74: e5941020 ldr r1, [r4, #32] <== NOT EXECUTED
33d78: e3a02000 mov r2, #0 <== NOT EXECUTED
33d7c: e28d3018 add r3, sp, #24 <== NOT EXECUTED
33d80: eb000d57 bl 372e4 <rtems_rfs_group_bitmap_alloc> <== NOT EXECUTED
false, &block);
if (rc > 0)
33d84: e3500000 cmp r0, #0 <== NOT EXECUTED
33d88: ca0000ce bgt 340c8 <rtems_rfs_block_map_grow+0x3a0> <== NOT EXECUTED
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
33d8c: e5949008 ldr r9, [r4, #8] <== NOT EXECUTED
33d90: e3590004 cmp r9, #4 <== NOT EXECUTED
map->blocks[map->size.count] = block;
33d94: 959d3018 ldrls r3, [sp, #24] <== NOT EXECUTED
33d98: 92899009 addls r9, r9, #9 <== NOT EXECUTED
33d9c: 97843109 strls r3, [r4, r9, lsl #2] <== NOT EXECUTED
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
false, &block);
if (rc > 0)
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
33da0: 9a0000b5 bls 3407c <rtems_rfs_block_map_grow+0x354> <== 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;
33da4: e5956030 ldr r6, [r5, #48] ; 0x30 <== NOT EXECUTED
33da8: e1a00009 mov r0, r9 <== NOT EXECUTED
33dac: e1a01006 mov r1, r6 <== NOT EXECUTED
33db0: eb0084a4 bl 55048 <__umodsi3> <== NOT EXECUTED
singly = map->size.count / fs->blocks_per_block;
33db4: e1a01006 mov r1, r6 <== 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;
33db8: e1a07000 mov r7, r0 <== NOT EXECUTED
singly = map->size.count / fs->blocks_per_block;
33dbc: e1a00009 mov r0, r9 <== NOT EXECUTED
33dc0: eb00840c bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
if (map->size.count < fs->block_map_singly_blocks)
33dc4: e5953034 ldr r3, [r5, #52] ; 0x34 <== NOT EXECUTED
33dc8: e1590003 cmp r9, 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;
33dcc: e1a0a000 mov sl, r0 <== NOT EXECUTED
if (map->size.count < fs->block_map_singly_blocks)
33dd0: 2a000017 bcs 33e34 <rtems_rfs_block_map_grow+0x10c> <== 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) ||
33dd4: e3570000 cmp r7, #0 <== NOT EXECUTED
33dd8: 0a000002 beq 33de8 <rtems_rfs_block_map_grow+0xc0> <== NOT EXECUTED
33ddc: e3570005 cmp r7, #5 <== NOT EXECUTED
33de0: 03500000 cmpeq r0, #0 <== NOT EXECUTED
33de4: 1a00000a bne 33e14 <rtems_rfs_block_map_grow+0xec> <== 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,
33de8: e28a3009 add r3, sl, #9 <== NOT EXECUTED
33dec: e3590005 cmp r9, #5 <== NOT EXECUTED
33df0: 13a0c000 movne ip, #0 <== NOT EXECUTED
33df4: 03a0c001 moveq ip, #1 <== NOT EXECUTED
33df8: e0843103 add r3, r4, r3, lsl #2 <== NOT EXECUTED
33dfc: e1a00005 mov r0, r5 <== NOT EXECUTED
33e00: e1a01004 mov r1, r4 <== NOT EXECUTED
33e04: e1a0200b mov r2, fp <== NOT EXECUTED
33e08: e58dc000 str ip, [sp] <== NOT EXECUTED
33e0c: ebffff7f bl 33c10 <rtems_rfs_block_map_indirect_alloc> <== 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) ||
33e10: ea000005 b 33e2c <rtems_rfs_block_map_grow+0x104> <== NOT EXECUTED
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
33e14: e280a009 add sl, r0, #9 <== NOT EXECUTED
33e18: e794210a ldr r2, [r4, sl, lsl #2] <== NOT EXECUTED
33e1c: e1a00005 mov r0, r5 <== NOT EXECUTED
33e20: e1a0100b mov r1, fp <== NOT EXECUTED
33e24: e3a03001 mov r3, #1 <== NOT EXECUTED
33e28: eb00022c bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
map->blocks[singly], true);
}
if (rc > 0)
33e2c: e3500000 cmp r0, #0 <== NOT EXECUTED
33e30: ea000072 b 34000 <rtems_rfs_block_map_grow+0x2d8> <== 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;
33e34: e1a01006 mov r1, r6 <== NOT EXECUTED
33e38: eb0083ee bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
singly %= fs->blocks_per_block;
33e3c: e1a01006 mov r1, r6 <== 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;
33e40: e1a09000 mov r9, r0 <== NOT EXECUTED
singly %= fs->blocks_per_block;
33e44: e1a0000a mov r0, sl <== NOT EXECUTED
33e48: eb00847e bl 55048 <__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)
33e4c: 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;
33e50: e1a06000 mov r6, 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)
33e54: 1a00004f bne 33f98 <rtems_rfs_block_map_grow+0x270> <== NOT EXECUTED
{
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
33e58: e1a00005 mov r0, r5 <== NOT EXECUTED
33e5c: e1a01004 mov r1, r4 <== NOT EXECUTED
33e60: e1a0200b mov r2, fp <== NOT EXECUTED
33e64: e28d3014 add r3, sp, #20 <== NOT EXECUTED
33e68: e58d7000 str r7, [sp] <== NOT EXECUTED
33e6c: ebffff67 bl 33c10 <rtems_rfs_block_map_indirect_alloc> <== NOT EXECUTED
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
33e70: e3500000 cmp r0, #0 <== NOT EXECUTED
33e74: c1a0a000 movgt sl, r0 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
33e78: c1a01007 movgt r1, r7 <== NOT EXECUTED
33e7c: c1a00005 movgt r0, r5 <== NOT EXECUTED
33e80: ca000062 bgt 34010 <rtems_rfs_block_map_grow+0x2e8> <== 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) ||
33e84: e3560000 cmp r6, #0 <== NOT EXECUTED
33e88: 0a000005 beq 33ea4 <rtems_rfs_block_map_grow+0x17c> <== NOT EXECUTED
33e8c: e3560005 cmp r6, #5 <== NOT EXECUTED
33e90: 03590000 cmpeq r9, #0 <== NOT EXECUTED
33e94: 13a03000 movne r3, #0 <== NOT EXECUTED
33e98: 03a03001 moveq r3, #1 <== NOT EXECUTED
33e9c: e58d300c str r3, [sp, #12] <== NOT EXECUTED
33ea0: 1a000013 bne 33ef4 <rtems_rfs_block_map_grow+0x1cc> <== 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,
33ea4: e5952034 ldr r2, [r5, #52] ; 0x34 <== NOT EXECUTED
33ea8: e594c008 ldr ip, [r4, #8] <== NOT EXECUTED
33eac: e2893009 add r3, r9, #9 <== NOT EXECUTED
33eb0: e15c0002 cmp ip, r2 <== NOT EXECUTED
33eb4: 13a0c000 movne ip, #0 <== NOT EXECUTED
33eb8: 03a0c001 moveq ip, #1 <== NOT EXECUTED
33ebc: e0843103 add r3, r4, r3, lsl #2 <== NOT EXECUTED
33ec0: e1a00005 mov r0, r5 <== NOT EXECUTED
33ec4: e1a01004 mov r1, r4 <== NOT EXECUTED
33ec8: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED
33ecc: e58dc000 str ip, [sp] <== NOT EXECUTED
33ed0: ebffff4e bl 33c10 <rtems_rfs_block_map_indirect_alloc> <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
upping);
if (rc > 0)
33ed4: e3500000 cmp r0, #0 <== NOT EXECUTED
33ed8: da000015 ble 33f34 <rtems_rfs_block_map_grow+0x20c> <== NOT EXECUTED
33edc: e1a0a000 mov sl, r0 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
33ee0: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED
33ee4: e1a00005 mov r0, r5 <== NOT EXECUTED
33ee8: e3a01000 mov r1, #0 <== NOT EXECUTED
33eec: eb000cdf bl 37270 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
33ef0: ea000044 b 34008 <rtems_rfs_block_map_grow+0x2e0> <== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
33ef4: e2899009 add r9, r9, #9 <== NOT EXECUTED
33ef8: e7942109 ldr r2, [r4, r9, lsl #2] <== NOT EXECUTED
33efc: e1a00005 mov r0, r5 <== NOT EXECUTED
33f00: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
33f04: e3a03001 mov r3, #1 <== NOT EXECUTED
33f08: eb0001f4 bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
33f0c: e3500000 cmp r0, #0 <== NOT EXECUTED
33f10: da000007 ble 33f34 <rtems_rfs_block_map_grow+0x20c> <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
33f14: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED
33f18: e1a0a000 mov sl, r0 <== NOT EXECUTED
33f1c: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED
33f20: e1a00005 mov r0, r5 <== NOT EXECUTED
33f24: eb000cd1 bl 37270 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
33f28: e1a00005 mov r0, r5 <== NOT EXECUTED
33f2c: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED
33f30: ea000036 b 34010 <rtems_rfs_block_map_grow+0x2e8> <== NOT EXECUTED
return rc;
}
}
rtems_rfs_block_set_number (&map->doubly_buffer,
33f34: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED
33f38: e5dd2017 ldrb r2, [sp, #23] <== NOT EXECUTED
33f3c: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
33f40: e7c32106 strb r2, [r3, r6, lsl #2] <== NOT EXECUTED
33f44: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED
33f48: e5932020 ldr r2, [r3, #32] <== NOT EXECUTED
33f4c: e1dd11b6 ldrh r1, [sp, #22] <== NOT EXECUTED
33f50: e1a03106 lsl r3, r6, #2 <== NOT EXECUTED
33f54: e0822003 add r2, r2, r3 <== NOT EXECUTED
33f58: e5c21001 strb r1, [r2, #1] <== NOT EXECUTED
33f5c: e594204c ldr r2, [r4, #76] ; 0x4c <== NOT EXECUTED
33f60: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED
33f64: e5922020 ldr r2, [r2, #32] <== NOT EXECUTED
33f68: e1a06086 lsl r6, r6, #1 <== NOT EXECUTED
33f6c: e2866001 add r6, r6, #1 <== NOT EXECUTED
33f70: e1a01421 lsr r1, r1, #8 <== NOT EXECUTED
33f74: e7c21086 strb r1, [r2, r6, lsl #1] <== NOT EXECUTED
33f78: e594204c ldr r2, [r4, #76] ; 0x4c <== NOT EXECUTED
33f7c: e5922020 ldr r2, [r2, #32] <== NOT EXECUTED
33f80: e0823003 add r3, r2, r3 <== NOT EXECUTED
33f84: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED
33f88: e3a00001 mov r0, #1 <== NOT EXECUTED
33f8c: e5c32003 strb r2, [r3, #3] <== NOT EXECUTED
33f90: e5c40044 strb r0, [r4, #68] ; 0x44 <== NOT EXECUTED
33f94: ea000020 b 3401c <rtems_rfs_block_map_grow+0x2f4> <== NOT EXECUTED
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
33f98: e2899009 add r9, r9, #9 <== NOT EXECUTED
33f9c: e7942109 ldr r2, [r4, r9, lsl #2] <== NOT EXECUTED
33fa0: e1a00005 mov r0, r5 <== NOT EXECUTED
33fa4: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
33fa8: e3a03001 mov r3, #1 <== NOT EXECUTED
33fac: eb0001cb bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
true);
if (rc > 0)
33fb0: e3500000 cmp r0, #0 <== NOT EXECUTED
33fb4: ca000012 bgt 34004 <rtems_rfs_block_map_grow+0x2dc> <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
33fb8: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED
33fbc: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
33fc0: e0832106 add r2, r3, r6, lsl #2 <== NOT EXECUTED
33fc4: e5d21003 ldrb r1, [r2, #3] <== NOT EXECUTED
33fc8: e7d3c106 ldrb ip, [r3, r6, lsl #2] <== NOT EXECUTED
33fcc: e1a06002 mov r6, r2 <== NOT EXECUTED
33fd0: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED
33fd4: e5d63002 ldrb r3, [r6, #2] <== NOT EXECUTED
33fd8: e181cc0c orr ip, r1, ip, lsl #24 <== NOT EXECUTED
33fdc: e18cc802 orr ip, ip, r2, lsl #16 <== NOT EXECUTED
33fe0: e18cc403 orr ip, ip, r3, lsl #8 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
33fe4: e1a0200c mov r2, ip <== NOT EXECUTED
33fe8: e1a00005 mov r0, r5 <== NOT EXECUTED
33fec: e1a0100b mov r1, fp <== NOT EXECUTED
33ff0: 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,
33ff4: e58dc014 str ip, [sp, #20] <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
33ff8: eb0001b8 bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
singly_block, true);
if (rc > 0)
33ffc: e3500000 cmp r0, #0 <== NOT EXECUTED
34000: da000005 ble 3401c <rtems_rfs_block_map_grow+0x2f4> <== NOT EXECUTED
34004: e1a0a000 mov sl, r0 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
34008: e1a00005 mov r0, r5 <== NOT EXECUTED
3400c: e3a01000 mov r1, #0 <== NOT EXECUTED
34010: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED
34014: eb000c95 bl 37270 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
34018: ea00002b b 340cc <rtems_rfs_block_map_grow+0x3a4> <== NOT EXECUTED
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
3401c: e5943040 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED
34020: e5dd201b ldrb r2, [sp, #27] <== NOT EXECUTED
34024: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
34028: e7c32107 strb r2, [r3, r7, lsl #2] <== NOT EXECUTED
3402c: e5943040 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED
34030: e5932020 ldr r2, [r3, #32] <== NOT EXECUTED
34034: e1dd11ba ldrh r1, [sp, #26] <== NOT EXECUTED
34038: e1a03107 lsl r3, r7, #2 <== NOT EXECUTED
3403c: e0822003 add r2, r2, r3 <== NOT EXECUTED
34040: e5c21001 strb r1, [r2, #1] <== NOT EXECUTED
34044: e5942040 ldr r2, [r4, #64] ; 0x40 <== NOT EXECUTED
34048: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED
3404c: e5922020 ldr r2, [r2, #32] <== NOT EXECUTED
34050: e1a07087 lsl r7, r7, #1 <== NOT EXECUTED
34054: e2877001 add r7, r7, #1 <== NOT EXECUTED
34058: e1a01421 lsr r1, r1, #8 <== NOT EXECUTED
3405c: e7c21087 strb r1, [r2, r7, lsl #1] <== NOT EXECUTED
34060: e5942040 ldr r2, [r4, #64] ; 0x40 <== NOT EXECUTED
34064: e5922020 ldr r2, [r2, #32] <== NOT EXECUTED
34068: e0823003 add r3, r2, r3 <== NOT EXECUTED
3406c: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED
34070: e5c32003 strb r2, [r3, #3] <== NOT EXECUTED
34074: e3a02001 mov r2, #1 <== NOT EXECUTED
34078: e5c42038 strb r2, [r4, #56] ; 0x38 <== NOT EXECUTED
}
map->size.count++;
3407c: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
34080: e2833001 add r3, r3, #1 <== NOT EXECUTED
34084: e5843008 str r3, [r4, #8] <== NOT EXECUTED
map->size.offset = 0;
34088: e3a03000 mov r3, #0 <== NOT EXECUTED
3408c: e584300c str r3, [r4, #12] <== NOT EXECUTED
if (b == 0)
34090: e3580000 cmp r8, #0 <== NOT EXECUTED
*new_block = block;
34094: 059d3018 ldreq r3, [sp, #24] <== NOT EXECUTED
34098: 059d0010 ldreq r0, [sp, #16] <== NOT EXECUTED
3409c: 05803000 streq r3, [r0] <== NOT EXECUTED
map->last_data_block = block;
340a0: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
map->dirty = true;
340a4: e3a02001 mov r2, #1 <== NOT EXECUTED
map->size.count++;
map->size.offset = 0;
if (b == 0)
*new_block = block;
map->last_data_block = block;
340a8: e5843020 str r3, [r4, #32] <== NOT EXECUTED
map->dirty = true;
340ac: e5c42000 strb r2, [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++)
340b0: e2888001 add r8, r8, #1 <== NOT EXECUTED
340b4: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
340b8: e1580003 cmp r8, r3 <== NOT EXECUTED
340bc: 3affff2b bcc 33d70 <rtems_rfs_block_map_grow+0x48> <== NOT EXECUTED
340c0: e3a0a000 mov sl, #0 <== NOT EXECUTED
340c4: ea000000 b 340cc <rtems_rfs_block_map_grow+0x3a4> <== NOT EXECUTED
340c8: e1a0a000 mov sl, r0 <== NOT EXECUTED
map->last_data_block = block;
map->dirty = true;
}
return 0;
}
340cc: e1a0000a mov r0, sl <== NOT EXECUTED
340d0: e28dd01c add sp, sp, #28 <== NOT EXECUTED
340d4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00033c10 <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)
{
33c10: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
33c14: e1a05001 mov r5, r1 <== NOT EXECUTED
33c18: e1a04002 mov r4, r2 <== NOT EXECUTED
33c1c: 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);
33c20: e591101c ldr r1, [r1, #28] <== NOT EXECUTED
33c24: e3a02000 mov r2, #0 <== NOT EXECUTED
33c28: 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)
{
33c2c: e1a06000 mov r6, r0 <== NOT EXECUTED
33c30: 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);
33c34: eb000daa bl 372e4 <rtems_rfs_group_bitmap_alloc> <== NOT EXECUTED
if (rc > 0)
33c38: e250a000 subs sl, r0, #0 <== NOT EXECUTED
33c3c: ca000037 bgt 33d20 <rtems_rfs_block_map_indirect_alloc+0x110><== NOT EXECUTED
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
33c40: e1a00006 mov r0, r6 <== NOT EXECUTED
33c44: e1a01004 mov r1, r4 <== NOT EXECUTED
33c48: e59d2000 ldr r2, [sp] <== NOT EXECUTED
33c4c: e3a03000 mov r3, #0 <== NOT EXECUTED
33c50: eb0002a2 bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
33c54: e250a000 subs sl, r0, #0 <== NOT EXECUTED
33c58: da000004 ble 33c70 <rtems_rfs_block_map_indirect_alloc+0x60><== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
33c5c: e1a00006 mov r0, r6 <== NOT EXECUTED
33c60: e3a01000 mov r1, #0 <== NOT EXECUTED
33c64: e59d2000 ldr r2, [sp] <== NOT EXECUTED
33c68: eb000d80 bl 37270 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
33c6c: ea00002b b 33d20 <rtems_rfs_block_map_indirect_alloc+0x110><== NOT EXECUTED
}
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
33c70: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
33c74: e5962008 ldr r2, [r6, #8] <== NOT EXECUTED
33c78: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED
33c7c: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED
33c80: eb0031d5 bl 403dc <memset> <== NOT EXECUTED
if (upping)
33c84: e3570000 cmp r7, #0 <== NOT EXECUTED
33c88: 0a00001e beq 33d08 <rtems_rfs_block_map_indirect_alloc+0xf8><== NOT EXECUTED
33c8c: e1a03005 mov r3, r5 <== NOT EXECUTED
33c90: e3a02000 mov r2, #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]);
33c94: e3a01001 mov r1, #1 <== NOT EXECUTED
33c98: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
33c9c: e5d3c027 ldrb ip, [r3, #39] ; 0x27 <== NOT EXECUTED
33ca0: e5900020 ldr r0, [r0, #32] <== NOT EXECUTED
33ca4: e7c0c002 strb ip, [r0, r2] <== NOT EXECUTED
33ca8: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
33cac: e5900020 ldr r0, [r0, #32] <== NOT EXECUTED
33cb0: e1d3c2b6 ldrh ip, [r3, #38] ; 0x26 <== NOT EXECUTED
33cb4: e0800002 add r0, r0, r2 <== NOT EXECUTED
33cb8: e5c0c001 strb ip, [r0, #1] <== NOT EXECUTED
33cbc: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
33cc0: e593c024 ldr ip, [r3, #36] ; 0x24 <== NOT EXECUTED
33cc4: e5900020 ldr r0, [r0, #32] <== NOT EXECUTED
33cc8: e1a0c42c lsr ip, ip, #8 <== NOT EXECUTED
33ccc: e0800002 add r0, r0, r2 <== NOT EXECUTED
33cd0: e5c0c002 strb ip, [r0, #2] <== NOT EXECUTED
33cd4: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
33cd8: e5900020 ldr r0, [r0, #32] <== NOT EXECUTED
33cdc: e593c024 ldr ip, [r3, #36] ; 0x24 <== NOT EXECUTED
33ce0: e0800002 add r0, r0, r2 <== NOT EXECUTED
33ce4: e2822004 add r2, r2, #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++)
33ce8: e3520014 cmp r2, #20 <== NOT EXECUTED
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
33cec: e5c0c003 strb ip, [r0, #3] <== NOT EXECUTED
33cf0: e2833004 add r3, r3, #4 <== NOT EXECUTED
33cf4: e5c41000 strb r1, [r4] <== 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++)
33cf8: 1affffe6 bne 33c98 <rtems_rfs_block_map_indirect_alloc+0x88><== NOT EXECUTED
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
33cfc: e2850024 add r0, r5, #36 ; 0x24 <== NOT EXECUTED
33d00: e3a01000 mov r1, #0 <== NOT EXECUTED
33d04: eb0031b4 bl 403dc <memset> <== NOT EXECUTED
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
33d08: 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);
33d0c: e3a02001 mov r2, #1 <== NOT EXECUTED
*block = new_block;
33d10: 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);
33d14: e5c42000 strb r2, [r4] <== NOT EXECUTED
*block = new_block;
map->last_map_block = new_block;
33d18: e585301c str r3, [r5, #28] <== NOT EXECUTED
33d1c: e3a0a000 mov sl, #0 <== NOT EXECUTED
return 0;
}
33d20: e1a0000a mov r0, sl <== NOT EXECUTED
33d24: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
000338a0 <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)
{
338a0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
338a4: 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) ||
338a8: 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)
{
338ac: 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) ||
338b0: 0a000005 beq 338cc <rtems_rfs_block_map_indirect_shrink+0x2c><== NOT EXECUTED
338b4: e35c0005 cmp ip, #5 <== NOT EXECUTED
338b8: 03530000 cmpeq r3, #0 <== NOT EXECUTED
338bc: 13a01000 movne r1, #0 <== NOT EXECUTED
338c0: 03a01001 moveq r1, #1 <== NOT EXECUTED
338c4: 11a00001 movne r0, r1 <== NOT EXECUTED
338c8: 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];
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
338cc: e35c0005 cmp ip, #5 <== NOT EXECUTED
338d0: 03530000 cmpeq r3, #0 <== NOT EXECUTED
338d4: 13a0c000 movne ip, #0 <== NOT EXECUTED
338d8: 03a0c001 moveq ip, #1 <== 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];
338dc: e2833009 add r3, r3, #9 <== NOT EXECUTED
338e0: e7945103 ldr r5, [r4, r3, lsl #2] <== NOT EXECUTED
else
{
/*
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
338e4: 1784c103 strne ip, [r4, r3, lsl #2] <== NOT EXECUTED
if ((index == 0) ||
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
338e8: 1a000010 bne 33930 <rtems_rfs_block_map_indirect_shrink+0x90><== NOT EXECUTED
338ec: e5923008 ldr r3, [r2, #8] <== NOT EXECUTED
338f0: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
338f4: e1a02004 mov r2, r4 <== 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,
338f8: e2831014 add r1, 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);
338fc: e5d3c001 ldrb ip, [r3, #1] <== NOT EXECUTED
33900: e5d3e000 ldrb lr, [r3] <== NOT EXECUTED
33904: e5d36003 ldrb r6, [r3, #3] <== NOT EXECUTED
33908: e1a0c80c lsl ip, ip, #16 <== NOT EXECUTED
3390c: e18ccc0e orr ip, ip, lr, lsl #24 <== NOT EXECUTED
33910: e5d3e002 ldrb lr, [r3, #2] <== NOT EXECUTED
33914: e18cc006 orr ip, ip, r6 <== NOT EXECUTED
33918: e2833004 add r3, r3, #4 <== NOT EXECUTED
3391c: e18cc40e orr ip, ip, lr, lsl #8 <== NOT EXECUTED
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
33920: e1530001 cmp r3, r1 <== NOT EXECUTED
map->blocks[b] = rtems_rfs_block_get_number (buffer, b);
33924: e582c024 str ip, [r2, #36] ; 0x24 <== NOT EXECUTED
33928: e2822004 add r2, r2, #4 <== NOT EXECUTED
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
3392c: 1afffff2 bne 338fc <rtems_rfs_block_map_indirect_shrink+0x5c><== 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);
33930: e3a01000 mov r1, #0 <== NOT EXECUTED
33934: e1a02005 mov r2, r5 <== NOT EXECUTED
33938: eb000e4c bl 37270 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
3393c: e3500000 cmp r0, #0 <== NOT EXECUTED
return rc;
map->last_map_block = block_to_free;
33940: d584501c strle r5, [r4, #28] <== NOT EXECUTED
}
return rc;
}
33944: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
0003380c <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)
{
3380c: e92d4007 push {r0, r1, r2, lr} <== NOT EXECUTED
rtems_rfs_block_pos bpos;
bpos.bno = map->bpos.bno + 1;
33810: e591e010 ldr lr, [r1, #16] <== NOT EXECUTED
bpos.boff = 0;
33814: 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)
{
33818: e1a03002 mov r3, r2 <== NOT EXECUTED
rtems_rfs_block_pos bpos;
bpos.bno = map->bpos.bno + 1;
3381c: e28ee001 add lr, lr, #1 <== NOT EXECUTED
bpos.boff = 0;
bpos.block = 0;
return rtems_rfs_block_map_find (fs, map, &bpos, block);
33820: 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;
33824: e58de000 str lr, [sp] <== NOT EXECUTED
bpos.boff = 0;
bpos.block = 0;
33828: 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;
3382c: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
bpos.block = 0;
return rtems_rfs_block_map_find (fs, map, &bpos, block);
33830: ebffff9f bl 336b4 <rtems_rfs_block_map_find> <== NOT EXECUTED
}
33834: e8bd800e pop {r1, r2, r3, pc} <== NOT EXECUTED
000342a0 <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)
{
342a0: 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;
342a4: e3a05000 mov r5, #0 <== NOT EXECUTED
342a8: e5c25000 strb r5, [r2] <== NOT EXECUTED
map->inode = NULL;
342ac: 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;
342b0: e5825008 str r5, [r2, #8] <== NOT EXECUTED
size->offset = 0;
342b4: 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;
342b8: e5825010 str r5, [r2, #16] <== NOT EXECUTED
bpos->boff = 0;
342bc: e5825014 str r5, [r2, #20] <== NOT EXECUTED
bpos->block = 0;
342c0: 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;
342c4: e5c25038 strb r5, [r2, #56] ; 0x38 <== NOT EXECUTED
handle->bnum = 0;
342c8: e582503c str r5, [r2, #60] ; 0x3c <== NOT EXECUTED
handle->buffer = NULL;
342cc: 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;
342d0: e5c25044 strb r5, [r2, #68] ; 0x44 <== NOT EXECUTED
handle->bnum = 0;
342d4: e5825048 str r5, [r2, #72] ; 0x48 <== NOT EXECUTED
handle->buffer = NULL;
342d8: 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)
{
342dc: e1a04002 mov r4, r2 <== NOT EXECUTED
342e0: e1a07000 mov r7, r0 <== NOT EXECUTED
342e4: 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);
342e8: eb000d8f bl 3792c <rtems_rfs_inode_load> <== NOT EXECUTED
if (rc > 0)
342ec: e2508000 subs r8, r0, #0 <== NOT EXECUTED
342f0: da00000d ble 3432c <rtems_rfs_block_map_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);
342f4: e2841038 add r1, r4, #56 ; 0x38 <== NOT EXECUTED
342f8: e1a00007 mov r0, r7 <== NOT EXECUTED
342fc: eb0000ae bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
34300: e5c45038 strb r5, [r4, #56] ; 0x38 <== NOT EXECUTED
handle->bnum = 0;
34304: e584503c str r5, [r4, #60] ; 0x3c <== NOT EXECUTED
handle->buffer = NULL;
34308: 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);
3430c: e1a00007 mov r0, r7 <== NOT EXECUTED
34310: e2841044 add r1, r4, #68 ; 0x44 <== NOT EXECUTED
34314: eb0000a8 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
handle->buffer = NULL;
34318: 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;
3431c: e5c45044 strb r5, [r4, #68] ; 0x44 <== NOT EXECUTED
handle->bnum = 0;
34320: e5845048 str r5, [r4, #72] ; 0x48 <== NOT EXECUTED
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
rc = rtems_rfs_inode_unload (fs, inode, false);
return rc;
}
34324: e1a00008 mov r0, r8 <== NOT EXECUTED
34328: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
3432c: e596300c ldr r3, [r6, #12] <== NOT EXECUTED
34330: e5846004 str r6, [r4, #4] <== 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,
34334: e2831030 add r1, r3, #48 ; 0x30 <== NOT EXECUTED
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
34338: e1a02004 mov r2, r4 <== NOT EXECUTED
3433c: e283301c add r3, r3, #28 <== NOT EXECUTED
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
34340: e5d30001 ldrb r0, [r3, #1] <== NOT EXECUTED
34344: e5d3c000 ldrb ip, [r3] <== NOT EXECUTED
34348: e5d35003 ldrb r5, [r3, #3] <== NOT EXECUTED
3434c: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
34350: e1800c0c orr r0, r0, ip, lsl #24 <== NOT EXECUTED
34354: e5d3c002 ldrb ip, [r3, #2] <== NOT EXECUTED
34358: e1800005 orr r0, r0, r5 <== NOT EXECUTED
3435c: e2833004 add r3, r3, #4 <== NOT EXECUTED
34360: 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++)
34364: e1530001 cmp r3, r1 <== NOT EXECUTED
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
34368: e5820024 str r0, [r2, #36] ; 0x24 <== NOT EXECUTED
3436c: 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++)
34370: 1afffff2 bne 34340 <rtems_rfs_block_map_open+0xa0> <== 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);
34374: e596300c ldr r3, [r6, #12] <== NOT EXECUTED
34378: e283200c add r2, r3, #12 <== NOT EXECUTED
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
map->size.count = rtems_rfs_inode_get_block_count (inode);
3437c: e5d21003 ldrb r1, [r2, #3] <== NOT EXECUTED
34380: e5d3000c ldrb r0, [r3, #12] <== NOT EXECUTED
34384: e5d2c001 ldrb ip, [r2, #1] <== NOT EXECUTED
34388: e1810c00 orr r0, r1, r0, lsl #24 <== NOT EXECUTED
3438c: e5d21002 ldrb r1, [r2, #2] <== NOT EXECUTED
34390: e180280c orr r2, r0, ip, lsl #16 <== NOT EXECUTED
34394: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED
34398: e5842008 str r2, [r4, #8] <== NOT EXECUTED
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
3439c: e5d3100a ldrb r1, [r3, #10] <== NOT EXECUTED
343a0: e5d3200b ldrb r2, [r3, #11] <== NOT EXECUTED
343a4: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED
343a8: e584200c str r2, [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);
343ac: e2832030 add r2, r3, #48 ; 0x30 <== NOT EXECUTED
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
343b0: e5d21003 ldrb r1, [r2, #3] <== NOT EXECUTED
343b4: e5d30030 ldrb r0, [r3, #48] ; 0x30 <== NOT EXECUTED
343b8: e5d2c001 ldrb ip, [r2, #1] <== NOT EXECUTED
343bc: e1810c00 orr r0, r1, r0, lsl #24 <== NOT EXECUTED
343c0: e5d21002 ldrb r1, [r2, #2] <== NOT EXECUTED
343c4: e180280c orr r2, r0, ip, lsl #16 <== NOT EXECUTED
343c8: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED
343cc: e584201c str r2, [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);
343d0: e2832034 add r2, r3, #52 ; 0x34 <== NOT EXECUTED
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
343d4: e5d30034 ldrb r0, [r3, #52] ; 0x34 <== NOT EXECUTED
343d8: e5d23003 ldrb r3, [r2, #3] <== NOT EXECUTED
343dc: e5d21001 ldrb r1, [r2, #1] <== NOT EXECUTED
343e0: e1833c00 orr r3, r3, r0, lsl #24 <== NOT EXECUTED
343e4: e5d22002 ldrb r2, [r2, #2] <== NOT EXECUTED
343e8: e1833801 orr r3, r3, r1, lsl #16 <== NOT EXECUTED
343ec: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, inode, false);
343f0: e1a00007 mov r0, r7 <== NOT EXECUTED
343f4: e1a01006 mov r1, r6 <== NOT EXECUTED
343f8: 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);
343fc: e5843020 str r3, [r4, #32] <== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, inode, false);
return rc;
}
34400: 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);
34404: ea000d11 b 37850 <rtems_rfs_inode_unload> <== NOT EXECUTED
00033838 <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)
{
33838: e92d43f7 push {r0, r1, r2, r4, r5, r6, r7, r8, r9, lr} <== NOT EXECUTED
rtems_rfs_block_pos bpos;
rtems_rfs_block_copy_bpos (&bpos, &map->bpos);
3383c: 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,
33840: e5905008 ldr r5, [r0, #8] <== NOT EXECUTED
33844: 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)
{
33848: e1a04001 mov r4, r1 <== NOT EXECUTED
3384c: e021ce95 mla r1, r5, lr, ip <== NOT EXECUTED
33850: e0928001 adds r8, r2, r1 <== NOT EXECUTED
33854: e2a39000 adc r9, r3, #0 <== NOT EXECUTED
rtems_rfs_block_pos bpos;
rtems_rfs_block_copy_bpos (&bpos, &map->bpos);
33858: 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)
{
3385c: e1a06000 mov r6, r0 <== NOT EXECUTED
33860: e1a01008 mov r1, r8 <== NOT EXECUTED
33864: e1a02009 mov r2, r9 <== NOT EXECUTED
33868: e1a0300d mov r3, sp <== NOT EXECUTED
rtems_rfs_block_pos bpos;
rtems_rfs_block_copy_bpos (&bpos, &map->bpos);
3386c: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
33870: e58d7008 str r7, [sp, #8] <== NOT EXECUTED
33874: e58de000 str lr, [sp] <== NOT EXECUTED
33878: ebffff30 bl 33540 <rtems_rfs_block_get_bpos> <== NOT EXECUTED
rtems_rfs_block_get_pos (fs, bpos) + offset,
bpos);
bpos->block = 0;
3387c: e3a0c000 mov ip, #0 <== NOT EXECUTED
rtems_rfs_block_add_pos (fs, offset, &bpos);
return rtems_rfs_block_map_find (fs, map, &bpos, block);
33880: e1a00006 mov r0, r6 <== NOT EXECUTED
33884: e1a01004 mov r1, r4 <== NOT EXECUTED
33888: e1a0200d mov r2, sp <== NOT EXECUTED
3388c: 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,
33890: e1a0500d mov r5, sp <== NOT EXECUTED
rtems_rfs_block_get_pos (fs, bpos) + offset,
bpos);
bpos->block = 0;
33894: e58dc008 str ip, [sp, #8] <== NOT EXECUTED
33898: ebffff85 bl 336b4 <rtems_rfs_block_map_find> <== NOT EXECUTED
}
3389c: e8bd83fe pop {r1, r2, r3, r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
00033948 <rtems_rfs_block_map_shrink>:
{
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)
33948: e5913008 ldr r3, [r1, #8] <== NOT EXECUTED
3394c: e3530000 cmp r3, #0 <== NOT EXECUTED
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
33950: e92d4ff7 push {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}<== NOT EXECUTED
33954: e1a04001 mov r4, r1 <== NOT EXECUTED
33958: e1a05000 mov r5, r0 <== 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)
3395c: 0a0000a7 beq 33c00 <rtems_rfs_block_map_shrink+0x2b8> <== NOT EXECUTED
33960: e1520003 cmp r2, r3 <== NOT EXECUTED
33964: 31a09002 movcc r9, r2 <== NOT EXECUTED
33968: 21a09003 movcs r9, r3 <== 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,
3396c: e2812044 add r2, r1, #68 ; 0x44 <== 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,
33970: e281b038 add fp, r1, #56 ; 0x38 <== 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,
33974: e58d2008 str r2, [sp, #8] <== NOT EXECUTED
33978: ea000080 b 33b80 <rtems_rfs_block_map_shrink+0x238> <== NOT EXECUTED
{
rtems_rfs_block_no block;
rtems_rfs_block_no block_to_free;
int rc;
block = map->size.count - 1;
3397c: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
33980: e243a001 sub sl, r3, #1 <== NOT EXECUTED
if (block < RTEMS_RFS_INODE_BLOCKS)
33984: e35a0004 cmp sl, #4 <== NOT EXECUTED
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
33988: 92833008 addls r3, r3, #8 <== NOT EXECUTED
map->blocks[block] = 0;
3398c: 93a02000 movls r2, #0 <== NOT EXECUTED
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
33990: 97948103 ldrls r8, [r4, r3, lsl #2] <== NOT EXECUTED
map->blocks[block] = 0;
33994: 97842103 strls r2, [r4, r3, lsl #2] <== NOT EXECUTED
33998: 9a000069 bls 33b44 <rtems_rfs_block_map_shrink+0x1fc> <== NOT EXECUTED
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
3399c: e5957030 ldr r7, [r5, #48] ; 0x30 <== NOT EXECUTED
339a0: e1a0000a mov r0, sl <== NOT EXECUTED
339a4: e1a01007 mov r1, r7 <== NOT EXECUTED
339a8: eb0085a6 bl 55048 <__umodsi3> <== NOT EXECUTED
singly = block / fs->blocks_per_block;
339ac: e1a01007 mov r1, r7 <== NOT EXECUTED
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
339b0: e1a06000 mov r6, r0 <== NOT EXECUTED
singly = block / fs->blocks_per_block;
339b4: e1a0000a mov r0, sl <== NOT EXECUTED
339b8: eb00850e bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
if (block < fs->block_map_singly_blocks)
339bc: e5953034 ldr r3, [r5, #52] ; 0x34 <== NOT EXECUTED
339c0: e15a0003 cmp sl, 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;
339c4: e1a08000 mov r8, r0 <== NOT EXECUTED
if (block < fs->block_map_singly_blocks)
339c8: 2a00001d bcs 33a44 <rtems_rfs_block_map_shrink+0xfc> <== 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,
339cc: e2803009 add r3, r0, #9 <== NOT EXECUTED
339d0: e7942103 ldr r2, [r4, r3, lsl #2] <== NOT EXECUTED
339d4: e1a00005 mov r0, r5 <== NOT EXECUTED
339d8: e1a0100b mov r1, fp <== NOT EXECUTED
339dc: e3a03001 mov r3, #1 <== NOT EXECUTED
339e0: eb00033e bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
map->blocks[singly], true);
if (rc > 0)
339e4: e3500000 cmp r0, #0 <== NOT EXECUTED
339e8: ca000085 bgt 33c04 <rtems_rfs_block_map_shrink+0x2bc> <== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
339ec: e5943040 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED
339f0: e593c020 ldr ip, [r3, #32] <== NOT EXECUTED
339f4: e08c7106 add r7, ip, r6, lsl #2 <== NOT EXECUTED
339f8: e1a0e007 mov lr, r7 <== NOT EXECUTED
339fc: e5d77002 ldrb r7, [r7, #2] <== NOT EXECUTED
33a00: e58d7004 str r7, [sp, #4] <== NOT EXECUTED
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
33a04: e1a03008 mov r3, r8 <== NOT EXECUTED
33a08: e1a00005 mov r0, r5 <== NOT EXECUTED
33a0c: e1a01004 mov r1, r4 <== NOT EXECUTED
33a10: e1a0200b mov r2, fp <== 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,
33a14: e5dea003 ldrb sl, [lr, #3] <== NOT EXECUTED
33a18: e7dc8106 ldrb r8, [ip, r6, lsl #2] <== NOT EXECUTED
33a1c: e5de7001 ldrb r7, [lr, #1] <== NOT EXECUTED
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
33a20: e58d6000 str r6, [sp] <== NOT EXECUTED
33a24: ebffff9d bl 338a0 <rtems_rfs_block_map_indirect_shrink> <== NOT EXECUTED
singly, direct);
if (rc)
33a28: e3500000 cmp r0, #0 <== NOT EXECUTED
33a2c: 1a000074 bne 33c04 <rtems_rfs_block_map_shrink+0x2bc> <== 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,
33a30: e18a8c08 orr r8, sl, r8, lsl #24 <== NOT EXECUTED
33a34: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
33a38: e1888807 orr r8, r8, r7, lsl #16 <== NOT EXECUTED
33a3c: e1888403 orr r8, r8, r3, lsl #8 <== NOT EXECUTED
33a40: ea00003f b 33b44 <rtems_rfs_block_map_shrink+0x1fc> <== 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)
33a44: e5953038 ldr r3, [r5, #56] ; 0x38 <== NOT EXECUTED
33a48: e15a0003 cmp sl, r3 <== NOT EXECUTED
33a4c: 2a00004d bcs 33b88 <rtems_rfs_block_map_shrink+0x240> <== 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;
33a50: e1a01007 mov r1, r7 <== NOT EXECUTED
33a54: eb0084e7 bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
33a58: e2803009 add r3, r0, #9 <== 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;
33a5c: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
33a60: e7942103 ldr r2, [r4, r3, lsl #2] <== NOT EXECUTED
33a64: e1a00005 mov r0, r5 <== NOT EXECUTED
33a68: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED
33a6c: e3a03001 mov r3, #1 <== NOT EXECUTED
33a70: eb00031a bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
33a74: e3500000 cmp r0, #0 <== NOT EXECUTED
33a78: ca000061 bgt 33c04 <rtems_rfs_block_map_shrink+0x2bc> <== 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;
33a7c: e1a01007 mov r1, r7 <== NOT EXECUTED
33a80: e1a00008 mov r0, r8 <== NOT EXECUTED
33a84: eb00856f bl 55048 <__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,
33a88: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED
33a8c: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
33a90: e0832100 add r2, r3, r0, lsl #2 <== NOT EXECUTED
33a94: e5d21003 ldrb r1, [r2, #3] <== NOT EXECUTED
33a98: e7d3a100 ldrb sl, [r3, r0, lsl #2] <== NOT EXECUTED
33a9c: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED
33aa0: e0833100 add r3, r3, r0, lsl #2 <== NOT EXECUTED
33aa4: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED
33aa8: e181ac0a orr sl, r1, sl, lsl #24 <== NOT EXECUTED
33aac: e18aa802 orr sl, sl, r2, lsl #16 <== NOT EXECUTED
33ab0: e18aa403 orr sl, sl, 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;
33ab4: e1a07000 mov r7, 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,
33ab8: e1a0100b mov r1, fp <== NOT EXECUTED
33abc: e1a00005 mov r0, r5 <== NOT EXECUTED
33ac0: e1a0200a mov r2, sl <== NOT EXECUTED
33ac4: e3a03001 mov r3, #1 <== NOT EXECUTED
33ac8: eb000304 bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
singly, true);
if (rc > 0)
33acc: e3500000 cmp r0, #0 <== NOT EXECUTED
33ad0: ca00004b bgt 33c04 <rtems_rfs_block_map_shrink+0x2bc> <== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
33ad4: e5943040 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED
33ad8: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
33adc: e0832106 add r2, r3, r6, lsl #2 <== NOT EXECUTED
33ae0: e5d21003 ldrb r1, [r2, #3] <== NOT EXECUTED
33ae4: e7d38106 ldrb r8, [r3, r6, lsl #2] <== NOT EXECUTED
33ae8: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED
33aec: e0833106 add r3, r3, r6, lsl #2 <== NOT EXECUTED
33af0: e1818c08 orr r8, r1, r8, lsl #24 <== NOT EXECUTED
33af4: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED
33af8: e1888802 orr r8, r8, r2, lsl #16 <== NOT EXECUTED
direct);
if (direct == 0)
33afc: e3560000 cmp r6, #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,
33b00: e1888403 orr r8, r8, r3, lsl #8 <== NOT EXECUTED
direct);
if (direct == 0)
33b04: 1a00000e bne 33b44 <rtems_rfs_block_map_shrink+0x1fc> <== NOT EXECUTED
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
33b08: e1a01006 mov r1, r6 <== NOT EXECUTED
33b0c: e1a00005 mov r0, r5 <== NOT EXECUTED
33b10: e1a0200a mov r2, sl <== NOT EXECUTED
33b14: eb000dd5 bl 37270 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
33b18: e3500000 cmp r0, #0 <== NOT EXECUTED
33b1c: ca000038 bgt 33c04 <rtems_rfs_block_map_shrink+0x2bc> <== NOT EXECUTED
return rc;
map->last_map_block = singly;
33b20: e584a01c str sl, [r4, #28] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
33b24: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
33b28: e1a00005 mov r0, r5 <== NOT EXECUTED
33b2c: e1a01004 mov r1, r4 <== NOT EXECUTED
33b30: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED
33b34: e58d7000 str r7, [sp] <== NOT EXECUTED
33b38: ebffff58 bl 338a0 <rtems_rfs_block_map_indirect_shrink> <== NOT EXECUTED
doubly, doubly_singly);
if (rc)
33b3c: e3500000 cmp r0, #0 <== NOT EXECUTED
33b40: 1a00002f bne 33c04 <rtems_rfs_block_map_shrink+0x2bc> <== NOT EXECUTED
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
33b44: e1a00005 mov r0, r5 <== NOT EXECUTED
33b48: e3a01000 mov r1, #0 <== NOT EXECUTED
33b4c: e1a02008 mov r2, r8 <== NOT EXECUTED
33b50: eb000dc6 bl 37270 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
33b54: e3500000 cmp r0, #0 <== NOT EXECUTED
33b58: ca000029 bgt 33c04 <rtems_rfs_block_map_shrink+0x2bc> <== NOT EXECUTED
return rc;
map->size.count--;
33b5c: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
33b60: e2433001 sub r3, r3, #1 <== NOT EXECUTED
33b64: e5843008 str r3, [r4, #8] <== NOT EXECUTED
map->size.offset = 0;
33b68: e3a02000 mov r2, #0 <== NOT EXECUTED
map->last_data_block = block_to_free;
map->dirty = true;
33b6c: 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;
33b70: e5848020 str r8, [r4, #32] <== 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;
33b74: e584200c str r2, [r4, #12] <== NOT EXECUTED
map->last_data_block = block_to_free;
map->dirty = true;
33b78: e5c43000 strb r3, [r4] <== NOT EXECUTED
blocks--;
33b7c: e2499001 sub r9, r9, #1 <== NOT EXECUTED
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
33b80: e3590000 cmp r9, #0 <== NOT EXECUTED
33b84: 1affff7c bne 3397c <rtems_rfs_block_map_shrink+0x34> <== NOT EXECUTED
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
33b88: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
33b8c: e3530000 cmp r3, #0 <== NOT EXECUTED
{
map->last_map_block = 0;
map->last_data_block = 0;
33b90: 05843020 streq r3, [r4, #32] <== NOT EXECUTED
blocks--;
}
if (map->size.count == 0)
{
map->last_map_block = 0;
33b94: 0584301c streq r3, [r4, #28] <== NOT EXECUTED
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
33b98: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
33b9c: e3530000 cmp r3, #0 <== NOT EXECUTED
33ba0: 0a000002 beq 33bb0 <rtems_rfs_block_map_shrink+0x268> <== NOT EXECUTED
33ba4: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED
33ba8: e3520000 cmp r2, #0 <== NOT EXECUTED
33bac: 0a000009 beq 33bd8 <rtems_rfs_block_map_shrink+0x290> <== NOT EXECUTED
33bb0: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED
33bb4: e1530002 cmp r3, r2 <== NOT EXECUTED
33bb8: 2a000006 bcs 33bd8 <rtems_rfs_block_map_shrink+0x290> <== NOT EXECUTED
33bbc: e2422001 sub r2, r2, #1 <== NOT EXECUTED
33bc0: e1530002 cmp r3, r2 <== NOT EXECUTED
33bc4: 1a00000d bne 33c00 <rtems_rfs_block_map_shrink+0x2b8> <== NOT EXECUTED
33bc8: e5942014 ldr r2, [r4, #20] <== NOT EXECUTED
33bcc: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
33bd0: e1520003 cmp r2, r3 <== NOT EXECUTED
33bd4: 9a000009 bls 33c00 <rtems_rfs_block_map_shrink+0x2b8> <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
33bd8: e594200c ldr r2, [r4, #12] <== NOT EXECUTED
33bdc: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
33be0: e3520000 cmp r2, #0 <== NOT EXECUTED
33be4: e5843010 str r3, [r4, #16] <== NOT EXECUTED
33be8: e3a00000 mov r0, #0 <== NOT EXECUTED
33bec: 12433001 subne r3, r3, #1 <== NOT EXECUTED
33bf0: e5842014 str r2, [r4, #20] <== NOT EXECUTED
33bf4: e5840018 str r0, [r4, #24] <== NOT EXECUTED
33bf8: 15843010 strne r3, [r4, #16] <== NOT EXECUTED
33bfc: 1a000000 bne 33c04 <rtems_rfs_block_map_shrink+0x2bc> <== NOT EXECUTED
33c00: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
}
33c04: e8bd8ffe pop {r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}<== NOT EXECUTED
0003c95c <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)
3c95c: e31100ff tst r1, #255 ; 0xff <== NOT EXECUTED
}
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
3c960: 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)
3c964: 0a000001 beq 3c970 <rtems_rfs_buffer_bdbuf_release+0x14> <== NOT EXECUTED
sc = rtems_bdbuf_release_modified (buffer);
3c968: ebff1dfc bl 4160 <rtems_bdbuf_release_modified> <== NOT EXECUTED
3c96c: ea000000 b 3c974 <rtems_rfs_buffer_bdbuf_release+0x18> <== NOT EXECUTED
else
sc = rtems_bdbuf_release (buffer);
3c970: ebff1e1c bl 41e8 <rtems_bdbuf_release> <== NOT EXECUTED
#endif
rc = EIO;
}
return rc;
}
3c974: e3500000 cmp r0, #0 <== NOT EXECUTED
3c978: 13a00005 movne r0, #5 <== NOT EXECUTED
3c97c: 03a00000 moveq r0, #0 <== NOT EXECUTED
3c980: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
0003c984 <rtems_rfs_buffer_bdbuf_request>:
rtems_rfs_buffer** buffer)
{
rtems_status_code sc;
int rc = 0;
if (read)
3c984: 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)
{
3c988: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3c98c: e1a02001 mov r2, r1 <== NOT EXECUTED
3c990: e590100c ldr r1, [r0, #12] <== NOT EXECUTED
rtems_status_code sc;
int rc = 0;
if (read)
3c994: 0a000002 beq 3c9a4 <rtems_rfs_buffer_bdbuf_request+0x20> <== NOT EXECUTED
sc = rtems_bdbuf_read (rtems_rfs_fs_device (fs), block, buffer);
3c998: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
3c99c: ebff2251 bl 52e8 <rtems_bdbuf_read> <== NOT EXECUTED
3c9a0: ea000001 b 3c9ac <rtems_rfs_buffer_bdbuf_request+0x28> <== NOT EXECUTED
else
sc = rtems_bdbuf_get (rtems_rfs_fs_device (fs), block, buffer);
3c9a4: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
3c9a8: ebff221b bl 521c <rtems_bdbuf_get> <== NOT EXECUTED
#endif
rc = EIO;
}
return rc;
}
3c9ac: e3500000 cmp r0, #0 <== NOT EXECUTED
3c9b0: 13a00005 movne r0, #5 <== NOT EXECUTED
3c9b4: 03a00000 moveq r0, #0 <== NOT EXECUTED
3c9b8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
0003453c <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));
3453c: e590300c ldr r3, [r0, #12] <== NOT EXECUTED
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
34540: 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));
34544: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
34548: 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));
3454c: ebffffe7 bl 344f0 <rtems_rfs_buffer_setblksize> <== NOT EXECUTED
34550: 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);
34554: e594000c ldr r0, [r4, #12] <== NOT EXECUTED
34558: ebff47cb bl 648c <rtems_disk_release> <== NOT EXECUTED
rc, strerror (rc));
}
#endif
return rc;
}
3455c: e1a00005 mov r0, r5 <== NOT EXECUTED
34560: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
000348e8 <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)
{
348e8: e92d4010 push {r4, lr} <== NOT EXECUTED
348ec: e1a04001 mov r4, r1 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
348f0: ebffff31 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
348f4: e3a00000 mov r0, #0 <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
348f8: 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;
348fc: e5c40000 strb r0, [r4] <== NOT EXECUTED
handle->bnum = 0;
34900: e5840004 str r0, [r4, #4] <== NOT EXECUTED
handle->buffer = NULL;
return 0;
}
34904: e8bd8010 pop {r4, pc} <== NOT EXECUTED
000345bc <rtems_rfs_buffer_handle_release>:
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
345bc: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
345c0: e5916008 ldr r6, [r1, #8] <== NOT EXECUTED
345c4: e3560000 cmp r6, #0 <== NOT EXECUTED
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
345c8: e1a05001 mov r5, r1 <== NOT EXECUTED
345cc: e1a04000 mov r4, r0 <== NOT EXECUTED
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
345d0: 0a000040 beq 346d8 <rtems_rfs_buffer_handle_release+0x11c> <== 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)
345d4: e5963034 ldr r3, [r6, #52] ; 0x34 <== NOT EXECUTED
345d8: e3530000 cmp r3, #0 <== NOT EXECUTED
rtems_rfs_buffer_refs_down (handle);
345dc: c2433001 subgt r3, r3, #1 <== NOT EXECUTED
345e0: c5863034 strgt r3, [r6, #52] ; 0x34 <== NOT EXECUTED
if (rtems_rfs_buffer_refs (handle) == 0)
345e4: e5967034 ldr r7, [r6, #52] ; 0x34 <== NOT EXECUTED
345e8: e3570000 cmp r7, #0 <== NOT EXECUTED
345ec: 13a06000 movne r6, #0 <== NOT EXECUTED
345f0: 1a000036 bne 346d0 <rtems_rfs_buffer_handle_release+0x114> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
345f4: e1a00006 mov r0, r6 <== NOT EXECUTED
345f8: ebff5f90 bl c440 <_Chain_Extract> <== NOT EXECUTED
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
345fc: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED
if (rtems_rfs_fs_no_local_cache (fs))
34600: e5946000 ldr r6, [r4] <== 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--;
34604: e2433001 sub r3, r3, #1 <== NOT EXECUTED
if (rtems_rfs_fs_no_local_cache (fs))
34608: e2166002 ands r6, r6, #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--;
3460c: e584304c str r3, [r4, #76] ; 0x4c <== NOT EXECUTED
if (rtems_rfs_fs_no_local_cache (fs))
34610: 0a000005 beq 3462c <rtems_rfs_buffer_handle_release+0x70> <== NOT EXECUTED
{
handle->buffer->user = (void*) 0;
34614: e5950008 ldr r0, [r5, #8] <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (handle->buffer,
34618: e5d51000 ldrb r1, [r5] <== 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;
3461c: e5807038 str r7, [r0, #56] ; 0x38 <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (handle->buffer,
34620: eb0020cd bl 3c95c <rtems_rfs_buffer_bdbuf_release> <== NOT EXECUTED
34624: e1a06000 mov r6, r0 <== NOT EXECUTED
34628: ea000028 b 346d0 <rtems_rfs_buffer_handle_release+0x114> <== 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 +
3462c: e594205c ldr r2, [r4, #92] ; 0x5c <== NOT EXECUTED
34630: e594306c ldr r3, [r4, #108] ; 0x6c <== NOT EXECUTED
fs->release_modified_count) >= fs->max_held_buffers)
34634: e594103c ldr r1, [r4, #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 +
34638: e0830002 add r0, r3, r2 <== NOT EXECUTED
fs->release_modified_count) >= fs->max_held_buffers)
3463c: e1500001 cmp r0, r1 <== NOT EXECUTED
34640: 3a000012 bcc 34690 <rtems_rfs_buffer_handle_release+0xd4> <== 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)
34644: e1520003 cmp r2, r3 <== NOT EXECUTED
34648: 9a000006 bls 34668 <rtems_rfs_buffer_handle_release+0xac> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
3464c: e2840050 add r0, r4, #80 ; 0x50 <== NOT EXECUTED
34650: ebff5f83 bl c464 <_Chain_Get> <== NOT EXECUTED
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
34654: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED
34658: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3465c: e584305c str r3, [r4, #92] ; 0x5c <== NOT EXECUTED
34660: e1a01006 mov r1, r6 <== NOT EXECUTED
34664: ea000005 b 34680 <rtems_rfs_buffer_handle_release+0xc4> <== NOT EXECUTED
34668: e2840060 add r0, r4, #96 ; 0x60 <== NOT EXECUTED
3466c: ebff5f7c bl c464 <_Chain_Get> <== NOT EXECUTED
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
34670: e594306c ldr r3, [r4, #108] ; 0x6c <== NOT EXECUTED
34674: e2433001 sub r3, r3, #1 <== NOT EXECUTED
34678: e584306c str r3, [r4, #108] ; 0x6c <== NOT EXECUTED
3467c: e3a01001 mov r1, #1 <== NOT EXECUTED
modified = true;
}
buffer->user = (void*) 0;
34680: e3a03000 mov r3, #0 <== NOT EXECUTED
34684: e5803038 str r3, [r0, #56] ; 0x38 <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (buffer, modified);
34688: eb0020b3 bl 3c95c <rtems_rfs_buffer_bdbuf_release> <== NOT EXECUTED
3468c: e1a06000 mov r6, r0 <== NOT EXECUTED
}
if (rtems_rfs_buffer_dirty (handle))
34690: e5d53000 ldrb r3, [r5] <== NOT EXECUTED
34694: e3530000 cmp r3, #0 <== NOT EXECUTED
34698: 0a000006 beq 346b8 <rtems_rfs_buffer_handle_release+0xfc> <== 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 );
3469c: e2840060 add r0, r4, #96 ; 0x60 <== NOT EXECUTED
346a0: e5951008 ldr r1, [r5, #8] <== NOT EXECUTED
346a4: ebff5f5a bl c414 <_Chain_Append> <== NOT EXECUTED
{
rtems_chain_append (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
346a8: e594306c ldr r3, [r4, #108] ; 0x6c <== NOT EXECUTED
346ac: e2833001 add r3, r3, #1 <== NOT EXECUTED
346b0: e584306c str r3, [r4, #108] ; 0x6c <== NOT EXECUTED
346b4: ea000005 b 346d0 <rtems_rfs_buffer_handle_release+0x114> <== NOT EXECUTED
346b8: e2840050 add r0, r4, #80 ; 0x50 <== NOT EXECUTED
346bc: e5951008 ldr r1, [r5, #8] <== NOT EXECUTED
346c0: ebff5f53 bl c414 <_Chain_Append> <== NOT EXECUTED
}
else
{
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
346c4: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED
346c8: e2833001 add r3, r3, #1 <== NOT EXECUTED
346cc: e584305c str r3, [r4, #92] ; 0x5c <== NOT EXECUTED
}
}
}
handle->buffer = NULL;
346d0: e3a03000 mov r3, #0 <== NOT EXECUTED
346d4: e5853008 str r3, [r5, #8] <== NOT EXECUTED
}
return rc;
}
346d8: e1a00006 mov r0, r6 <== NOT EXECUTED
346dc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
000346e0 <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)
{
346e0: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
346e4: 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))
346e8: e5911008 ldr r1, [r1, #8] <== NOT EXECUTED
346ec: 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)
{
346f0: e1a04000 mov r4, r0 <== NOT EXECUTED
346f4: e1a06002 mov r6, r2 <== NOT EXECUTED
346f8: e20380ff and r8, 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))
346fc: 0a00000d beq 34738 <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))
34700: e3520000 cmp r2, #0 <== NOT EXECUTED
34704: 0a000003 beq 34718 <rtems_rfs_buffer_handle_request+0x38> <== NOT EXECUTED
34708: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED
3470c: e1530002 cmp r3, r2 <== NOT EXECUTED
34710: 03a00000 moveq r0, #0 <== NOT EXECUTED
34714: 08bd81f0 popeq {r4, r5, r6, r7, r8, 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);
34718: e1a00004 mov r0, r4 <== NOT EXECUTED
3471c: e1a01005 mov r1, r5 <== NOT EXECUTED
34720: ebffffa5 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rc > 0)
34724: e3500000 cmp r0, #0 <== NOT EXECUTED
34728: c8bd81f0 popgt {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
return rc;
handle->dirty = false;
3472c: e3a03000 mov r3, #0 <== NOT EXECUTED
handle->bnum = 0;
34730: 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;
34734: 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)
34738: e594204c ldr r2, [r4, #76] ; 0x4c <== NOT EXECUTED
3473c: e3520000 cmp r2, #0 <== NOT EXECUTED
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
34740: 12841040 addne r1, r4, #64 ; 0x40 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return the_chain->last;
34744: 15943048 ldrne r3, [r4, #72] ; 0x48 <== 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)
34748: 1a00000d bne 34784 <rtems_rfs_buffer_handle_request+0xa4> <== NOT EXECUTED
3474c: ea000010 b 34794 <rtems_rfs_buffer_handle_request+0xb4> <== 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)
34750: e5930038 ldr r0, [r3, #56] ; 0x38 <== NOT EXECUTED
34754: e1500006 cmp r0, r6 <== 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;
34758: e1a07003 mov r7, r3 <== 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)
3475c: 1a000007 bne 34780 <rtems_rfs_buffer_handle_request+0xa0> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf (": found block=%" PRIuPTR "\n",
((intptr_t)(buffer->user)));
(*count)--;
34760: e2422001 sub r2, r2, #1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
34764: e1a00003 mov r0, r3 <== NOT EXECUTED
34768: e584204c str r2, [r4, #76] ; 0x4c <== NOT EXECUTED
3476c: ebff5f33 bl c440 <_Chain_Extract> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
34770: e3a03000 mov r3, #0 <== NOT EXECUTED
34774: e5873000 str r3, [r7] <== NOT EXECUTED
34778: e5873004 str r3, [r7, #4] <== NOT EXECUTED
3477c: ea000003 b 34790 <rtems_rfs_buffer_handle_request+0xb0> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Previous(
Chain_Node *the_node
)
{
return the_node->previous;
34780: e5933004 ldr r3, [r3, #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))
34784: e1530001 cmp r3, r1 <== NOT EXECUTED
34788: 1afffff0 bne 34750 <rtems_rfs_buffer_handle_request+0x70> <== NOT EXECUTED
3478c: e3a07000 mov r7, #0 <== NOT EXECUTED
if (fs->buffers_count)
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
34790: e5857008 str r7, [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) &&
34794: e5943000 ldr r3, [r4] <== NOT EXECUTED
34798: e3130002 tst r3, #2 <== NOT EXECUTED
3479c: 1a000036 bne 3487c <rtems_rfs_buffer_handle_request+0x19c> <== NOT EXECUTED
!rtems_rfs_buffer_handle_has_block (handle))
347a0: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
347a4: e3530000 cmp r3, #0 <== NOT EXECUTED
347a8: 1a000033 bne 3487c <rtems_rfs_buffer_handle_request+0x19c> <== NOT EXECUTED
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
347ac: e594205c ldr r2, [r4, #92] ; 0x5c <== NOT EXECUTED
347b0: e3520000 cmp r2, #0 <== NOT EXECUTED
handle->buffer = rtems_rfs_scan_chain (&fs->release,
347b4: 12841050 addne r1, r4, #80 ; 0x50 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return the_chain->last;
347b8: 15943058 ldrne r3, [r4, #88] ; 0x58 <== NOT EXECUTED
!rtems_rfs_buffer_handle_has_block (handle))
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
347bc: 1a00000d bne 347f8 <rtems_rfs_buffer_handle_request+0x118> <== NOT EXECUTED
347c0: ea000010 b 34808 <rtems_rfs_buffer_handle_request+0x128> <== 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)
347c4: e5930038 ldr r0, [r3, #56] ; 0x38 <== NOT EXECUTED
347c8: e1500006 cmp r0, r6 <== 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;
347cc: e1a07003 mov r7, r3 <== 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)
347d0: 1a000007 bne 347f4 <rtems_rfs_buffer_handle_request+0x114> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf (": found block=%" PRIuPTR "\n",
((intptr_t)(buffer->user)));
(*count)--;
347d4: e2422001 sub r2, r2, #1 <== NOT EXECUTED
347d8: e1a00003 mov r0, r3 <== NOT EXECUTED
347dc: e584205c str r2, [r4, #92] ; 0x5c <== NOT EXECUTED
347e0: ebff5f16 bl c440 <_Chain_Extract> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
347e4: e3a03000 mov r3, #0 <== NOT EXECUTED
347e8: e5873000 str r3, [r7] <== NOT EXECUTED
347ec: e5873004 str r3, [r7, #4] <== NOT EXECUTED
347f0: ea000003 b 34804 <rtems_rfs_buffer_handle_request+0x124> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Previous(
Chain_Node *the_node
)
{
return the_node->previous;
347f4: e5933004 ldr r3, [r3, #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))
347f8: e1530001 cmp r3, r1 <== NOT EXECUTED
347fc: 1afffff0 bne 347c4 <rtems_rfs_buffer_handle_request+0xe4> <== NOT EXECUTED
34800: e3a07000 mov r7, #0 <== NOT EXECUTED
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
handle->buffer = rtems_rfs_scan_chain (&fs->release,
34804: e5857008 str r7, [r5, #8] <== NOT EXECUTED
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
34808: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
3480c: e3530000 cmp r3, #0 <== NOT EXECUTED
34810: 1a000019 bne 3487c <rtems_rfs_buffer_handle_request+0x19c> <== NOT EXECUTED
fs->release_modified_count)
34814: e594206c ldr r2, [r4, #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) &&
34818: e3520000 cmp r2, #0 <== NOT EXECUTED
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
3481c: 12841060 addne r1, r4, #96 ; 0x60 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return the_chain->last;
34820: 15943068 ldrne r3, [r4, #104] ; 0x68 <== 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) &&
34824: 1a00000d bne 34860 <rtems_rfs_buffer_handle_request+0x180> <== NOT EXECUTED
34828: ea000013 b 3487c <rtems_rfs_buffer_handle_request+0x19c> <== 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)
3482c: e5930038 ldr r0, [r3, #56] ; 0x38 <== NOT EXECUTED
34830: e1500006 cmp r0, r6 <== 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;
34834: e1a07003 mov r7, r3 <== 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)
34838: 1a000007 bne 3485c <rtems_rfs_buffer_handle_request+0x17c> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf (": found block=%" PRIuPTR "\n",
((intptr_t)(buffer->user)));
(*count)--;
3483c: e2422001 sub r2, r2, #1 <== NOT EXECUTED
34840: e1a00003 mov r0, r3 <== NOT EXECUTED
34844: e584206c str r2, [r4, #108] ; 0x6c <== NOT EXECUTED
34848: ebff5efc bl c440 <_Chain_Extract> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
3484c: e3a03000 mov r3, #0 <== NOT EXECUTED
34850: e5873000 str r3, [r7] <== NOT EXECUTED
34854: e5873004 str r3, [r7, #4] <== NOT EXECUTED
34858: ea000003 b 3486c <rtems_rfs_buffer_handle_request+0x18c> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Previous(
Chain_Node *the_node
)
{
return the_node->previous;
3485c: e5933004 ldr r3, [r3, #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))
34860: e1530001 cmp r3, r1 <== NOT EXECUTED
34864: 1afffff0 bne 3482c <rtems_rfs_buffer_handle_request+0x14c> <== NOT EXECUTED
34868: e3a07000 mov r7, #0 <== NOT EXECUTED
&fs->release_modified_count,
block);
/*
* If we found a buffer retain the dirty buffer state.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
3486c: e3570000 cmp r7, #0 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (handle);
34870: 13a03001 movne r3, #1 <== NOT EXECUTED
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
34874: e5857008 str r7, [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);
34878: 15c53000 strbne r3, [r5] <== NOT EXECUTED
}
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
3487c: e5957008 ldr r7, [r5, #8] <== NOT EXECUTED
34880: e3570000 cmp r7, #0 <== NOT EXECUTED
34884: 1a000009 bne 348b0 <rtems_rfs_buffer_handle_request+0x1d0> <== NOT EXECUTED
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
34888: e2853008 add r3, r5, #8 <== NOT EXECUTED
3488c: e1a02008 mov r2, r8 <== NOT EXECUTED
34890: e1a00004 mov r0, r4 <== NOT EXECUTED
34894: e1a01006 mov r1, r6 <== NOT EXECUTED
34898: eb002039 bl 3c984 <rtems_rfs_buffer_bdbuf_request> <== NOT EXECUTED
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
3489c: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
if (rc > 0)
348a0: e3500000 cmp r0, #0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
348a4: e5837000 str r7, [r3] <== NOT EXECUTED
348a8: e5837004 str r7, [r3, #4] <== NOT EXECUTED
348ac: c8bd81f0 popgt {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
348b0: e5951008 ldr r1, [r5, #8] <== NOT EXECUTED
348b4: e5913034 ldr r3, [r1, #52] ; 0x34 <== NOT EXECUTED
348b8: e2833001 add r3, r3, #1 <== NOT EXECUTED
348bc: e5813034 str r3, [r1, #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 );
348c0: e2840040 add r0, r4, #64 ; 0x40 <== NOT EXECUTED
348c4: ebff5ed2 bl c414 <_Chain_Append> <== NOT EXECUTED
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
348c8: e594204c ldr r2, [r4, #76] ; 0x4c <== NOT EXECUTED
handle->buffer->user = (void*) ((intptr_t) block);
348cc: 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++;
348d0: e2822001 add r2, r2, #1 <== NOT EXECUTED
348d4: e584204c str r2, [r4, #76] ; 0x4c <== NOT EXECUTED
handle->buffer->user = (void*) ((intptr_t) block);
348d8: e5836038 str r6, [r3, #56] ; 0x38 <== NOT EXECUTED
handle->bnum = block;
348dc: e5856004 str r6, [r5, #4] <== NOT EXECUTED
348e0: 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;
}
348e4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00034564 <rtems_rfs_buffer_open>:
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
34564: e92d4010 push {r4, lr} <== NOT EXECUTED
34568: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED
3456c: 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)
34570: e1a0100d mov r1, sp <== NOT EXECUTED
34574: ebff522e bl 8e34 <stat> <== NOT EXECUTED
34578: e3500000 cmp r0, #0 <== NOT EXECUTED
3457c: b3a00002 movlt r0, #2 <== NOT EXECUTED
34580: ba00000b blt 345b4 <rtems_rfs_buffer_open+0x50> <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
/*
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
34584: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
34588: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
3458c: e3530a06 cmp r3, #24576 ; 0x6000 <== NOT EXECUTED
34590: 1a000006 bne 345b0 <rtems_rfs_buffer_open+0x4c> <== NOT EXECUTED
}
/*
* Check that device is registred as a block device and lock it.
*/
fs->disk = rtems_disk_obtain (st.st_rdev);
34594: e28d1018 add r1, sp, #24 <== NOT EXECUTED
34598: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
3459c: ebff473e bl 629c <rtems_disk_obtain> <== NOT EXECUTED
if (!fs->disk)
345a0: 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);
345a4: e584000c str r0, [r4, #12] <== NOT EXECUTED
if (!fs->disk)
345a8: 13a00000 movne r0, #0 <== NOT EXECUTED
345ac: 1a000000 bne 345b4 <rtems_rfs_buffer_open+0x50> <== NOT EXECUTED
345b0: 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;
}
345b4: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
345b8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
000344f0 <rtems_rfs_buffer_setblksize>:
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
344f0: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
344f4: e1a05000 mov r5, r0 <== NOT EXECUTED
344f8: e28d4004 add r4, sp, #4 <== NOT EXECUTED
344fc: 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);
34500: ebffffdc bl 34478 <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);
34504: e1a00005 mov r0, r5 <== NOT EXECUTED
34508: ebffffec bl 344c0 <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);
3450c: e595300c ldr r3, [r5, #12] <== NOT EXECUTED
34510: e1a0200d mov r2, sp <== NOT EXECUTED
34514: e1a00003 mov r0, r3 <== NOT EXECUTED
34518: e59f1018 ldr r1, [pc, #24] ; 34538 <rtems_rfs_buffer_setblksize+0x48><== NOT EXECUTED
3451c: e1a0e00f mov lr, pc <== NOT EXECUTED
34520: e593f028 ldr pc, [r3, #40] ; 0x28 <== NOT EXECUTED
if (rc < 0)
34524: e3500000 cmp r0, #0 <== NOT EXECUTED
34528: aa000001 bge 34534 <rtems_rfs_buffer_setblksize+0x44> <== NOT EXECUTED
rc = errno;
3452c: eb002273 bl 3cf00 <__errno> <== NOT EXECUTED
34530: e5900000 ldr r0, [r0] <== NOT EXECUTED
#endif
return rc;
}
34534: e8bd8038 pop {r3, r4, r5, pc} <== NOT EXECUTED
000344c0 <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));
344c0: e590300c ldr r3, [r0, #12] <== NOT EXECUTED
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
344c4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
344c8: 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));
344cc: e8930003 ldm r3, {r0, r1} <== NOT EXECUTED
344d0: ebff3ca2 bl 3760 <rtems_bdbuf_syncdev> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
344d4: e3500000 cmp r0, #0 <== NOT EXECUTED
344d8: 13a05005 movne r5, #5 <== NOT EXECUTED
344dc: 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);
344e0: e594000c ldr r0, [r4, #12] <== NOT EXECUTED
344e4: ebff47e8 bl 648c <rtems_disk_release> <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
344e8: e1a00005 mov r0, r5 <== NOT EXECUTED
344ec: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00034478 <rtems_rfs_buffers_release>:
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
34478: 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,
3447c: e280105c add r1, r0, #92 ; 0x5c <== NOT EXECUTED
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
34480: 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,
34484: e3a02000 mov r2, #0 <== NOT EXECUTED
34488: e2800050 add r0, r0, #80 ; 0x50 <== NOT EXECUTED
3448c: ebffffdd bl 34408 <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,
34490: 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,
34494: 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,
34498: e3a02001 mov r2, #1 <== NOT EXECUTED
3449c: e2840060 add r0, r4, #96 ; 0x60 <== NOT EXECUTED
344a0: ebffffd8 bl 34408 <rtems_rfs_release_chain> <== NOT EXECUTED
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
344a4: e2753001 rsbs r3, r5, #1 <== NOT EXECUTED
344a8: 33a03000 movcc r3, #0 <== NOT EXECUTED
344ac: e3500000 cmp r0, #0 <== NOT EXECUTED
344b0: d3a03000 movle r3, #0 <== NOT EXECUTED
rrc = rc;
return rrc;
}
344b4: e3530000 cmp r3, #0 <== NOT EXECUTED
344b8: 01a00005 moveq r0, r5 <== NOT EXECUTED
344bc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00034fa4 <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)
{
34fa4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
34fa8: e24dd084 sub sp, sp, #132 ; 0x84 <== 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);
34fac: e28d8018 add r8, sp, #24 <== 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)
{
34fb0: e58d2000 str r2, [sp] <== 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);
34fb4: e1a02008 mov r2, r8 <== 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)
{
34fb8: e1a05003 mov r5, r3 <== NOT EXECUTED
34fbc: e1a04000 mov r4, r0 <== NOT EXECUTED
34fc0: e59d60a8 ldr r6, [sp, #168] ; 0xa8 <== 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);
34fc4: ebfffcb5 bl 342a0 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
34fc8: e2509000 subs r9, r0, #0 <== NOT EXECUTED
34fcc: ca000095 bgt 35228 <rtems_rfs_dir_add_entry+0x284> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
34fd0: e3a03000 mov r3, #0 <== 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) <
34fd4: e285000a add r0, r5, #10 <== NOT EXECUTED
34fd8: e58d307c str r3, [sp, #124] ; 0x7c <== NOT EXECUTED
34fdc: e5cd3068 strb r3, [sp, #104] ; 0x68 <== NOT EXECUTED
handle->bnum = 0;
34fe0: e58d306c str r3, [sp, #108] ; 0x6c <== NOT EXECUTED
handle->buffer = NULL;
34fe4: e58d3070 str r3, [sp, #112] ; 0x70 <== 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;
34fe8: e58d3074 str r3, [sp, #116] ; 0x74 <== NOT EXECUTED
bpos->boff = 0;
34fec: e58d3078 str r3, [sp, #120] ; 0x78 <== NOT EXECUTED
34ff0: e58d0014 str r0, [sp, #20] <== 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);
34ff4: e28da080 add sl, sp, #128 ; 0x80 <== 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) <
34ff8: e1a07005 mov r7, r5 <== 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);
34ffc: e1a00004 mov r0, r4 <== NOT EXECUTED
35000: e1a01008 mov r1, r8 <== NOT EXECUTED
35004: e28d2074 add r2, sp, #116 ; 0x74 <== NOT EXECUTED
35008: e1a0300a mov r3, sl <== NOT EXECUTED
3500c: ebfff9a8 bl 336b4 <rtems_rfs_block_map_find> <== NOT EXECUTED
if (rc > 0)
35010: e2509000 subs r9, r0, #0 <== NOT EXECUTED
35014: d3a05001 movle r5, #1 <== NOT EXECUTED
35018: da000009 ble 35044 <rtems_rfs_dir_add_entry+0xa0> <== NOT EXECUTED
{
if (rc != ENXIO)
3501c: e3590006 cmp r9, #6 <== NOT EXECUTED
35020: 1a00007a bne 35210 <rtems_rfs_dir_add_entry+0x26c> <== NOT EXECUTED
}
/*
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
35024: e1a00004 mov r0, r4 <== NOT EXECUTED
35028: e1a01008 mov r1, r8 <== NOT EXECUTED
3502c: e3a02001 mov r2, #1 <== NOT EXECUTED
35030: e1a0300a mov r3, sl <== NOT EXECUTED
35034: ebfffb3b bl 33d28 <rtems_rfs_block_map_grow> <== NOT EXECUTED
if (rc > 0)
35038: e2509000 subs r9, r0, #0 <== NOT EXECUTED
3503c: ca000073 bgt 35210 <rtems_rfs_dir_add_entry+0x26c> <== NOT EXECUTED
35040: e3a05000 mov r5, #0 <== NOT EXECUTED
}
read = false;
}
bpos.bno++;
35044: e59dc074 ldr ip, [sp, #116] ; 0x74 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
35048: e1a00004 mov r0, r4 <== NOT EXECUTED
}
read = false;
}
bpos.bno++;
3504c: e28cc001 add ip, ip, #1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
35050: e28d1068 add r1, sp, #104 ; 0x68 <== NOT EXECUTED
35054: e59d2080 ldr r2, [sp, #128] ; 0x80 <== NOT EXECUTED
35058: e1a03005 mov r3, r5 <== NOT EXECUTED
}
read = false;
}
bpos.bno++;
3505c: e58dc074 str ip, [sp, #116] ; 0x74 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
35060: ebfffd9e bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
35064: e2509000 subs r9, r0, #0 <== NOT EXECUTED
35068: ca000068 bgt 35210 <rtems_rfs_dir_add_entry+0x26c> <== 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);
3506c: e59d3070 ldr r3, [sp, #112] ; 0x70 <== NOT EXECUTED
if (!read)
35070: 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);
35074: e5935020 ldr r5, [r3, #32] <== NOT EXECUTED
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
35078: 01a00005 moveq r0, r5 <== NOT EXECUTED
3507c: 03a010ff moveq r1, #255 ; 0xff <== NOT EXECUTED
35080: 05942008 ldreq r2, [r4, #8] <== NOT EXECUTED
35084: 0b002cd4 bleq 403dc <memset> <== NOT EXECUTED
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
35088: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED
3508c: e241300a sub r3, r1, #10 <== NOT EXECUTED
35090: e3a02000 mov r2, #0 <== NOT EXECUTED
35094: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
35098: ea000058 b 35200 <rtems_rfs_dir_add_entry+0x25c> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
3509c: e5d50008 ldrb r0, [r5, #8] <== NOT EXECUTED
350a0: e5d53009 ldrb r3, [r5, #9] <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
350a4: e59fb188 ldr fp, [pc, #392] ; 35234 <rtems_rfs_dir_add_entry+0x290><== 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);
350a8: e1833400 orr r3, r3, r0, lsl #8 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
350ac: e153000b cmp r3, fp <== 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);
350b0: e285b008 add fp, r5, #8 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
350b4: e5d5e001 ldrb lr, [r5, #1] <== NOT EXECUTED
350b8: e5d50003 ldrb r0, [r5, #3] <== NOT EXECUTED
350bc: e5d5c002 ldrb ip, [r5, #2] <== 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);
350c0: e58db010 str fp, [sp, #16] <== NOT EXECUTED
350c4: e285b009 add fp, r5, #9 <== NOT EXECUTED
350c8: e58db00c str fp, [sp, #12] <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
350cc: e1a09005 mov r9, r5 <== NOT EXECUTED
350d0: e4d9b001 ldrb fp, [r9], #1 <== NOT EXECUTED
350d4: e1800c0b orr r0, r0, fp, lsl #24 <== NOT EXECUTED
350d8: e180080e orr r0, r0, lr, lsl #16 <== NOT EXECUTED
350dc: e285e003 add lr, r5, #3 <== NOT EXECUTED
350e0: e285b002 add fp, r5, #2 <== NOT EXECUTED
350e4: e58de008 str lr, [sp, #8] <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
350e8: 1a00002d bne 351a4 <rtems_rfs_dir_add_entry+0x200> <== NOT EXECUTED
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
350ec: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED
350f0: e0622001 rsb r2, r2, r1 <== NOT EXECUTED
350f4: e1500002 cmp r0, r2 <== NOT EXECUTED
350f8: 2affffbf bcs 34ffc <rtems_rfs_dir_add_entry+0x58> <== NOT EXECUTED
350fc: e1a03007 mov r3, r7 <== NOT EXECUTED
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
35100: e1a01003 mov r1, r3 <== NOT EXECUTED
35104: e59d0000 ldr r0, [sp] <== NOT EXECUTED
35108: e1a07005 mov r7, r5 <== NOT EXECUTED
3510c: e1a05003 mov r5, r3 <== NOT EXECUTED
35110: eb001e29 bl 3c9bc <rtems_rfs_dir_hash> <== NOT EXECUTED
rtems_rfs_dir_set_entry_hash (entry, hash);
35114: e1a0c820 lsr ip, r0, #16 <== NOT EXECUTED
35118: e5c7c005 strb ip, [r7, #5] <== NOT EXECUTED
3511c: e5c70007 strb r0, [r7, #7] <== NOT EXECUTED
rtems_rfs_dir_set_entry_ino (entry, ino);
35120: e1a03007 mov r3, r7 <== NOT EXECUTED
35124: e1a0c826 lsr ip, r6, #16 <== 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);
35128: e1a0ec20 lsr lr, r0, #24 <== NOT EXECUTED
3512c: e1a01420 lsr r1, r0, #8 <== NOT EXECUTED
rtems_rfs_dir_set_entry_ino (entry, ino);
35130: e1a02c26 lsr r2, r6, #24 <== NOT EXECUTED
35134: e1a00426 lsr r0, r6, #8 <== 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);
35138: e5c71006 strb r1, [r7, #6] <== NOT EXECUTED
3513c: e5c7e004 strb lr, [r7, #4] <== NOT EXECUTED
rtems_rfs_dir_set_entry_ino (entry, ino);
35140: e4c3200a strb r2, [r3], #10 <== NOT EXECUTED
35144: e5c9c000 strb ip, [r9] <== NOT EXECUTED
35148: e5cb0000 strb r0, [fp] <== NOT EXECUTED
3514c: e59db008 ldr fp, [sp, #8] <== NOT EXECUTED
35150: e5cb6000 strb r6, [fp] <== NOT EXECUTED
rtems_rfs_dir_set_entry_length (entry,
35154: e59de010 ldr lr, [sp, #16] <== NOT EXECUTED
35158: e285200a add r2, r5, #10 <== NOT EXECUTED
3515c: e1a01422 lsr r1, r2, #8 <== NOT EXECUTED
35160: e5ce1000 strb r1, [lr] <== NOT EXECUTED
35164: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED
35168: e5c02000 strb r2, [r0] <== NOT EXECUTED
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
3516c: e59d1000 ldr r1, [sp] <== NOT EXECUTED
35170: e1a02005 mov r2, r5 <== NOT EXECUTED
35174: e1a00003 mov r0, r3 <== NOT EXECUTED
35178: eb002c10 bl 401c0 <memcpy> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&buffer);
3517c: e28d1084 add r1, sp, #132 ; 0x84 <== NOT EXECUTED
35180: e3a03001 mov r3, #1 <== NOT EXECUTED
35184: e561301c strb r3, [r1, #-28]! <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
35188: e1a00004 mov r0, r4 <== NOT EXECUTED
3518c: ebfffdd5 bl 348e8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
35190: e1a00004 mov r0, r4 <== NOT EXECUTED
35194: e28d1018 add r1, sp, #24 <== NOT EXECUTED
35198: ebfffbce bl 340d8 <rtems_rfs_block_map_close> <== NOT EXECUTED
3519c: e3a09000 mov r9, #0 <== NOT EXECUTED
return 0;
351a0: ea000020 b 35228 <rtems_rfs_dir_add_entry+0x284> <== NOT EXECUTED
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
351a4: e353000a cmp r3, #10 <== NOT EXECUTED
351a8: da00000a ble 351d8 <rtems_rfs_dir_add_entry+0x234> <== NOT EXECUTED
351ac: e190040c orrs r0, r0, ip, lsl #8 <== NOT EXECUTED
351b0: e594e018 ldr lr, [r4, #24] <== NOT EXECUTED
351b4: 13a0c000 movne ip, #0 <== NOT EXECUTED
351b8: 03a0c001 moveq ip, #1 <== NOT EXECUTED
351bc: e153000e cmp r3, lr <== NOT EXECUTED
351c0: 238cc001 orrcs ip, ip, #1 <== NOT EXECUTED
351c4: e35c0000 cmp ip, #0 <== NOT EXECUTED
351c8: 1a000002 bne 351d8 <rtems_rfs_dir_add_entry+0x234> <== NOT EXECUTED
351cc: e594c010 ldr ip, [r4, #16] <== NOT EXECUTED
351d0: e150000c cmp r0, ip <== NOT EXECUTED
351d4: 9a000007 bls 351f8 <rtems_rfs_dir_add_entry+0x254> <== 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);
351d8: e28d1068 add r1, sp, #104 ; 0x68 <== NOT EXECUTED
351dc: e1a00004 mov r0, r4 <== NOT EXECUTED
351e0: ebfffdc0 bl 348e8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
351e4: e1a00004 mov r0, r4 <== NOT EXECUTED
351e8: e28d1018 add r1, sp, #24 <== NOT EXECUTED
351ec: ebfffbb9 bl 340d8 <rtems_rfs_block_map_close> <== NOT EXECUTED
351f0: e3a09005 mov r9, #5 <== NOT EXECUTED
return EIO;
351f4: ea00000b b 35228 <rtems_rfs_dir_add_entry+0x284> <== NOT EXECUTED
}
entry += elength;
offset += elength;
351f8: e0822003 add r2, r2, r3 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return EIO;
}
entry += elength;
351fc: e0855003 add r5, r5, r3 <== 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))
35200: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
35204: e1520003 cmp r2, r3 <== NOT EXECUTED
35208: 2affff7b bcs 34ffc <rtems_rfs_dir_add_entry+0x58> <== NOT EXECUTED
3520c: eaffffa2 b 3509c <rtems_rfs_dir_add_entry+0xf8> <== NOT EXECUTED
entry += elength;
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
35210: e28d1068 add r1, sp, #104 ; 0x68 <== NOT EXECUTED
35214: e1a00004 mov r0, r4 <== NOT EXECUTED
35218: ebfffdb2 bl 348e8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
3521c: e1a00004 mov r0, r4 <== NOT EXECUTED
35220: e28d1018 add r1, sp, #24 <== NOT EXECUTED
35224: ebfffbab bl 340d8 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
}
35228: e1a00009 mov r0, r9 <== NOT EXECUTED
3522c: e28dd084 add sp, sp, #132 ; 0x84 <== NOT EXECUTED
35230: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00034d3c <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)
{
34d3c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
34d40: e24dd074 sub sp, sp, #116 ; 0x74 <== 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);
34d44: e28d7014 add r7, sp, #20 <== 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)
{
34d48: e58d2010 str r2, [sp, #16] <== 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);
34d4c: e1a02007 mov r2, r7 <== 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)
{
34d50: e1a08003 mov r8, r3 <== NOT EXECUTED
34d54: e1a05000 mov r5, 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);
34d58: ebfffd50 bl 342a0 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
34d5c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
34d60: ca00008b bgt 34f94 <rtems_rfs_dir_del_entry+0x258> <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
34d64: e3a06000 mov r6, #0 <== NOT EXECUTED
34d68: e28da070 add sl, sp, #112 ; 0x70 <== NOT EXECUTED
34d6c: e1a00005 mov r0, r5 <== NOT EXECUTED
34d70: e1a01007 mov r1, r7 <== NOT EXECUTED
34d74: e1a02008 mov r2, r8 <== NOT EXECUTED
34d78: e1a03006 mov r3, r6 <== NOT EXECUTED
34d7c: e58da000 str sl, [sp] <== NOT EXECUTED
34d80: ebfffaac bl 33838 <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
34d84: e2504000 subs r4, r0, #0 <== NOT EXECUTED
34d88: da000004 ble 34da0 <rtems_rfs_dir_del_entry+0x64> <== NOT EXECUTED
{
if (rc == ENXIO)
34d8c: e3540006 cmp r4, #6 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
34d90: e1a00005 mov r0, r5 <== NOT EXECUTED
34d94: e1a01007 mov r1, r7 <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
if (rc > 0)
{
if (rc == ENXIO)
34d98: 03a04002 moveq r4, #2 <== NOT EXECUTED
34d9c: ea00007b b 34f90 <rtems_rfs_dir_del_entry+0x254> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
34da0: e5cd6064 strb r6, [sp, #100] ; 0x64 <== NOT EXECUTED
handle->bnum = 0;
34da4: e58d6068 str r6, [sp, #104] ; 0x68 <== NOT EXECUTED
handle->buffer = NULL;
34da8: e58d606c str r6, [sp, #108] ; 0x6c <== NOT EXECUTED
}
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
34dac: e2789001 rsbs r9, r8, #1 <== NOT EXECUTED
34db0: 33a09000 movcc r9, #0 <== NOT EXECUTED
34db4: e1a04006 mov r4, r6 <== NOT EXECUTED
while (rc == 0)
34db8: ea00006d b 34f74 <rtems_rfs_dir_del_entry+0x238> <== NOT EXECUTED
{
uint8_t* entry;
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
34dbc: e1a00005 mov r0, r5 <== NOT EXECUTED
34dc0: e28d1064 add r1, sp, #100 ; 0x64 <== NOT EXECUTED
34dc4: e59d2070 ldr r2, [sp, #112] ; 0x70 <== NOT EXECUTED
34dc8: e3a03001 mov r3, #1 <== NOT EXECUTED
34dcc: ebfffe43 bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
34dd0: e250b000 subs fp, r0, #0 <== NOT EXECUTED
34dd4: c1a0400b movgt r4, fp <== NOT EXECUTED
34dd8: ca000067 bgt 34f7c <rtems_rfs_dir_del_entry+0x240> <== 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)
34ddc: e3590000 cmp r9, #0 <== NOT EXECUTED
34de0: 11a00004 movne r0, r4 <== NOT EXECUTED
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
34de4: 01a00008 moveq r0, r8 <== NOT EXECUTED
34de8: 05951008 ldreq r1, [r5, #8] <== NOT EXECUTED
34dec: 0b008095 bleq 55048 <__umodsi3> <== NOT EXECUTED
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
34df0: e59d306c ldr r3, [sp, #108] ; 0x6c <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
34df4: e5952008 ldr r2, [r5, #8] <== NOT EXECUTED
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
34df8: e5936020 ldr r6, [r3, #32] <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
34dfc: e242e00a sub lr, r2, #10 <== NOT EXECUTED
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
34e00: e0866000 add r6, r6, r0 <== NOT EXECUTED
34e04: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
34e08: ea00004a b 34f38 <rtems_rfs_dir_del_entry+0x1fc> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
34e0c: e5d63009 ldrb r3, [r6, #9] <== NOT EXECUTED
34e10: e5d67008 ldrb r7, [r6, #8] <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
34e14: e5d6c000 ldrb ip, [r6] <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
34e18: e59f2180 ldr r2, [pc, #384] ; 34fa0 <rtems_rfs_dir_del_entry+0x264><== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
34e1c: e5d61003 ldrb r1, [r6, #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);
34e20: e1837407 orr r7, r3, r7, lsl #8 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
34e24: e5d63001 ldrb r3, [r6, #1] <== NOT EXECUTED
34e28: e1811c0c orr r1, r1, ip, lsl #24 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
34e2c: e1570002 cmp r7, r2 <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
34e30: e1811803 orr r1, r1, r3, lsl #16 <== NOT EXECUTED
34e34: e5d6a002 ldrb sl, [r6, #2] <== 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);
34e38: e2863008 add r3, r6, #8 <== NOT EXECUTED
34e3c: e286c009 add ip, r6, #9 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
34e40: 0a00003e beq 34f40 <rtems_rfs_dir_del_entry+0x204> <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
34e44: e357000a cmp r7, #10 <== NOT EXECUTED
34e48: da000047 ble 34f6c <rtems_rfs_dir_del_entry+0x230> <== NOT EXECUTED
34e4c: e191140a orrs r1, r1, sl, lsl #8 <== NOT EXECUTED
34e50: e5952018 ldr r2, [r5, #24] <== NOT EXECUTED
34e54: 13a0a000 movne sl, #0 <== NOT EXECUTED
34e58: 03a0a001 moveq sl, #1 <== NOT EXECUTED
34e5c: e1570002 cmp r7, r2 <== NOT EXECUTED
34e60: 238aa001 orrcs sl, sl, #1 <== NOT EXECUTED
34e64: e35a0000 cmp sl, #0 <== NOT EXECUTED
34e68: 1a00003f bne 34f6c <rtems_rfs_dir_del_entry+0x230> <== NOT EXECUTED
34e6c: e595a010 ldr sl, [r5, #16] <== NOT EXECUTED
34e70: e151000a cmp r1, sl <== NOT EXECUTED
34e74: 8a00003c bhi 34f6c <rtems_rfs_dir_del_entry+0x230> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
rc = EIO;
break;
}
if (ino == rtems_rfs_dir_entry_ino (entry))
34e78: e59da010 ldr sl, [sp, #16] <== NOT EXECUTED
34e7c: e15a0001 cmp sl, r1 <== NOT EXECUTED
34e80: 1a000028 bne 34f28 <rtems_rfs_dir_del_entry+0x1ec> <== NOT EXECUTED
34e84: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
34e88: e0808007 add r8, r0, r7 <== NOT EXECUTED
34e8c: e0688002 rsb r8, r8, r2 <== NOT EXECUTED
34e90: e1a0a000 mov sl, r0 <== NOT EXECUTED
memmove (entry, entry + elength, remaining);
34e94: e0861007 add r1, r6, r7 <== NOT EXECUTED
34e98: e1a02008 mov r2, r8 <== NOT EXECUTED
34e9c: e1a00006 mov r0, r6 <== NOT EXECUTED
34ea0: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
34ea4: e58dc00c str ip, [sp, #12] <== NOT EXECUTED
34ea8: eb002d00 bl 402b0 <memmove> <== NOT EXECUTED
memset (entry + remaining, 0xff, elength);
34eac: e1a02007 mov r2, r7 <== NOT EXECUTED
34eb0: e0860008 add r0, r6, r8 <== NOT EXECUTED
34eb4: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED
34eb8: eb002d47 bl 403dc <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);
34ebc: e28d3008 add r3, sp, #8 <== NOT EXECUTED
34ec0: e8931008 ldm r3, {r3, ip} <== NOT EXECUTED
34ec4: e5d32000 ldrb r2, [r3] <== NOT EXECUTED
34ec8: e5dc3000 ldrb r3, [ip] <== NOT EXECUTED
34ecc: e1832402 orr r2, r3, r2, lsl #8 <== NOT EXECUTED
34ed0: e59f30c8 ldr r3, [pc, #200] ; 34fa0 <rtems_rfs_dir_del_entry+0x264><== NOT EXECUTED
34ed4: e1520003 cmp r2, r3 <== NOT EXECUTED
34ed8: 035a0000 cmpeq sl, #0 <== NOT EXECUTED
34edc: 1a00000d bne 34f18 <rtems_rfs_dir_del_entry+0x1dc> <== 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))
34ee0: e59d3024 ldr r3, [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) &&
34ee4: e3530000 cmp r3, #0 <== NOT EXECUTED
34ee8: 1a000002 bne 34ef8 <rtems_rfs_dir_del_entry+0x1bc> <== NOT EXECUTED
34eec: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED
34ef0: e3520000 cmp r2, #0 <== NOT EXECUTED
34ef4: 0a000003 beq 34f08 <rtems_rfs_dir_del_entry+0x1cc> <== NOT EXECUTED
34ef8: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED
34efc: e2422001 sub r2, r2, #1 <== NOT EXECUTED
34f00: e1530002 cmp r3, r2 <== NOT EXECUTED
34f04: 1a000003 bne 34f18 <rtems_rfs_dir_del_entry+0x1dc> <== NOT EXECUTED
(eoffset == 0) && rtems_rfs_block_map_last (&map))
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
34f08: e1a00005 mov r0, r5 <== NOT EXECUTED
34f0c: e28d1014 add r1, sp, #20 <== NOT EXECUTED
34f10: e3a02001 mov r2, #1 <== NOT EXECUTED
34f14: ebfffa8b bl 33948 <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);
34f18: e28d1074 add r1, sp, #116 ; 0x74 <== NOT EXECUTED
34f1c: e3a03001 mov r3, #1 <== NOT EXECUTED
34f20: e5613010 strb r3, [r1, #-16]! <== NOT EXECUTED
34f24: ea000015 b 34f80 <rtems_rfs_dir_del_entry+0x244> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return 0;
}
if (!search)
34f28: e3590000 cmp r9, #0 <== NOT EXECUTED
34f2c: 0a00000e beq 34f6c <rtems_rfs_dir_del_entry+0x230> <== NOT EXECUTED
rc = EIO;
break;
}
entry += elength;
eoffset += elength;
34f30: e0800007 add r0, r0, r7 <== NOT EXECUTED
{
rc = EIO;
break;
}
entry += elength;
34f34: e0866007 add r6, r6, r7 <== 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))
34f38: e150000e cmp r0, lr <== NOT EXECUTED
34f3c: 3affffb2 bcc 34e0c <rtems_rfs_dir_del_entry+0xd0> <== NOT EXECUTED
entry += elength;
eoffset += elength;
}
if (rc == 0)
34f40: e35b0000 cmp fp, #0 <== NOT EXECUTED
34f44: 1a000009 bne 34f70 <rtems_rfs_dir_del_entry+0x234> <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
34f48: e1a00005 mov r0, r5 <== NOT EXECUTED
34f4c: e28d1014 add r1, sp, #20 <== NOT EXECUTED
34f50: e28d2070 add r2, sp, #112 ; 0x70 <== NOT EXECUTED
34f54: ebfffa2c bl 3380c <rtems_rfs_block_map_next_block> <== NOT EXECUTED
if (rc == ENXIO)
34f58: e3500006 cmp r0, #6 <== NOT EXECUTED
eoffset += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
34f5c: e1a04000 mov r4, r0 <== NOT EXECUTED
if (rc == ENXIO)
34f60: 1a000003 bne 34f74 <rtems_rfs_dir_del_entry+0x238> <== NOT EXECUTED
34f64: e3a04002 mov r4, #2 <== NOT EXECUTED
34f68: ea000003 b 34f7c <rtems_rfs_dir_del_entry+0x240> <== NOT EXECUTED
34f6c: e3a0b005 mov fp, #5 <== NOT EXECUTED
34f70: e1a0400b mov r4, fp <== NOT EXECUTED
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
34f74: e3540000 cmp r4, #0 <== NOT EXECUTED
34f78: 0affff8f beq 34dbc <rtems_rfs_dir_del_entry+0x80> <== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
34f7c: e28d1064 add r1, sp, #100 ; 0x64 <== NOT EXECUTED
34f80: e1a00005 mov r0, r5 <== NOT EXECUTED
34f84: ebfffe57 bl 348e8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
34f88: e1a00005 mov r0, r5 <== NOT EXECUTED
34f8c: e28d1014 add r1, sp, #20 <== NOT EXECUTED
34f90: ebfffc50 bl 340d8 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
}
34f94: e1a00004 mov r0, r4 <== NOT EXECUTED
34f98: e28dd074 add sp, sp, #116 ; 0x74 <== NOT EXECUTED
34f9c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00034908 <rtems_rfs_dir_empty>:
}
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
34908: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3490c: 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);
34910: e28d6004 add r6, sp, #4 <== NOT EXECUTED
34914: e1a02006 mov r2, r6 <== NOT EXECUTED
}
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
34918: 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);
3491c: ebfffe5f bl 342a0 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
34920: e250a000 subs sl, r0, #0 <== NOT EXECUTED
34924: ca000055 bgt 34a80 <rtems_rfs_dir_empty+0x178> <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
34928: e1a01006 mov r1, r6 <== NOT EXECUTED
3492c: e28d5060 add r5, sp, #96 ; 0x60 <== NOT EXECUTED
34930: e1a00004 mov r0, r4 <== NOT EXECUTED
34934: e3a02000 mov r2, #0 <== NOT EXECUTED
34938: e3a03000 mov r3, #0 <== NOT EXECUTED
3493c: e58d5000 str r5, [sp] <== NOT EXECUTED
34940: ebfffbbc bl 33838 <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
34944: e250a000 subs sl, r0, #0 <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
34948: c1a00004 movgt r0, r4 <== NOT EXECUTED
3494c: c1a01006 movgt r1, r6 <== 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);
if (rc > 0)
34950: ca000049 bgt 34a7c <rtems_rfs_dir_empty+0x174> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
34954: e3a03000 mov r3, #0 <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
34958: 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;
3495c: e5cd3054 strb r3, [sp, #84] ; 0x54 <== NOT EXECUTED
handle->bnum = 0;
34960: e58d3058 str r3, [sp, #88] ; 0x58 <== 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)
34964: e59f7120 ldr r7, [pc, #288] ; 34a8c <rtems_rfs_dir_empty+0x184><== NOT EXECUTED
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
34968: e28d8054 add r8, sp, #84 ; 0x54 <== NOT EXECUTED
3496c: e1a00004 mov r0, r4 <== NOT EXECUTED
34970: e1a01008 mov r1, r8 <== NOT EXECUTED
34974: e59d2060 ldr r2, [sp, #96] ; 0x60 <== NOT EXECUTED
34978: e3a03001 mov r3, #1 <== NOT EXECUTED
3497c: ebffff57 bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
34980: e250a000 subs sl, r0, #0 <== NOT EXECUTED
34984: ca000037 bgt 34a68 <rtems_rfs_dir_empty+0x160> <== NOT EXECUTED
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
34988: e594e008 ldr lr, [r4, #8] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
3498c: e59d305c ldr r3, [sp, #92] ; 0x5c <== NOT EXECUTED
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
34990: e24ee00a sub lr, lr, #10 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
34994: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
34998: e3a01000 mov r1, #0 <== NOT EXECUTED
3499c: ea000024 b 34a34 <rtems_rfs_dir_empty+0x12c> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
349a0: e5d30008 ldrb r0, [r3, #8] <== NOT EXECUTED
349a4: e5d32009 ldrb r2, [r3, #9] <== NOT EXECUTED
349a8: e1822400 orr r2, r2, r0, lsl #8 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
349ac: e1520007 cmp r2, r7 <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
349b0: e5d3b000 ldrb fp, [r3] <== NOT EXECUTED
349b4: e5d39001 ldrb r9, [r3, #1] <== NOT EXECUTED
349b8: e5d3c002 ldrb ip, [r3, #2] <== NOT EXECUTED
349bc: e5d30003 ldrb r0, [r3, #3] <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
349c0: 0a00001d beq 34a3c <rtems_rfs_dir_empty+0x134> <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
349c4: e352000a cmp r2, #10 <== NOT EXECUTED
349c8: da00001b ble 34a3c <rtems_rfs_dir_empty+0x134> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
349cc: e1800c0b orr r0, r0, fp, lsl #24 <== NOT EXECUTED
349d0: e1800809 orr r0, r0, r9, lsl #16 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
349d4: e190040c orrs r0, r0, ip, lsl #8 <== NOT EXECUTED
349d8: e5949018 ldr r9, [r4, #24] <== NOT EXECUTED
349dc: 13a0c000 movne ip, #0 <== NOT EXECUTED
349e0: 03a0c001 moveq ip, #1 <== NOT EXECUTED
349e4: e1520009 cmp r2, r9 <== NOT EXECUTED
349e8: 238cc001 orrcs ip, ip, #1 <== NOT EXECUTED
349ec: e35c0000 cmp ip, #0 <== NOT EXECUTED
349f0: 1a000011 bne 34a3c <rtems_rfs_dir_empty+0x134> <== NOT EXECUTED
349f4: e5949010 ldr r9, [r4, #16] <== NOT EXECUTED
349f8: e1500009 cmp r0, r9 <== NOT EXECUTED
349fc: 8a00000e bhi 34a3c <rtems_rfs_dir_empty+0x134> <== NOT EXECUTED
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
34a00: e352000b cmp r2, #11 <== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
34a04: 05d3000a ldrbeq r0, [r3, #10] <== NOT EXECUTED
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
34a08: 0a000005 beq 34a24 <rtems_rfs_dir_empty+0x11c> <== NOT EXECUTED
34a0c: e352000c cmp r2, #12 <== NOT EXECUTED
34a10: 1a000012 bne 34a60 <rtems_rfs_dir_empty+0x158> <== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
34a14: e5d3000a ldrb r0, [r3, #10] <== NOT EXECUTED
34a18: e350002e cmp r0, #46 ; 0x2e <== NOT EXECUTED
34a1c: 1a00000f bne 34a60 <rtems_rfs_dir_empty+0x158> <== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE + 1] != '.')))
34a20: e5d3000b ldrb r0, [r3, #11] <== NOT EXECUTED
34a24: e350002e cmp r0, #46 ; 0x2e <== NOT EXECUTED
34a28: 1a00000c bne 34a60 <rtems_rfs_dir_empty+0x158> <== NOT EXECUTED
empty = false;
break;
}
entry += elength;
offset += elength;
34a2c: e0811002 add r1, r1, r2 <== NOT EXECUTED
{
empty = false;
break;
}
entry += elength;
34a30: e0833002 add r3, r3, 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))
34a34: e151000e cmp r1, lr <== NOT EXECUTED
34a38: 3affffd8 bcc 349a0 <rtems_rfs_dir_empty+0x98> <== NOT EXECUTED
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
34a3c: e1a00004 mov r0, r4 <== NOT EXECUTED
34a40: e1a01006 mov r1, r6 <== NOT EXECUTED
34a44: e1a02005 mov r2, r5 <== NOT EXECUTED
34a48: ebfffb6f bl 3380c <rtems_rfs_block_map_next_block> <== NOT EXECUTED
if (rc > 0)
34a4c: e250a000 subs sl, r0, #0 <== NOT EXECUTED
34a50: daffffc5 ble 3496c <rtems_rfs_dir_empty+0x64> <== NOT EXECUTED
{
if (rc == ENXIO)
34a54: e35a0006 cmp sl, #6 <== NOT EXECUTED
34a58: 03a0a000 moveq sl, #0 <== NOT EXECUTED
34a5c: ea000001 b 34a68 <rtems_rfs_dir_empty+0x160> <== NOT EXECUTED
break;
}
}
}
if ((rc == 0) && !empty)
34a60: e35a0000 cmp sl, #0 <== NOT EXECUTED
34a64: 03a0a05a moveq sl, #90 ; 0x5a <== NOT EXECUTED
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
34a68: e28d1054 add r1, sp, #84 ; 0x54 <== NOT EXECUTED
34a6c: e1a00004 mov r0, r4 <== NOT EXECUTED
34a70: ebffff9c bl 348e8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
34a74: e1a00004 mov r0, r4 <== NOT EXECUTED
34a78: e28d1004 add r1, sp, #4 <== NOT EXECUTED
34a7c: ebfffd95 bl 340d8 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
}
34a80: e1a0000a mov r0, sl <== NOT EXECUTED
34a84: e28dd064 add sp, sp, #100 ; 0x64 <== NOT EXECUTED
34a88: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0003c9bc <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;
3c9bc: e59f31b8 ldr r3, [pc, #440] ; 3cb7c <rtems_rfs_dir_hash+0x1c0><== NOT EXECUTED
3c9c0: e0813003 add r3, r1, r3 <== NOT EXECUTED
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
3c9c4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== 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;
3c9c8: e1a02003 mov r2, r3 <== NOT EXECUTED
3c9cc: e1a0c003 mov ip, r3 <== 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)
3c9d0: ea00002d b 3ca8c <rtems_rfs_dir_hash+0xd0> <== NOT EXECUTED
{
a += k[0];
3c9d4: e550900a ldrb r9, [r0, #-10] <== 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];
3c9d8: e5508002 ldrb r8, [r0, #-2] <== 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];
3c9dc: e550500b ldrb r5, [r0, #-11] <== 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];
3c9e0: e5504003 ldrb r4, [r0, #-3] <== 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];
3c9e4: 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];
3c9e8: e1a08808 lsl r8, r8, #16 <== 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;
3c9ec: e550a00c ldrb sl, [r0, #-12] <== NOT EXECUTED
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
3c9f0: e5506006 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;
3c9f4: e5507004 ldrb r7, [r0, #-4] <== 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];
3c9f8: 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];
3c9fc: 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;
3ca00: e5505009 ldrb r5, [r0, #-9] <== NOT EXECUTED
a += ((uint32_t)k[3])<<24;
b += k[4];
3ca04: e5504007 ldrb r4, [r0, #-7] <== 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;
3ca08: e550b001 ldrb fp, [r0, #-1] <== 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;
3ca0c: e089a00a add sl, r9, sl <== NOT EXECUTED
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
3ca10: e1a06806 lsl r6, r6, #16 <== 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;
3ca14: e0887007 add r7, r8, r7 <== NOT EXECUTED
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
3ca18: e5509008 ldrb r9, [r0, #-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;
3ca1c: e08aac05 add sl, sl, r5, lsl #24 <== NOT EXECUTED
a += ((uint32_t)k[3])<<24;
b += k[4];
3ca20: e0864404 add r4, r6, r4, lsl #8 <== 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;
3ca24: e0877c0b add r7, r7, fp, lsl #24 <== NOT EXECUTED
a += ((uint32_t)k[1])<<8;
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;
3ca28: e5505005 ldrb r5, [r0, #-5] <== 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;
3ca2c: 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;
3ca30: e08ac00c add ip, sl, ip <== NOT EXECUTED
b += k[4];
b += ((uint32_t)k[5])<<8;
3ca34: e0844009 add r4, r4, r9 <== NOT EXECUTED
b += ((uint32_t)k[6])<<16;
3ca38: 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);
3ca3c: e063c00c rsb ip, r3, ip <== NOT EXECUTED
3ca40: e02cce63 eor ip, ip, 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;
3ca44: e0842002 add r2, r4, r2 <== 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);
3ca48: e06c6002 rsb r6, ip, r2 <== NOT EXECUTED
3ca4c: e0266d6c eor r6, r6, ip, ror #26 <== NOT EXECUTED
3ca50: e0833002 add r3, r3, r2 <== NOT EXECUTED
3ca54: e0664003 rsb r4, r6, r3 <== NOT EXECUTED
3ca58: e0244c66 eor r4, r4, r6, ror #24 <== NOT EXECUTED
3ca5c: e08c3003 add r3, ip, r3 <== NOT EXECUTED
3ca60: e064c003 rsb ip, r4, r3 <== NOT EXECUTED
3ca64: e02cc864 eor ip, ip, r4, ror #16 <== NOT EXECUTED
3ca68: e0866003 add r6, r6, r3 <== NOT EXECUTED
3ca6c: e06c2006 rsb r2, ip, r6 <== NOT EXECUTED
3ca70: e02226ec eor r2, r2, ip, ror #13 <== NOT EXECUTED
3ca74: e0844006 add r4, r4, r6 <== NOT EXECUTED
3ca78: e08cc004 add ip, ip, r4 <== NOT EXECUTED
3ca7c: e0624004 rsb r4, r2, r4 <== NOT EXECUTED
3ca80: e0243e62 eor r3, r4, r2, ror #28 <== NOT EXECUTED
length -= 12;
3ca84: 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);
3ca88: e082200c add r2, r2, ip <== 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)
3ca8c: e351000c cmp r1, #12 <== 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);
length -= 12;
3ca90: e1a04000 mov r4, r0 <== NOT EXECUTED
3ca94: e280000c add r0, r0, #12 <== 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)
3ca98: 8affffcd bhi 3c9d4 <rtems_rfs_dir_hash+0x18> <== NOT EXECUTED
length -= 12;
k += 12;
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
3ca9c: e2411001 sub r1, r1, #1 <== NOT EXECUTED
3caa0: e351000b cmp r1, #11 <== NOT EXECUTED
3caa4: 979ff101 ldrls pc, [pc, r1, lsl #2] <== NOT EXECUTED
3caa8: ea000031 b 3cb74 <rtems_rfs_dir_hash+0x1b8> <== NOT EXECUTED
3caac: 0003cb34 .word 0x0003cb34 <== NOT EXECUTED
3cab0: 0003cb2c .word 0x0003cb2c <== NOT EXECUTED
3cab4: 0003cb24 .word 0x0003cb24 <== NOT EXECUTED
3cab8: 0003cb1c .word 0x0003cb1c <== NOT EXECUTED
3cabc: 0003cb14 .word 0x0003cb14 <== NOT EXECUTED
3cac0: 0003cb0c .word 0x0003cb0c <== NOT EXECUTED
3cac4: 0003cb04 .word 0x0003cb04 <== NOT EXECUTED
3cac8: 0003cafc .word 0x0003cafc <== NOT EXECUTED
3cacc: 0003caf4 .word 0x0003caf4 <== NOT EXECUTED
3cad0: 0003caec .word 0x0003caec <== NOT EXECUTED
3cad4: 0003cae4 .word 0x0003cae4 <== NOT EXECUTED
3cad8: 0003cadc .word 0x0003cadc <== NOT EXECUTED
{
case 12: c+=((uint32_t)k[11])<<24;
3cadc: e5d4100b ldrb r1, [r4, #11] <== NOT EXECUTED
3cae0: e0833c01 add r3, r3, r1, lsl #24 <== NOT EXECUTED
case 11: c+=((uint32_t)k[10])<<16;
3cae4: e5d4100a ldrb r1, [r4, #10] <== NOT EXECUTED
3cae8: e0833801 add r3, r3, r1, lsl #16 <== NOT EXECUTED
case 10: c+=((uint32_t)k[9])<<8;
3caec: e5d41009 ldrb r1, [r4, #9] <== NOT EXECUTED
3caf0: e0833401 add r3, r3, r1, lsl #8 <== NOT EXECUTED
case 9 : c+=k[8];
3caf4: e5d41008 ldrb r1, [r4, #8] <== NOT EXECUTED
3caf8: e0833001 add r3, r3, r1 <== NOT EXECUTED
case 8 : b+=((uint32_t)k[7])<<24;
3cafc: e5d41007 ldrb r1, [r4, #7] <== NOT EXECUTED
3cb00: e0822c01 add r2, r2, r1, lsl #24 <== NOT EXECUTED
case 7 : b+=((uint32_t)k[6])<<16;
3cb04: e5d41006 ldrb r1, [r4, #6] <== NOT EXECUTED
3cb08: e0822801 add r2, r2, r1, lsl #16 <== NOT EXECUTED
case 6 : b+=((uint32_t)k[5])<<8;
3cb0c: e5d41005 ldrb r1, [r4, #5] <== NOT EXECUTED
3cb10: e0822401 add r2, r2, r1, lsl #8 <== NOT EXECUTED
case 5 : b+=k[4];
3cb14: e5d41004 ldrb r1, [r4, #4] <== NOT EXECUTED
3cb18: e0822001 add r2, r2, r1 <== NOT EXECUTED
case 4 : a+=((uint32_t)k[3])<<24;
3cb1c: e5d41003 ldrb r1, [r4, #3] <== NOT EXECUTED
3cb20: e08ccc01 add ip, ip, r1, lsl #24 <== NOT EXECUTED
case 3 : a+=((uint32_t)k[2])<<16;
3cb24: e5d41002 ldrb r1, [r4, #2] <== NOT EXECUTED
3cb28: e08cc801 add ip, ip, r1, lsl #16 <== NOT EXECUTED
case 2 : a+=((uint32_t)k[1])<<8;
3cb2c: e5d41001 ldrb r1, [r4, #1] <== NOT EXECUTED
3cb30: e08cc401 add ip, ip, r1, lsl #8 <== NOT EXECUTED
case 1 : a+=k[0];
3cb34: e5d41000 ldrb r1, [r4] <== NOT EXECUTED
break;
case 0 : return c;
}
}
final(a,b,c);
3cb38: e0233002 eor r3, r3, r2 <== 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];
3cb3c: e08cc001 add ip, ip, r1 <== NOT EXECUTED
break;
case 0 : return c;
}
}
final(a,b,c);
3cb40: e0431962 sub r1, r3, r2, ror #18 <== NOT EXECUTED
3cb44: e021c00c eor ip, r1, ip <== NOT EXECUTED
3cb48: e04ccae1 sub ip, ip, r1, ror #21 <== NOT EXECUTED
3cb4c: e02c2002 eor r2, ip, r2 <== NOT EXECUTED
3cb50: e04223ec sub r2, r2, ip, ror #7 <== NOT EXECUTED
3cb54: e0221001 eor r1, r2, r1 <== NOT EXECUTED
3cb58: e0411862 sub r1, r1, r2, ror #16 <== NOT EXECUTED
3cb5c: e021c00c eor ip, r1, ip <== NOT EXECUTED
3cb60: e04cce61 sub ip, ip, r1, ror #28 <== NOT EXECUTED
3cb64: e02c2002 eor r2, ip, r2 <== NOT EXECUTED
3cb68: e042296c sub r2, r2, ip, ror #18 <== NOT EXECUTED
3cb6c: e0223001 eor r3, r2, r1 <== NOT EXECUTED
3cb70: e0433462 sub r3, r3, r2, ror #8 <== NOT EXECUTED
return c;
}
3cb74: e1a00003 mov r0, r3 <== NOT EXECUTED
3cb78: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00035238 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
35238: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3523c: e24dd068 sub sp, sp, #104 ; 0x68 <== NOT EXECUTED
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
35240: e59dc08c ldr ip, [sp, #140] ; 0x8c <== NOT EXECUTED
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
35244: e1a09002 mov r9, r2 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
*offset = 0;
35248: e59d2090 ldr r2, [sp, #144] ; 0x90 <== NOT EXECUTED
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
3524c: e3a06000 mov r6, #0 <== NOT EXECUTED
*offset = 0;
rc = rtems_rfs_block_map_open (fs, inode, &map);
35250: e28d7008 add r7, sp, #8 <== NOT EXECUTED
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
35254: e58c6000 str r6, [ip] <== NOT EXECUTED
*offset = 0;
35258: e5826000 str r6, [r2] <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, inode, &map);
3525c: e1a02007 mov r2, r7 <== NOT EXECUTED
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
35260: e1a08003 mov r8, r3 <== NOT EXECUTED
35264: e1a05000 mov r5, r0 <== NOT EXECUTED
}
*ino = RTEMS_RFS_EMPTY_INO;
*offset = 0;
rc = rtems_rfs_block_map_open (fs, inode, &map);
35268: ebfffc0c bl 342a0 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
3526c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
35270: ca00007e bgt 35470 <rtems_rfs_dir_lookup_ino+0x238> <== NOT EXECUTED
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
35274: e1a01008 mov r1, r8 <== NOT EXECUTED
35278: e1a00009 mov r0, r9 <== NOT EXECUTED
3527c: e58d6060 str r6, [sp, #96] ; 0x60 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
35280: e5cd6058 strb r6, [sp, #88] ; 0x58 <== NOT EXECUTED
handle->bnum = 0;
35284: e58d605c str r6, [sp, #92] ; 0x5c <== NOT EXECUTED
35288: eb001dcb bl 3c9bc <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);
3528c: e28d6064 add r6, sp, #100 ; 0x64 <== NOT EXECUTED
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
35290: e58d0004 str r0, [sp, #4] <== 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);
35294: e1a01007 mov r1, r7 <== NOT EXECUTED
35298: e1a00005 mov r0, r5 <== NOT EXECUTED
3529c: e3a02000 mov r2, #0 <== NOT EXECUTED
352a0: e3a03000 mov r3, #0 <== NOT EXECUTED
352a4: e58d6000 str r6, [sp] <== NOT EXECUTED
352a8: ebfff962 bl 33838 <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
352ac: e2504000 subs r4, r0, #0 <== NOT EXECUTED
352b0: da000060 ble 35438 <rtems_rfs_dir_lookup_ino+0x200> <== 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)
rc = ENOENT;
rtems_rfs_buffer_handle_close (fs, &entries);
352b4: e28d1058 add r1, sp, #88 ; 0x58 <== NOT EXECUTED
352b8: e1a00005 mov r0, r5 <== NOT EXECUTED
352bc: ebfffd89 bl 348e8 <rtems_rfs_buffer_handle_close> <== 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)
352c0: e3540006 cmp r4, #6 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
352c4: e1a00005 mov r0, r5 <== NOT EXECUTED
352c8: e1a01007 mov r1, r7 <== 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)
352cc: 03a04002 moveq r4, #2 <== NOT EXECUTED
352d0: ea000065 b 3546c <rtems_rfs_dir_lookup_ino+0x234> <== 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);
352d4: e1a00005 mov r0, r5 <== NOT EXECUTED
352d8: e28d1058 add r1, sp, #88 ; 0x58 <== NOT EXECUTED
352dc: e3a03001 mov r3, #1 <== NOT EXECUTED
352e0: ebfffcfe bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
352e4: e250a000 subs sl, r0, #0 <== NOT EXECUTED
352e8: ca000059 bgt 35454 <rtems_rfs_dir_lookup_ino+0x21c> <== 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);
352ec: e59d3060 ldr r3, [sp, #96] ; 0x60 <== NOT EXECUTED
map.bpos.boff = 0;
352f0: e58d401c str r4, [sp, #28] <== 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);
352f4: e5936020 ldr r6, [r3, #32] <== NOT EXECUTED
352f8: e1a07004 mov r7, r4 <== NOT EXECUTED
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
352fc: ea00003a b 353ec <rtems_rfs_dir_lookup_ino+0x1b4> <== 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);
35300: e5d62000 ldrb r2, [r6] <== NOT EXECUTED
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
35304: e5d60009 ldrb r0, [r6, #9] <== NOT EXECUTED
*ino = rtems_rfs_dir_entry_ino (entry);
35308: e5d63003 ldrb r3, [r6, #3] <== NOT EXECUTED
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
3530c: e5d64008 ldrb r4, [r6, #8] <== NOT EXECUTED
*ino = rtems_rfs_dir_entry_ino (entry);
35310: e5d61001 ldrb r1, [r6, #1] <== NOT EXECUTED
35314: 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);
35318: e1804404 orr r4, r0, r4, 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);
3531c: e5d60005 ldrb r0, [r6, #5] <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
35320: 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);
35324: e5d61004 ldrb r1, [r6, #4] <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
35328: e5d62002 ldrb r2, [r6, #2] <== NOT EXECUTED
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
3532c: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
35330: 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);
35334: e5d61007 ldrb r1, [r6, #7] <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
35338: 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);
3533c: e5d62006 ldrb r2, [r6, #6] <== NOT EXECUTED
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
35340: 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)
35344: e59fc138 ldr ip, [pc, #312] ; 35484 <rtems_rfs_dir_lookup_ino+0x24c><== NOT EXECUTED
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
35348: e1812402 orr r2, 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);
3534c: e59d108c ldr r1, [sp, #140] ; 0x8c <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
35350: e154000c cmp r4, ip <== 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);
35354: e5813000 str r3, [r1] <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
35358: 0a000028 beq 35400 <rtems_rfs_dir_lookup_ino+0x1c8> <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
3535c: e354000a cmp r4, #10 <== NOT EXECUTED
35360: da000031 ble 3542c <rtems_rfs_dir_lookup_ino+0x1f4> <== NOT EXECUTED
35364: e5951018 ldr r1, [r5, #24] <== NOT EXECUTED
35368: e1540001 cmp r4, r1 <== NOT EXECUTED
3536c: 2a00002e bcs 3542c <rtems_rfs_dir_lookup_ino+0x1f4> <== NOT EXECUTED
35370: e3530000 cmp r3, #0 <== NOT EXECUTED
35374: 0a00002c beq 3542c <rtems_rfs_dir_lookup_ino+0x1f4> <== NOT EXECUTED
35378: e5951010 ldr r1, [r5, #16] <== NOT EXECUTED
3537c: e1530001 cmp r3, r1 <== NOT EXECUTED
35380: 8a000029 bhi 3542c <rtems_rfs_dir_lookup_ino+0x1f4> <== NOT EXECUTED
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
35384: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
35388: e1520003 cmp r2, r3 <== NOT EXECUTED
3538c: 1a000012 bne 353dc <rtems_rfs_dir_lookup_ino+0x1a4> <== 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)
35390: e286000a add r0, r6, #10 <== NOT EXECUTED
35394: e1a01009 mov r1, r9 <== NOT EXECUTED
35398: e1a02008 mov r2, r8 <== NOT EXECUTED
3539c: eb002b5d bl 40118 <memcmp> <== NOT EXECUTED
353a0: e3500000 cmp r0, #0 <== NOT EXECUTED
353a4: 1a00000c bne 353dc <rtems_rfs_dir_lookup_ino+0x1a4> <== NOT EXECUTED
{
*offset = rtems_rfs_block_map_pos (fs, &map);
353a8: e28d6008 add r6, sp, #8 <== NOT EXECUTED
353ac: e1a00005 mov r0, r5 <== NOT EXECUTED
353b0: e2861010 add r1, r6, #16 <== NOT EXECUTED
353b4: ebfff874 bl 3358c <rtems_rfs_block_get_pos> <== NOT EXECUTED
353b8: e59dc090 ldr ip, [sp, #144] ; 0x90 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
printf ("rtems-rfs: dir-lookup-ino: "
"entry found in ino %" PRIu32 ", ino=%" PRIu32 " offset=%" PRIu32 "\n",
rtems_rfs_inode_ino (inode), *ino, *offset);
rtems_rfs_buffer_handle_close (fs, &entries);
353bc: e28d1058 add r1, sp, #88 ; 0x58 <== NOT EXECUTED
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)
{
*offset = rtems_rfs_block_map_pos (fs, &map);
353c0: e58c0000 str r0, [ip] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
printf ("rtems-rfs: dir-lookup-ino: "
"entry found in ino %" PRIu32 ", ino=%" PRIu32 " offset=%" PRIu32 "\n",
rtems_rfs_inode_ino (inode), *ino, *offset);
rtems_rfs_buffer_handle_close (fs, &entries);
353c4: e1a00005 mov r0, r5 <== NOT EXECUTED
353c8: ebfffd46 bl 348e8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
353cc: e1a04007 mov r4, r7 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
353d0: e1a00005 mov r0, r5 <== NOT EXECUTED
353d4: e1a01006 mov r1, r6 <== NOT EXECUTED
353d8: ea000023 b 3546c <rtems_rfs_dir_lookup_ino+0x234> <== NOT EXECUTED
return 0;
}
}
map.bpos.boff += elength;
353dc: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED
353e0: e0833004 add r3, r3, r4 <== NOT EXECUTED
353e4: e58d301c str r3, [sp, #28] <== NOT EXECUTED
entry += elength;
353e8: e0866004 add r6, r6, r4 <== 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))
353ec: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
353f0: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED
353f4: e243300a sub r3, r3, #10 <== NOT EXECUTED
353f8: e1520003 cmp r2, r3 <== NOT EXECUTED
353fc: 3affffbf bcc 35300 <rtems_rfs_dir_lookup_ino+0xc8> <== NOT EXECUTED
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
35400: e35a0000 cmp sl, #0 <== NOT EXECUTED
35404: 1a000009 bne 35430 <rtems_rfs_dir_lookup_ino+0x1f8> <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
35408: e1a00005 mov r0, r5 <== NOT EXECUTED
3540c: e28d1008 add r1, sp, #8 <== NOT EXECUTED
35410: e1a0200b mov r2, fp <== NOT EXECUTED
35414: ebfff8fc bl 3380c <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)
35418: e3500006 cmp r0, #6 <== NOT EXECUTED
entry += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
3541c: e1a04000 mov r4, r0 <== 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)
35420: 1a000005 bne 3543c <rtems_rfs_dir_lookup_ino+0x204> <== NOT EXECUTED
35424: e3a04002 mov r4, #2 <== NOT EXECUTED
35428: ea00000a b 35458 <rtems_rfs_dir_lookup_ino+0x220> <== NOT EXECUTED
3542c: e3a0a005 mov sl, #5 <== NOT EXECUTED
35430: e1a0400a mov r4, sl <== NOT EXECUTED
35434: ea000000 b 3543c <rtems_rfs_dir_lookup_ino+0x204> <== NOT EXECUTED
entry += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
35438: e1a0b006 mov fp, r6 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
3543c: e3540000 cmp r4, #0 <== NOT EXECUTED
35440: 1a000004 bne 35458 <rtems_rfs_dir_lookup_ino+0x220> <== NOT EXECUTED
35444: e59d2064 ldr r2, [sp, #100] ; 0x64 <== NOT EXECUTED
35448: e3520000 cmp r2, #0 <== NOT EXECUTED
3544c: 1affffa0 bne 352d4 <rtems_rfs_dir_lookup_ino+0x9c> <== NOT EXECUTED
35450: ea000009 b 3547c <rtems_rfs_dir_lookup_ino+0x244> <== NOT EXECUTED
35454: e1a0400a mov r4, sl <== 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);
35458: e28d1058 add r1, sp, #88 ; 0x58 <== NOT EXECUTED
3545c: e1a00005 mov r0, r5 <== NOT EXECUTED
35460: ebfffd20 bl 348e8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
35464: e1a00005 mov r0, r5 <== NOT EXECUTED
35468: e28d1008 add r1, sp, #8 <== NOT EXECUTED
3546c: ebfffb19 bl 340d8 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
}
35470: e1a00004 mov r0, r4 <== NOT EXECUTED
35474: e28dd068 add sp, sp, #104 ; 0x68 <== NOT EXECUTED
35478: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
if ((rc == 0) && (block == 0))
3547c: e3a04005 mov r4, #5 <== NOT EXECUTED
35480: eafffff4 b 35458 <rtems_rfs_dir_lookup_ino+0x220> <== NOT EXECUTED
00034a90 <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)
{
34a90: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
34a94: e24dd078 sub sp, sp, #120 ; 0x78 <== NOT EXECUTED
34a98: e59d60a0 ldr r6, [sp, #160] ; 0xa0 <== 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;
34a9c: e3a0c000 mov ip, #0 <== 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)
{
34aa0: e58d2008 str r2, [sp, #8] <== NOT EXECUTED
34aa4: 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;
34aa8: e586c000 str ip, [r6] <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
34aac: e28d2018 add r2, sp, #24 <== 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)
{
34ab0: e1a04000 mov r4, r0 <== NOT EXECUTED
34ab4: e59d509c ldr r5, [sp, #156] ; 0x9c <== 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);
34ab8: ebfffdf8 bl 342a0 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
34abc: e250a000 subs sl, r0, #0 <== NOT EXECUTED
34ac0: ca000099 bgt 34d2c <rtems_rfs_dir_read+0x29c> <== NOT EXECUTED
return rc;
if (((rtems_rfs_fs_block_size (fs) -
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
34ac4: e5947008 ldr r7, [r4, #8] <== NOT EXECUTED
34ac8: 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) -
34acc: e1a02007 mov r2, r7 <== NOT EXECUTED
34ad0: e1a03008 mov r3, r8 <== NOT EXECUTED
34ad4: e28d1008 add r1, sp, #8 <== NOT EXECUTED
34ad8: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
34adc: eb00839d bl 55958 <__moddi3> <== NOT EXECUTED
34ae0: e1a02007 mov r2, r7 <== NOT EXECUTED
34ae4: e1a03008 mov r3, r8 <== NOT EXECUTED
34ae8: e0522000 subs r2, r2, r0 <== NOT EXECUTED
34aec: e0c33001 sbc r3, r3, r1 <== NOT EXECUTED
34af0: e3530000 cmp r3, #0 <== NOT EXECUTED
34af4: ca000010 bgt 34b3c <rtems_rfs_dir_read+0xac> <== NOT EXECUTED
34af8: 1a000001 bne 34b04 <rtems_rfs_dir_read+0x74> <== NOT EXECUTED
34afc: e352000a cmp r2, #10 <== NOT EXECUTED
34b00: 8a00000d bhi 34b3c <rtems_rfs_dir_read+0xac> <== NOT EXECUTED
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
34b04: e28d1008 add r1, sp, #8 <== NOT EXECUTED
34b08: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
34b0c: e1a02007 mov r2, r7 <== NOT EXECUTED
34b10: e1a03008 mov r3, r8 <== NOT EXECUTED
34b14: eb008265 bl 554b0 <__divdi3> <== NOT EXECUTED
34b18: e3a02001 mov r2, #1 <== NOT EXECUTED
34b1c: e0922000 adds r2, r2, r0 <== NOT EXECUTED
34b20: e3a03000 mov r3, #0 <== NOT EXECUTED
34b24: e0a33001 adc r3, r3, r1 <== NOT EXECUTED
34b28: e0810792 umull r0, r1, r2, r7 <== NOT EXECUTED
34b2c: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
34b30: e58d100c str r1, [sp, #12] <== NOT EXECUTED
34b34: e0211397 mla r1, r7, r3, r1 <== NOT EXECUTED
34b38: e58d100c str r1, [sp, #12] <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
34b3c: e28d7018 add r7, sp, #24 <== NOT EXECUTED
34b40: e28d8074 add r8, sp, #116 ; 0x74 <== NOT EXECUTED
34b44: e1a00004 mov r0, r4 <== NOT EXECUTED
34b48: e1a01007 mov r1, r7 <== NOT EXECUTED
34b4c: e28d3008 add r3, sp, #8 <== NOT EXECUTED
34b50: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
34b54: e58d8000 str r8, [sp] <== NOT EXECUTED
34b58: ebfffb36 bl 33838 <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
34b5c: e250a000 subs sl, r0, #0 <== NOT EXECUTED
34b60: da000004 ble 34b78 <rtems_rfs_dir_read+0xe8> <== NOT EXECUTED
{
if (rc == ENXIO)
34b64: e35a0006 cmp sl, #6 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
34b68: e1a00004 mov r0, r4 <== NOT EXECUTED
34b6c: e1a01007 mov r1, r7 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
if (rc > 0)
{
if (rc == ENXIO)
34b70: 03a0a002 moveq sl, #2 <== NOT EXECUTED
34b74: ea00006b b 34d28 <rtems_rfs_dir_read+0x298> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
34b78: e3a03000 mov r3, #0 <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
34b7c: e58d3070 str r3, [sp, #112] ; 0x70 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
34b80: e5cd3068 strb r3, [sp, #104] ; 0x68 <== NOT EXECUTED
handle->bnum = 0;
34b84: e58d306c str r3, [sp, #108] ; 0x6c <== NOT EXECUTED
uint8_t* entry;
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
34b88: e58d5004 str r5, [sp, #4] <== NOT EXECUTED
34b8c: e28d9068 add r9, sp, #104 ; 0x68 <== NOT EXECUTED
34b90: e1a01009 mov r1, r9 <== NOT EXECUTED
34b94: e59d2074 ldr r2, [sp, #116] ; 0x74 <== NOT EXECUTED
34b98: e3a03001 mov r3, #1 <== NOT EXECUTED
34b9c: e1a00004 mov r0, r4 <== NOT EXECUTED
34ba0: ebfffece bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
34ba4: e250a000 subs sl, 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);
34ba8: e28d1018 add r1, sp, #24 <== NOT EXECUTED
34bac: e28d2074 add r2, sp, #116 ; 0x74 <== NOT EXECUTED
34bb0: e1a00004 mov r0, r4 <== NOT EXECUTED
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &buffer);
34bb4: c1a01009 movgt r1, r9 <== NOT EXECUTED
34bb8: ca000057 bgt 34d1c <rtems_rfs_dir_read+0x28c> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
34bbc: e59d3070 ldr r3, [sp, #112] ; 0x70 <== NOT EXECUTED
entry += map.bpos.boff;
34bc0: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
34bc4: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
entry += map.bpos.boff;
34bc8: e083700c add r7, r3, ip <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
34bcc: e7d3e00c ldrb lr, [r3, ip] <== NOT EXECUTED
34bd0: e5d7b003 ldrb fp, [r7, #3] <== NOT EXECUTED
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
34bd4: e5d73009 ldrb r3, [r7, #9] <== NOT EXECUTED
34bd8: e5d78008 ldrb r8, [r7, #8] <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
34bdc: e5d75001 ldrb r5, [r7, #1] <== NOT EXECUTED
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
34be0: e1838408 orr r8, r3, r8, lsl #8 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
34be4: e18b3c0e orr r3, fp, lr, lsl #24 <== NOT EXECUTED
34be8: e1833805 orr r3, r3, r5, lsl #16 <== NOT EXECUTED
34bec: e5d7e002 ldrb lr, [r7, #2] <== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
34bf0: e59f5140 ldr r5, [pc, #320] ; 34d38 <rtems_rfs_dir_read+0x2a8><== 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);
34bf4: e183340e orr r3, r3, lr, lsl #8 <== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
34bf8: e1580005 cmp r8, r5 <== 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);
34bfc: e287e002 add lr, r7, #2 <== NOT EXECUTED
34c00: e2875003 add r5, r7, #3 <== NOT EXECUTED
34c04: e287b001 add fp, r7, #1 <== NOT EXECUTED
34c08: e58de014 str lr, [sp, #20] <== NOT EXECUTED
34c0c: e58d5010 str r5, [sp, #16] <== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
34c10: 0a000031 beq 34cdc <rtems_rfs_dir_read+0x24c> <== NOT EXECUTED
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
34c14: e358000a cmp r8, #10 <== NOT EXECUTED
34c18: e59d5004 ldr r5, [sp, #4] <== NOT EXECUTED
34c1c: da00003b ble 34d10 <rtems_rfs_dir_read+0x280> <== NOT EXECUTED
34c20: e5941018 ldr r1, [r4, #24] <== NOT EXECUTED
34c24: e3530000 cmp r3, #0 <== NOT EXECUTED
34c28: 11580001 cmpne r8, r1 <== NOT EXECUTED
34c2c: 33a01000 movcc r1, #0 <== NOT EXECUTED
34c30: 23a01001 movcs r1, #1 <== NOT EXECUTED
34c34: 2a000035 bcs 34d10 <rtems_rfs_dir_read+0x280> <== NOT EXECUTED
34c38: e5942010 ldr r2, [r4, #16] <== NOT EXECUTED
34c3c: e1530002 cmp r3, r2 <== NOT EXECUTED
34c40: 8a000032 bhi 34d10 <rtems_rfs_dir_read+0x280> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
34c44: e3a02e11 mov r2, #272 ; 0x110 <== NOT EXECUTED
34c48: e1a00005 mov r0, r5 <== NOT EXECUTED
34c4c: eb002de2 bl 403dc <memset> <== NOT EXECUTED
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
*length += elength;
34c50: e5963000 ldr r3, [r6] <== NOT EXECUTED
34c54: e0883003 add r3, r8, r3 <== NOT EXECUTED
34c58: e5863000 str r3, [r6] <== NOT EXECUTED
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
34c5c: e59d202c ldr r2, [sp, #44] ; 0x2c <== NOT EXECUTED
34c60: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED
34c64: e0622001 rsb r2, r2, r1 <== NOT EXECUTED
34c68: e0682002 rsb r2, r8, r2 <== NOT EXECUTED
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
34c6c: e352000a cmp r2, #10 <== NOT EXECUTED
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
34c70: e28d1008 add r1, sp, #8 <== NOT EXECUTED
34c74: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
*length += elength;
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
*length += remaining;
34c78: d0823003 addle r3, r2, r3 <== NOT EXECUTED
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
34c7c: e248800a sub r8, r8, #10 <== NOT EXECUTED
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
34c80: e9850003 stmib r5, {r0, r1} <== NOT EXECUTED
*length += elength;
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
*length += remaining;
34c84: d5863000 strle r3, [r6] <== NOT EXECUTED
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
34c88: e3a01e11 mov r1, #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;
34c8c: e35800ff cmp r8, #255 ; 0xff <== NOT EXECUTED
34c90: a3a080ff movge r8, #255 ; 0xff <== NOT EXECUTED
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
34c94: e1c510bc strh r1, [r5, #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);
34c98: e1a02008 mov r2, r8 <== NOT EXECUTED
34c9c: e287100a add r1, r7, #10 <== NOT EXECUTED
34ca0: e2850010 add r0, r5, #16 <== NOT EXECUTED
34ca4: eb002d45 bl 401c0 <memcpy> <== NOT EXECUTED
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
34ca8: e5db3000 ldrb r3, [fp] <== NOT EXECUTED
34cac: e59de010 ldr lr, [sp, #16] <== NOT EXECUTED
34cb0: e5d72000 ldrb r2, [r7] <== NOT EXECUTED
34cb4: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED
34cb8: e5de1000 ldrb r1, [lr] <== NOT EXECUTED
34cbc: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED
34cc0: e1833c02 orr r3, r3, r2, lsl #24 <== NOT EXECUTED
34cc4: e5d02000 ldrb r2, [r0] <== NOT EXECUTED
34cc8: e1833001 orr r3, r3, r1 <== NOT EXECUTED
34ccc: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
dirent->d_namlen = elength;
34cd0: e1c580be strh r8, [r5, #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);
34cd4: e5853000 str r3, [r5] <== 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;
34cd8: ea00000d b 34d14 <rtems_rfs_dir_read+0x284> <== NOT EXECUTED
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
34cdc: e594e008 ldr lr, [r4, #8] <== NOT EXECUTED
34ce0: e5963000 ldr r3, [r6] <== NOT EXECUTED
34ce4: e06cc00e rsb ip, ip, lr <== NOT EXECUTED
34ce8: e083300c add r3, r3, ip <== NOT EXECUTED
34cec: e5863000 str r3, [r6] <== 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);
34cf0: ebfffac5 bl 3380c <rtems_rfs_block_map_next_block> <== NOT EXECUTED
if (rc == ENXIO)
34cf4: 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);
34cf8: e1a0a000 mov sl, r0 <== NOT EXECUTED
if (rc == ENXIO)
34cfc: 03a0a002 moveq sl, #2 <== NOT EXECUTED
34d00: 0a000003 beq 34d14 <rtems_rfs_dir_read+0x284> <== NOT EXECUTED
/*
* Look for an empty entry and if this is the last block that is the end of
* the directory.
*/
while (rc == 0)
34d04: e3500000 cmp r0, #0 <== NOT EXECUTED
34d08: 0affffa0 beq 34b90 <rtems_rfs_dir_read+0x100> <== NOT EXECUTED
34d0c: ea000000 b 34d14 <rtems_rfs_dir_read+0x284> <== NOT EXECUTED
34d10: e3a0a005 mov sl, #5 <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
}
rtems_rfs_buffer_handle_close (fs, &buffer);
34d14: e28d1068 add r1, sp, #104 ; 0x68 <== NOT EXECUTED
34d18: e1a00004 mov r0, r4 <== NOT EXECUTED
34d1c: ebfffef1 bl 348e8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
34d20: e1a00004 mov r0, r4 <== NOT EXECUTED
34d24: e28d1018 add r1, sp, #24 <== NOT EXECUTED
34d28: ebfffcea bl 340d8 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
}
34d2c: e1a0000a mov r0, sl <== NOT EXECUTED
34d30: e28dd078 add sp, sp, #120 ; 0x78 <== NOT EXECUTED
34d34: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00035b3c <rtems_rfs_file_close>:
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)
35b3c: e591301c ldr r3, [r1, #28] <== NOT EXECUTED
35b40: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED
35b44: e3520000 cmp r2, #0 <== NOT EXECUTED
handle->shared->references--;
35b48: c2422001 subgt r2, r2, #1 <== NOT EXECUTED
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
35b4c: e92d4070 push {r4, r5, r6, lr} <== 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)
handle->shared->references--;
35b50: c5832008 strgt r2, [r3, #8] <== NOT EXECUTED
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
35b54: e1a04001 mov r4, r1 <== NOT EXECUTED
handle->shared->inode.ino);
if (handle->shared->references > 0)
handle->shared->references--;
if (handle->shared->references == 0)
35b58: e591101c ldr r1, [r1, #28] <== NOT EXECUTED
35b5c: e5913008 ldr r3, [r1, #8] <== NOT EXECUTED
35b60: e3530000 cmp r3, #0 <== NOT EXECUTED
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
35b64: e1a06000 mov r6, r0 <== NOT EXECUTED
handle->shared->inode.ino);
if (handle->shared->references > 0)
handle->shared->references--;
if (handle->shared->references == 0)
35b68: 13a05000 movne r5, #0 <== NOT EXECUTED
35b6c: 1a000054 bne 35cc4 <rtems_rfs_file_close+0x188> <== NOT EXECUTED
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
35b70: e5913018 ldr r3, [r1, #24] <== NOT EXECUTED
35b74: e3530000 cmp r3, #0 <== NOT EXECUTED
35b78: 1a000003 bne 35b8c <rtems_rfs_file_close+0x50> <== NOT EXECUTED
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
35b7c: e281100c add r1, r1, #12 <== NOT EXECUTED
35b80: eb000769 bl 3792c <rtems_rfs_inode_load> <== NOT EXECUTED
if (rrc == 0)
35b84: e2505000 subs r5, r0, #0 <== NOT EXECUTED
35b88: 1a000039 bne 35c74 <rtems_rfs_file_close+0x138> <== NOT EXECUTED
{
/*
* @todo This could be clever and only update if different.
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
35b8c: e594201c ldr r2, [r4, #28] <== NOT EXECUTED
35b90: e592308c ldr r3, [r2, #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);
35b94: e5921018 ldr r1, [r2, #24] <== NOT EXECUTED
35b98: e1a00c23 lsr r0, r3, #24 <== NOT EXECUTED
35b9c: e5c10010 strb r0, [r1, #16] <== NOT EXECUTED
35ba0: e5921018 ldr r1, [r2, #24] <== NOT EXECUTED
35ba4: e1a00823 lsr r0, r3, #16 <== NOT EXECUTED
35ba8: e5c10011 strb r0, [r1, #17] <== NOT EXECUTED
35bac: e5921018 ldr r1, [r2, #24] <== NOT EXECUTED
35bb0: e1a00423 lsr r0, r3, #8 <== NOT EXECUTED
35bb4: e5c10012 strb r0, [r1, #18] <== NOT EXECUTED
35bb8: e5921018 ldr r1, [r2, #24] <== NOT EXECUTED
35bbc: e5c13013 strb r3, [r1, #19] <== NOT EXECUTED
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
35bc0: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
35bc4: e5931090 ldr r1, [r3, #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);
35bc8: e593c018 ldr ip, [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);
35bcc: 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);
35bd0: e1a0ec21 lsr lr, r1, #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);
35bd4: e5c2001c strb r0, [r2, #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);
35bd8: e5cce014 strb lr, [ip, #20] <== NOT EXECUTED
35bdc: e5932018 ldr r2, [r3, #24] <== NOT EXECUTED
35be0: e1a0c821 lsr ip, r1, #16 <== NOT EXECUTED
35be4: e5c2c015 strb ip, [r2, #21] <== NOT EXECUTED
35be8: e5932018 ldr r2, [r3, #24] <== NOT EXECUTED
35bec: e1a0c421 lsr ip, r1, #8 <== NOT EXECUTED
35bf0: e5c2c016 strb ip, [r2, #22] <== NOT EXECUTED
35bf4: e5932018 ldr r2, [r3, #24] <== NOT EXECUTED
35bf8: e5c21017 strb r1, [r2, #23] <== NOT EXECUTED
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
35bfc: e594201c ldr r2, [r4, #28] <== NOT EXECUTED
35c00: e5921094 ldr r1, [r2, #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);
35c04: e592c018 ldr ip, [r2, #24] <== NOT EXECUTED
35c08: 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);
35c0c: e5c3001c strb r0, [r3, #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);
35c10: e5cce018 strb lr, [ip, #24] <== NOT EXECUTED
35c14: e5923018 ldr r3, [r2, #24] <== NOT EXECUTED
35c18: e1a0c821 lsr ip, r1, #16 <== NOT EXECUTED
35c1c: e5c3c019 strb ip, [r3, #25] <== NOT EXECUTED
35c20: e5923018 ldr r3, [r2, #24] <== NOT EXECUTED
35c24: e1a0c421 lsr ip, r1, #8 <== NOT EXECUTED
35c28: e5c3c01a strb ip, [r3, #26] <== NOT EXECUTED
35c2c: e5923018 ldr r3, [r2, #24] <== NOT EXECUTED
35c30: e5c3101b strb r1, [r3, #27] <== NOT EXECUTED
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
35c34: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
35c38: e5931084 ldr r1, [r3, #132] ; 0x84 <== NOT EXECUTED
35c3c: e593c03c ldr ip, [r3, #60] ; 0x3c <== NOT EXECUTED
35c40: e151000c cmp r1, ip <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
35c44: e5c2001c strb r0, [r2, #28] <== NOT EXECUTED
35c48: 1a000003 bne 35c5c <rtems_rfs_file_close+0x120> <== NOT EXECUTED
35c4c: e5930088 ldr r0, [r3, #136] ; 0x88 <== NOT EXECUTED
35c50: e5932040 ldr r2, [r3, #64] ; 0x40 <== NOT EXECUTED
35c54: e1500002 cmp r0, r2 <== NOT EXECUTED
35c58: 0a000004 beq 35c70 <rtems_rfs_file_close+0x134> <== 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);
35c5c: e5932088 ldr r2, [r3, #136] ; 0x88 <== NOT EXECUTED
map->dirty = true;
35c60: e3a00001 mov r0, #1 <== NOT EXECUTED
35c64: e5c30034 strb r0, [r3, #52] ; 0x34 <== 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);
35c68: e583103c str r1, [r3, #60] ; 0x3c <== NOT EXECUTED
35c6c: e5832040 str r2, [r3, #64] ; 0x40 <== NOT EXECUTED
map->dirty = true;
35c70: 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);
35c74: e594101c ldr r1, [r4, #28] <== NOT EXECUTED
35c78: e1a00006 mov r0, r6 <== NOT EXECUTED
35c7c: e2811034 add r1, r1, #52 ; 0x34 <== NOT EXECUTED
35c80: ebfff914 bl 340d8 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
35c84: e3500000 cmp r0, #0 <== NOT EXECUTED
35c88: da000001 ble 35c94 <rtems_rfs_file_close+0x158> <== 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)
35c8c: e3550000 cmp r5, #0 <== NOT EXECUTED
35c90: 01a05000 moveq r5, r0 <== NOT EXECUTED
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
35c94: e594101c ldr r1, [r4, #28] <== NOT EXECUTED
35c98: e1a00006 mov r0, r6 <== NOT EXECUTED
35c9c: e281100c add r1, r1, #12 <== NOT EXECUTED
35ca0: eb000714 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
35ca4: e3500000 cmp r0, #0 <== NOT EXECUTED
35ca8: da000001 ble 35cb4 <rtems_rfs_file_close+0x178> <== 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)
35cac: e3550000 cmp r5, #0 <== NOT EXECUTED
35cb0: 01a05000 moveq r5, r0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
35cb4: e594001c ldr r0, [r4, #28] <== NOT EXECUTED
35cb8: ebff59e0 bl c440 <_Chain_Extract> <== NOT EXECUTED
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
35cbc: e594001c ldr r0, [r4, #28] <== NOT EXECUTED
35cc0: ebff467b bl 76b4 <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);
35cc4: e2841004 add r1, r4, #4 <== NOT EXECUTED
35cc8: e1a00006 mov r0, r6 <== NOT EXECUTED
35ccc: ebfffa3a bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
35cd0: 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);
35cd4: e1a00004 mov r0, r4 <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
35cd8: 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;
35cdc: e5c43004 strb r3, [r4, #4] <== NOT EXECUTED
handle->bnum = 0;
35ce0: e5843008 str r3, [r4, #8] <== NOT EXECUTED
35ce4: ebff4672 bl 76b4 <free> <== NOT EXECUTED
return rrc;
}
35ce8: e1a00005 mov r0, r5 <== NOT EXECUTED
35cec: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00035488 <rtems_rfs_file_get_shared>:
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
35488: e2802074 add r2, r0, #116 ; 0x74 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return the_chain->first;
3548c: e5903070 ldr r3, [r0, #112] ; 0x70 <== 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))
35490: ea000004 b 354a8 <rtems_rfs_file_get_shared+0x20> <== NOT EXECUTED
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
35494: e5930014 ldr r0, [r3, #20] <== NOT EXECUTED
35498: 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;
3549c: e1a00003 mov r0, r3 <== NOT EXECUTED
if (shared->inode.ino == ino)
354a0: 012fff1e bxeq lr <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
354a4: 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))
354a8: e1530002 cmp r3, r2 <== NOT EXECUTED
354ac: 1afffff8 bne 35494 <rtems_rfs_file_get_shared+0xc> <== NOT EXECUTED
354b0: e3a00000 mov r0, #0 <== NOT EXECUTED
if (shared->inode.ino == ino)
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
354b4: e12fff1e bx lr <== NOT EXECUTED
0003599c <rtems_rfs_file_io_end>:
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
3599c: e92d45f1 push {r0, 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))
359a0: e590400c ldr r4, [r0, #12] <== NOT EXECUTED
359a4: e3540000 cmp r4, #0 <== NOT EXECUTED
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
359a8: e1a05000 mov r5, r0 <== NOT EXECUTED
359ac: e1a07001 mov r7, r1 <== NOT EXECUTED
359b0: 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))
359b4: 0a000015 beq 35a10 <rtems_rfs_file_io_end+0x74> <== NOT EXECUTED
{
if (!read)
359b8: e3560000 cmp r6, #0 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
359bc: 03a03001 moveq r3, #1 <== NOT EXECUTED
359c0: 05c03004 strbeq r3, [r0, #4] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
359c4: e590301c ldr r3, [r0, #28] <== NOT EXECUTED
359c8: e2851004 add r1, r5, #4 <== NOT EXECUTED
359cc: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
359d0: ebfffaf9 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
if (rc > 0)
359d4: e2504000 subs r4, r0, #0 <== NOT EXECUTED
359d8: da00000c ble 35a10 <rtems_rfs_file_io_end+0x74> <== NOT EXECUTED
{
printf (
359dc: e59f314c ldr r3, [pc, #332] ; 35b30 <rtems_rfs_file_io_end+0x194><== NOT EXECUTED
359e0: e59f214c ldr r2, [pc, #332] ; 35b34 <rtems_rfs_file_io_end+0x198><== NOT EXECUTED
359e4: e3560000 cmp r6, #0 <== NOT EXECUTED
359e8: 11a06002 movne r6, r2 <== NOT EXECUTED
359ec: 01a06003 moveq r6, r3 <== NOT EXECUTED
359f0: eb0036b3 bl 434c4 <strerror> <== NOT EXECUTED
359f4: e1a01006 mov r1, r6 <== NOT EXECUTED
359f8: e58d0000 str r0, [sp] <== NOT EXECUTED
359fc: e1a02007 mov r2, r7 <== NOT EXECUTED
35a00: e1a03004 mov r3, r4 <== NOT EXECUTED
35a04: e59f012c ldr r0, [pc, #300] ; 35b38 <rtems_rfs_file_io_end+0x19c><== NOT EXECUTED
35a08: eb002e9a bl 41478 <printf> <== NOT EXECUTED
"rtems-rfs: file-io: end: error on release: %s size=%zu: %d: %s\n",
read ? "read" : "write", size, rc, strerror (rc));
return rc;
35a0c: ea000045 b 35b28 <rtems_rfs_file_io_end+0x18c> <== 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;
35a10: e5952014 ldr r2, [r5, #20] <== NOT EXECUTED
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
35a14: 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;
35a18: e0877002 add r7, r7, r2 <== NOT EXECUTED
35a1c: e5857014 str r7, [r5, #20] <== NOT EXECUTED
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
35a20: e5933098 ldr r3, [r3, #152] ; 0x98 <== NOT EXECUTED
35a24: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED
35a28: e1570002 cmp r7, r2 <== NOT EXECUTED
35a2c: 3a000005 bcc 35a48 <rtems_rfs_file_io_end+0xac> <== NOT EXECUTED
{
handle->bpos.bno++;
35a30: e5952010 ldr r2, [r5, #16] <== NOT EXECUTED
35a34: e2822001 add r2, r2, #1 <== NOT EXECUTED
35a38: e5852010 str r2, [r5, #16] <== NOT EXECUTED
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
35a3c: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
35a40: e0637007 rsb r7, r3, r7 <== NOT EXECUTED
35a44: e5857014 str r7, [r5, #20] <== NOT EXECUTED
}
length = false;
mtime = false;
if (!read &&
35a48: e3560000 cmp r6, #0 <== NOT EXECUTED
35a4c: 1a000018 bne 35ab4 <rtems_rfs_file_io_end+0x118> <== NOT EXECUTED
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
35a50: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
}
length = false;
mtime = false;
if (!read &&
35a54: e3530000 cmp r3, #0 <== NOT EXECUTED
35a58: 0a000003 beq 35a6c <rtems_rfs_file_io_end+0xd0> <== NOT EXECUTED
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
35a5c: e595201c ldr r2, [r5, #28] <== NOT EXECUTED
35a60: e592203c ldr r2, [r2, #60] ; 0x3c <== NOT EXECUTED
35a64: e3520000 cmp r2, #0 <== NOT EXECUTED
35a68: 0a00000a beq 35a98 <rtems_rfs_file_io_end+0xfc> <== NOT EXECUTED
35a6c: e595201c ldr r2, [r5, #28] <== NOT EXECUTED
35a70: e592103c ldr r1, [r2, #60] ; 0x3c <== NOT EXECUTED
}
length = false;
mtime = false;
if (!read &&
35a74: e1530001 cmp r3, r1 <== NOT EXECUTED
35a78: 2a000006 bcs 35a98 <rtems_rfs_file_io_end+0xfc> <== NOT EXECUTED
35a7c: e2411001 sub r1, r1, #1 <== NOT EXECUTED
35a80: e1530001 cmp r3, r1 <== NOT EXECUTED
35a84: 1a00000a bne 35ab4 <rtems_rfs_file_io_end+0x118> <== NOT EXECUTED
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
35a88: e5923040 ldr r3, [r2, #64] ; 0x40 <== NOT EXECUTED
35a8c: e5952014 ldr r2, [r5, #20] <== NOT EXECUTED
35a90: e1520003 cmp r2, r3 <== NOT EXECUTED
35a94: 9a000006 bls 35ab4 <rtems_rfs_file_io_end+0x118> <== NOT EXECUTED
rtems_rfs_file_bpos (handle)))
{
rtems_rfs_block_map_set_size_offset (rtems_rfs_file_map (handle),
35a98: e595301c ldr r3, [r5, #28] <== 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;
35a9c: e5951014 ldr r1, [r5, #20] <== NOT EXECUTED
map->dirty = true;
35aa0: e3a02001 mov r2, #1 <== NOT EXECUTED
35aa4: 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;
35aa8: e5831040 str r1, [r3, #64] ; 0x40 <== NOT EXECUTED
map->dirty = true;
35aac: e5c32034 strb r2, [r3, #52] ; 0x34 <== NOT EXECUTED
35ab0: ea000000 b 35ab8 <rtems_rfs_file_io_end+0x11c> <== NOT EXECUTED
35ab4: e3a08000 mov r8, #0 <== NOT EXECUTED
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
35ab8: e595a000 ldr sl, [r5] <== NOT EXECUTED
35abc: e1a07008 mov r7, r8 <== NOT EXECUTED
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
35ac0: e31a0002 tst sl, #2 <== NOT EXECUTED
35ac4: 13a07000 movne r7, #0 <== NOT EXECUTED
length = rtems_rfs_file_update_length (handle) && length;
35ac8: e31a0004 tst sl, #4 <== NOT EXECUTED
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
35acc: e22aa001 eor sl, sl, #1 <== NOT EXECUTED
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
length = rtems_rfs_file_update_length (handle) && length;
35ad0: 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)
35ad4: e21aa001 ands sl, sl, #1 <== NOT EXECUTED
35ad8: 1a000001 bne 35ae4 <rtems_rfs_file_io_end+0x148> <== NOT EXECUTED
35adc: e3570000 cmp r7, #0 <== NOT EXECUTED
35ae0: 0a00000a beq 35b10 <rtems_rfs_file_io_end+0x174> <== NOT EXECUTED
{
time_t now = time (NULL);
35ae4: e3a00000 mov r0, #0 <== NOT EXECUTED
35ae8: eb004c76 bl 48cc8 <time> <== NOT EXECUTED
if (read && atime)
35aec: e3560000 cmp r6, #0 <== NOT EXECUTED
35af0: 0a000003 beq 35b04 <rtems_rfs_file_io_end+0x168> <== NOT EXECUTED
35af4: e35a0000 cmp sl, #0 <== NOT EXECUTED
handle->shared->atime = now;
35af8: 1595301c ldrne r3, [r5, #28] <== NOT EXECUTED
35afc: 1583008c strne r0, [r3, #140] ; 0x8c <== NOT EXECUTED
35b00: ea000002 b 35b10 <rtems_rfs_file_io_end+0x174> <== NOT EXECUTED
if (!read && mtime)
35b04: e3570000 cmp r7, #0 <== NOT EXECUTED
handle->shared->mtime = now;
35b08: 1595301c ldrne r3, [r5, #28] <== NOT EXECUTED
35b0c: 15830090 strne r0, [r3, #144] ; 0x90 <== NOT EXECUTED
}
if (length)
35b10: e3580000 cmp r8, #0 <== NOT EXECUTED
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
35b14: 1595301c ldrne r3, [r5, #28] <== NOT EXECUTED
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
35b18: 1593203c ldrne r2, [r3, #60] ; 0x3c <== NOT EXECUTED
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
35b1c: 15931040 ldrne r1, [r3, #64] ; 0x40 <== NOT EXECUTED
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
35b20: 15832084 strne r2, [r3, #132] ; 0x84 <== NOT EXECUTED
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
35b24: 15831088 strne r1, [r3, #136] ; 0x88 <== NOT EXECUTED
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
35b28: e1a00004 mov r0, r4 <== NOT EXECUTED
35b2c: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
000355f4 <rtems_rfs_file_io_release>:
return rc;
}
int
rtems_rfs_file_io_release (rtems_rfs_file_handle* handle)
{
355f4: e1a01000 mov r1, r0 <== NOT EXECUTED
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
355f8: e590000c ldr r0, [r0, #12] <== NOT EXECUTED
355fc: e3500000 cmp r0, #0 <== NOT EXECUTED
35600: 012fff1e bxeq lr <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
35604: e591301c ldr r3, [r1, #28] <== NOT EXECUTED
35608: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
3560c: e2811004 add r1, r1, #4 <== NOT EXECUTED
35610: eafffbe9 b 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
000354b8 <rtems_rfs_file_io_start>:
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
354b8: e92d41f1 push {r0, 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))
354bc: e590700c ldr r7, [r0, #12] <== NOT EXECUTED
354c0: e3570000 cmp r7, #0 <== NOT EXECUTED
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
354c4: e1a04000 mov r4, r0 <== NOT EXECUTED
354c8: e1a06001 mov r6, r1 <== NOT EXECUTED
354cc: 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))
354d0: 1a00002f bne 35594 <rtems_rfs_file_io_start+0xdc> <== NOT EXECUTED
bool request_read;
int rc;
request_read = read;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
354d4: e590301c ldr r3, [r0, #28] <== NOT EXECUTED
354d8: e2842010 add r2, r4, #16 <== NOT EXECUTED
354dc: e2831034 add r1, r3, #52 ; 0x34 <== NOT EXECUTED
354e0: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
354e4: e1a0300d mov r3, sp <== NOT EXECUTED
354e8: ebfff871 bl 336b4 <rtems_rfs_block_map_find> <== NOT EXECUTED
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
354ec: 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),
354f0: e1a0800d mov r8, sp <== NOT EXECUTED
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
354f4: da000010 ble 3553c <rtems_rfs_file_io_start+0x84> <== NOT EXECUTED
{
/*
* Has the read reached the EOF ?
*/
if (read && (rc == ENXIO))
354f8: e3550000 cmp r5, #0 <== NOT EXECUTED
354fc: 0a000003 beq 35510 <rtems_rfs_file_io_start+0x58> <== NOT EXECUTED
35500: e3500006 cmp r0, #6 <== NOT EXECUTED
{
*available = 0;
35504: 05867000 streq r7, [r6] <== NOT EXECUTED
35508: 01a00007 moveq r0, r7 <== NOT EXECUTED
3550c: ea000037 b 355f0 <rtems_rfs_file_io_start+0x138> <== NOT EXECUTED
return 0;
}
if (rc != ENXIO)
35510: e3500006 cmp r0, #6 <== NOT EXECUTED
35514: 1a000035 bne 355f0 <rtems_rfs_file_io_start+0x138> <== 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),
35518: e594201c ldr r2, [r4, #28] <== NOT EXECUTED
3551c: e1a0300d mov r3, sp <== NOT EXECUTED
35520: e2821034 add r1, r2, #52 ; 0x34 <== NOT EXECUTED
35524: e5920098 ldr r0, [r2, #152] ; 0x98 <== NOT EXECUTED
35528: e3a02001 mov r2, #1 <== NOT EXECUTED
3552c: ebfff9fd bl 33d28 <rtems_rfs_block_map_grow> <== NOT EXECUTED
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
35530: e3500000 cmp r0, #0 <== NOT EXECUTED
35534: ca00002d bgt 355f0 <rtems_rfs_file_io_start+0x138> <== NOT EXECUTED
35538: ea00000b b 3556c <rtems_rfs_file_io_start+0xb4> <== 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 &&
3553c: e3550000 cmp r5, #0 <== NOT EXECUTED
35540: 11a03005 movne r3, r5 <== NOT EXECUTED
35544: 1a00000b bne 35578 <rtems_rfs_file_io_start+0xc0> <== NOT EXECUTED
(rtems_rfs_file_block_offset (handle) ||
35548: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
3554c: e3530000 cmp r3, #0 <== NOT EXECUTED
35550: 1a000007 bne 35574 <rtems_rfs_file_io_start+0xbc> <== NOT EXECUTED
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
35554: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
35558: e5933098 ldr r3, [r3, #152] ; 0x98 <== NOT EXECUTED
3555c: e5962000 ldr r2, [r6] <== NOT EXECUTED
35560: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
35564: e1520003 cmp r2, r3 <== NOT EXECUTED
35568: 3a000001 bcc 35574 <rtems_rfs_file_io_start+0xbc> <== NOT EXECUTED
3556c: e3a03000 mov r3, #0 <== NOT EXECUTED
35570: ea000000 b 35578 <rtems_rfs_file_io_start+0xc0> <== NOT EXECUTED
35574: 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),
35578: e594201c ldr r2, [r4, #28] <== NOT EXECUTED
3557c: e2841004 add r1, r4, #4 <== NOT EXECUTED
35580: e5920098 ldr r0, [r2, #152] ; 0x98 <== NOT EXECUTED
35584: e59d2000 ldr r2, [sp] <== NOT EXECUTED
35588: ebfffc54 bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
rtems_rfs_file_buffer (handle),
block, request_read);
if (rc > 0)
3558c: e3500000 cmp r0, #0 <== NOT EXECUTED
35590: ca000016 bgt 355f0 <rtems_rfs_file_io_start+0x138> <== NOT EXECUTED
return rc;
}
if (read
35594: e3550000 cmp r5, #0 <== NOT EXECUTED
35598: 0a00000d beq 355d4 <rtems_rfs_file_io_start+0x11c> <== NOT EXECUTED
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
3559c: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
355a0: e5932044 ldr r2, [r3, #68] ; 0x44 <== NOT EXECUTED
block, request_read);
if (rc > 0)
return rc;
}
if (read
355a4: e3520000 cmp r2, #0 <== NOT EXECUTED
355a8: 1a000002 bne 355b8 <rtems_rfs_file_io_start+0x100> <== NOT EXECUTED
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
355ac: e593103c ldr r1, [r3, #60] ; 0x3c <== NOT EXECUTED
355b0: e3510000 cmp r1, #0 <== NOT EXECUTED
355b4: 0a000003 beq 355c8 <rtems_rfs_file_io_start+0x110> <== NOT EXECUTED
block, request_read);
if (rc > 0)
return rc;
}
if (read
355b8: e593103c ldr r1, [r3, #60] ; 0x3c <== NOT EXECUTED
355bc: e2411001 sub r1, r1, #1 <== NOT EXECUTED
355c0: e1520001 cmp r2, r1 <== NOT EXECUTED
355c4: 1a000002 bne 355d4 <rtems_rfs_file_io_start+0x11c> <== NOT EXECUTED
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
355c8: e5933040 ldr r3, [r3, #64] ; 0x40 <== NOT EXECUTED
block, request_read);
if (rc > 0)
return rc;
}
if (read
355cc: e3530000 cmp r3, #0 <== NOT EXECUTED
355d0: 1a000002 bne 355e0 <rtems_rfs_file_io_start+0x128> <== 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));
355d4: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
355d8: e5933098 ldr r3, [r3, #152] ; 0x98 <== NOT EXECUTED
355dc: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
*available = size - rtems_rfs_file_block_offset (handle);
355e0: e5942014 ldr r2, [r4, #20] <== NOT EXECUTED
355e4: e0623003 rsb r3, r2, r3 <== NOT EXECUTED
355e8: e5863000 str r3, [r6] <== NOT EXECUTED
355ec: 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;
}
355f0: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00035cf0 <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)
{
35cf0: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, 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;
35cf4: e3a05000 mov r5, #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)
{
35cf8: e1a06000 mov r6, 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;
35cfc: e5835000 str r5, [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));
35d00: 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)
{
35d04: e1a08003 mov r8, r3 <== NOT EXECUTED
35d08: e1a0a001 mov sl, r1 <== NOT EXECUTED
35d0c: 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));
35d10: ebff480e bl 7d50 <malloc> <== NOT EXECUTED
if (!handle)
35d14: e2504000 subs r4, r0, #0 <== NOT EXECUTED
35d18: 0a000020 beq 35da0 <rtems_rfs_file_open+0xb0> <== NOT EXECUTED
return ENOMEM;
memset (handle, 0, sizeof (rtems_rfs_file_handle));
35d1c: e3a02020 mov r2, #32 <== NOT EXECUTED
35d20: e1a01005 mov r1, r5 <== NOT EXECUTED
35d24: eb0029ac bl 403dc <memset> <== 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;
35d28: e584500c str r5, [r4, #12] <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
35d2c: e5c45004 strb r5, [r4, #4] <== NOT EXECUTED
handle->bnum = 0;
35d30: e5845008 str r5, [r4, #8] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return the_chain->first;
35d34: e5963070 ldr r3, [r6, #112] ; 0x70 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
35d38: e2862074 add r2, r6, #116 ; 0x74 <== NOT EXECUTED
35d3c: ea000004 b 35d54 <rtems_rfs_file_open+0x64> <== NOT EXECUTED
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;
if (shared->inode.ino == ino)
35d40: e5931014 ldr r1, [r3, #20] <== NOT EXECUTED
35d44: e151000a cmp r1, sl <== 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;
35d48: e1a05003 mov r5, r3 <== NOT EXECUTED
if (shared->inode.ino == ino)
35d4c: 0a000003 beq 35d60 <rtems_rfs_file_open+0x70> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
35d50: 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))
35d54: e1530002 cmp r3, r2 <== NOT EXECUTED
35d58: 1afffff8 bne 35d40 <rtems_rfs_file_open+0x50> <== NOT EXECUTED
35d5c: ea000003 b 35d70 <rtems_rfs_file_open+0x80> <== NOT EXECUTED
* the reference count and return the pointer to the data.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
if (shared)
{
shared->references++;
35d60: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
35d64: e2833001 add r3, r3, #1 <== NOT EXECUTED
35d68: e5853008 str r3, [r5, #8] <== NOT EXECUTED
35d6c: ea000060 b 35ef4 <rtems_rfs_file_open+0x204> <== 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));
35d70: e3a0009c mov r0, #156 ; 0x9c <== NOT EXECUTED
35d74: ebff47f5 bl 7d50 <malloc> <== NOT EXECUTED
if (!shared)
35d78: e2505000 subs r5, r0, #0 <== NOT EXECUTED
35d7c: 1a000009 bne 35da8 <rtems_rfs_file_open+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);
35d80: e1a00006 mov r0, r6 <== NOT EXECUTED
35d84: e2841004 add r1, r4, #4 <== NOT EXECUTED
35d88: ebfffa0b bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
handle->buffer = NULL;
35d8c: e584500c str r5, [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;
35d90: e5c45004 strb r5, [r4, #4] <== NOT EXECUTED
handle->bnum = 0;
35d94: e5845008 str r5, [r4, #8] <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
35d98: e1a00004 mov r0, r4 <== NOT EXECUTED
35d9c: ebff4644 bl 76b4 <free> <== NOT EXECUTED
35da0: e3a0a00c mov sl, #12 <== NOT EXECUTED
return ENOMEM;
35da4: ea000056 b 35f04 <rtems_rfs_file_open+0x214> <== NOT EXECUTED
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
35da8: e3a01000 mov r1, #0 <== NOT EXECUTED
35dac: e3a0209c mov r2, #156 ; 0x9c <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
35db0: e285700c add r7, r5, #12 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
35db4: eb002988 bl 403dc <memset> <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
35db8: e1a0100a mov r1, sl <== NOT EXECUTED
35dbc: e1a00006 mov r0, r6 <== NOT EXECUTED
35dc0: e1a02007 mov r2, r7 <== NOT EXECUTED
35dc4: e3a03001 mov r3, #1 <== NOT EXECUTED
35dc8: eb0006ed bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
35dcc: e250a000 subs sl, r0, #0 <== NOT EXECUTED
35dd0: ca000008 bgt 35df8 <rtems_rfs_file_open+0x108> <== 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);
35dd4: e1a00006 mov r0, r6 <== NOT EXECUTED
35dd8: e1a01007 mov r1, r7 <== NOT EXECUTED
35ddc: e2852034 add r2, r5, #52 ; 0x34 <== NOT EXECUTED
35de0: ebfff92e bl 342a0 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
35de4: e250a000 subs sl, r0, #0 <== NOT EXECUTED
35de8: da00000e ble 35e28 <rtems_rfs_file_open+0x138> <== 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);
35dec: e1a01007 mov r1, r7 <== NOT EXECUTED
35df0: e1a00006 mov r0, r6 <== NOT EXECUTED
35df4: eb0006bf bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
free (shared);
35df8: e1a00005 mov r0, r5 <== NOT EXECUTED
35dfc: ebff462c bl 76b4 <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);
35e00: e1a00006 mov r0, r6 <== NOT EXECUTED
35e04: e2841004 add r1, r4, #4 <== NOT EXECUTED
35e08: ebfff9eb bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
35e0c: e3a03000 mov r3, #0 <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
35e10: 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;
35e14: e5c43004 strb r3, [r4, #4] <== NOT EXECUTED
handle->bnum = 0;
35e18: e5843008 str r3, [r4, #8] <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
35e1c: e1a00004 mov r0, r4 <== NOT EXECUTED
35e20: ebff4623 bl 76b4 <free> <== NOT EXECUTED
return rc;
35e24: ea000036 b 35f04 <rtems_rfs_file_open+0x214> <== 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);
35e28: e5953018 ldr r3, [r5, #24] <== NOT EXECUTED
}
shared->references = 1;
35e2c: e3a02001 mov r2, #1 <== NOT EXECUTED
35e30: e5852008 str r2, [r5, #8] <== NOT EXECUTED
35e34: e283200c add r2, r3, #12 <== NOT EXECUTED
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
35e38: e5d21003 ldrb r1, [r2, #3] <== NOT EXECUTED
35e3c: e5d3000c ldrb r0, [r3, #12] <== NOT EXECUTED
35e40: e5d2c001 ldrb ip, [r2, #1] <== NOT EXECUTED
35e44: e1810c00 orr r0, r1, r0, lsl #24 <== NOT EXECUTED
35e48: e5d21002 ldrb r1, [r2, #2] <== NOT EXECUTED
35e4c: e180280c orr r2, r0, ip, lsl #16 <== NOT EXECUTED
35e50: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED
35e54: e5852084 str r2, [r5, #132] ; 0x84 <== NOT EXECUTED
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
35e58: e5d3100a ldrb r1, [r3, #10] <== NOT EXECUTED
35e5c: e5d3200b ldrb r2, [r3, #11] <== NOT EXECUTED
35e60: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED
35e64: e5852088 str r2, [r5, #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);
35e68: e2832010 add r2, r3, #16 <== NOT EXECUTED
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
35e6c: e5d21003 ldrb r1, [r2, #3] <== NOT EXECUTED
35e70: e5d30010 ldrb r0, [r3, #16] <== NOT EXECUTED
35e74: e5d2c001 ldrb ip, [r2, #1] <== NOT EXECUTED
35e78: e1810c00 orr r0, r1, r0, lsl #24 <== NOT EXECUTED
35e7c: e5d21002 ldrb r1, [r2, #2] <== NOT EXECUTED
35e80: e180280c orr r2, r0, ip, lsl #16 <== NOT EXECUTED
35e84: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED
35e88: e585208c str r2, [r5, #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);
35e8c: e2832014 add r2, r3, #20 <== NOT EXECUTED
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
35e90: e5d21003 ldrb r1, [r2, #3] <== NOT EXECUTED
35e94: e5d30014 ldrb r0, [r3, #20] <== NOT EXECUTED
35e98: e5d2c001 ldrb ip, [r2, #1] <== NOT EXECUTED
35e9c: e1810c00 orr r0, r1, r0, lsl #24 <== NOT EXECUTED
35ea0: e5d21002 ldrb r1, [r2, #2] <== NOT EXECUTED
35ea4: e180280c orr r2, r0, ip, lsl #16 <== NOT EXECUTED
35ea8: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED
35eac: e5852090 str r2, [r5, #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);
35eb0: e2832018 add r2, r3, #24 <== NOT EXECUTED
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
35eb4: e5d30018 ldrb r0, [r3, #24] <== NOT EXECUTED
35eb8: e5d23003 ldrb r3, [r2, #3] <== NOT EXECUTED
35ebc: e5d21001 ldrb r1, [r2, #1] <== NOT EXECUTED
35ec0: e1833c00 orr r3, r3, r0, lsl #24 <== NOT EXECUTED
35ec4: e5d22002 ldrb r2, [r2, #2] <== NOT EXECUTED
35ec8: e1833801 orr r3, r3, r1, lsl #16 <== NOT EXECUTED
35ecc: 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 );
35ed0: e2860070 add r0, r6, #112 ; 0x70 <== NOT EXECUTED
35ed4: e1a01005 mov r1, r5 <== NOT EXECUTED
35ed8: e5853094 str r3, [r5, #148] ; 0x94 <== NOT EXECUTED
shared->fs = fs;
35edc: e5856098 str r6, [r5, #152] ; 0x98 <== NOT EXECUTED
35ee0: ebff594b bl c414 <_Chain_Append> <== NOT EXECUTED
rtems_chain_append (&fs->file_shares, &shared->link);
rtems_rfs_inode_unload (fs, &shared->inode, false);
35ee4: e1a00006 mov r0, r6 <== NOT EXECUTED
35ee8: e1a01007 mov r1, r7 <== NOT EXECUTED
35eec: e3a02000 mov r2, #0 <== NOT EXECUTED
35ef0: eb000656 bl 37850 <rtems_rfs_inode_unload> <== NOT EXECUTED
}
handle->flags = flags;
handle->shared = shared;
*file = handle;
35ef4: e5884000 str r4, [r8] <== 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;
35ef8: e5849000 str r9, [r4] <== NOT EXECUTED
handle->shared = shared;
35efc: e584501c str r5, [r4, #28] <== NOT EXECUTED
*file = handle;
35f00: e3a0a000 mov sl, #0 <== NOT EXECUTED
return 0;
}
35f04: e1a0000a mov r0, sl <== NOT EXECUTED
35f08: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
000358dc <rtems_rfs_file_seek>:
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
358dc: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
358e0: 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),
358e4: 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)
{
358e8: e1a05001 mov r5, r1 <== NOT EXECUTED
358ec: e2801084 add r1, r0, #132 ; 0x84 <== NOT EXECUTED
358f0: e5900098 ldr r0, [r0, #152] ; 0x98 <== NOT EXECUTED
358f4: e1a06002 mov r6, r2 <== NOT EXECUTED
358f8: e1a08003 mov r8, r3 <== NOT EXECUTED
358fc: ebfff73e bl 335fc <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),
35900: e1510006 cmp r1, r6 <== NOT EXECUTED
35904: 8a000002 bhi 35914 <rtems_rfs_file_seek+0x38> <== NOT EXECUTED
35908: 1a00001c bne 35980 <rtems_rfs_file_seek+0xa4> <== NOT EXECUTED
3590c: e1500005 cmp r0, r5 <== NOT EXECUTED
35910: 9a00001a bls 35980 <rtems_rfs_file_seek+0xa4> <== NOT EXECUTED
handle->shared))
{
rtems_rfs_file_set_bpos (handle, pos);
35914: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
35918: e2847010 add r7, r4, #16 <== NOT EXECUTED
3591c: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
35920: e1a01005 mov r1, r5 <== NOT EXECUTED
35924: e1a03007 mov r3, r7 <== NOT EXECUTED
35928: e1a02006 mov r2, r6 <== NOT EXECUTED
3592c: ebfff703 bl 33540 <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))
35930: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
35934: e3530000 cmp r3, #0 <== NOT EXECUTED
35938: 0a000014 beq 35990 <rtems_rfs_file_seek+0xb4> <== NOT EXECUTED
{
rtems_rfs_buffer_block block;
int rc;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
3593c: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
35940: e1a02007 mov r2, r7 <== NOT EXECUTED
35944: e2831034 add r1, r3, #52 ; 0x34 <== NOT EXECUTED
35948: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
3594c: e1a0300d mov r3, sp <== NOT EXECUTED
35950: ebfff757 bl 336b4 <rtems_rfs_block_map_find> <== NOT EXECUTED
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
35954: e3500000 cmp r0, #0 <== NOT EXECUTED
35958: ca00000e bgt 35998 <rtems_rfs_file_seek+0xbc> <== NOT EXECUTED
return rc;
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
3595c: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED
35960: e59d3000 ldr r3, [sp] <== NOT EXECUTED
35964: e1520003 cmp r2, r3 <== NOT EXECUTED
35968: 0a000008 beq 35990 <rtems_rfs_file_seek+0xb4> <== NOT EXECUTED
{
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
3596c: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
35970: e2841004 add r1, r4, #4 <== NOT EXECUTED
35974: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
35978: ebfffb0f bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
3597c: ea000001 b 35988 <rtems_rfs_file_seek+0xac> <== 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);
35980: e1a00004 mov r0, r4 <== NOT EXECUTED
35984: ebffff1a bl 355f4 <rtems_rfs_file_io_release> <== NOT EXECUTED
if (rc > 0)
35988: e3500000 cmp r0, #0 <== NOT EXECUTED
3598c: ca000001 bgt 35998 <rtems_rfs_file_seek+0xbc> <== NOT EXECUTED
return rc;
}
*new_pos = pos;
35990: e8880060 stm r8, {r5, r6} <== NOT EXECUTED
35994: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
}
35998: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00035614 <rtems_rfs_file_set_size>:
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
35614: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
35618: e590501c ldr r5, [r0, #28] <== NOT EXECUTED
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
3561c: e1a06001 mov r6, r1 <== NOT EXECUTED
35620: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
35624: e1a04000 mov r4, r0 <== NOT EXECUTED
35628: e2851084 add r1, r5, #132 ; 0x84 <== NOT EXECUTED
3562c: e5950098 ldr r0, [r5, #152] ; 0x98 <== NOT EXECUTED
35630: e1a07002 mov r7, r2 <== NOT EXECUTED
35634: ebfff7f0 bl 335fc <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)
35638: e1500006 cmp r0, r6 <== NOT EXECUTED
3563c: 1a000001 bne 35648 <rtems_rfs_file_set_size+0x34> <== NOT EXECUTED
35640: e1510007 cmp r1, r7 <== NOT EXECUTED
35644: 0a0000a1 beq 358d0 <rtems_rfs_file_set_size+0x2bc> <== NOT EXECUTED
{
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
35648: e1962007 orrs r2, r6, r7 <== 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);
3564c: 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)
35650: 1a000006 bne 35670 <rtems_rfs_file_set_size+0x5c> <== NOT EXECUTED
{
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
35654: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
35658: e1a01009 mov r1, r9 <== NOT EXECUTED
3565c: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
35660: ebfff968 bl 33c08 <rtems_rfs_block_map_free_all> <== NOT EXECUTED
if (rc > 0)
35664: e3500000 cmp r0, #0 <== NOT EXECUTED
35668: ca000099 bgt 358d4 <rtems_rfs_file_set_size+0x2c0> <== NOT EXECUTED
3566c: ea00008a b 3589c <rtems_rfs_file_set_size+0x288> <== NOT EXECUTED
return rc;
}
else
{
if (size < new_size)
35670: e1570001 cmp r7, r1 <== NOT EXECUTED
35674: 8a000002 bhi 35684 <rtems_rfs_file_set_size+0x70> <== NOT EXECUTED
35678: 1a000054 bne 357d0 <rtems_rfs_file_set_size+0x1bc> <== NOT EXECUTED
3567c: e1560000 cmp r6, r0 <== NOT EXECUTED
35680: 9a000052 bls 357d0 <rtems_rfs_file_set_size+0x1bc> <== 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));
35684: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
35688: e5933098 ldr r3, [r3, #152] ; 0x98 <== 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),
3568c: e3a02000 mov r2, #0 <== NOT EXECUTED
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
35690: e1a0a006 mov sl, r6 <== NOT EXECUTED
35694: e1a0b007 mov fp, r7 <== NOT EXECUTED
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
35698: e5936008 ldr r6, [r3, #8] <== 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),
3569c: e2843004 add r3, r4, #4 <== NOT EXECUTED
356a0: e58d2000 str r2, [sp] <== NOT EXECUTED
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
356a4: e05aa000 subs sl, sl, r0 <== NOT EXECUTED
356a8: e0cbb001 sbc fp, fp, r1 <== 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),
356ac: e58d3004 str r3, [sp, #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);
356b0: e1a07002 mov r7, r2 <== NOT EXECUTED
* Have we reached the EOF ?
*/
if (rc != ENXIO)
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
356b4: e3a08001 mov r8, #1 <== NOT EXECUTED
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
while (count)
356b8: ea000041 b 357c4 <rtems_rfs_file_set_size+0x1b0> <== 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);
356bc: e595303c ldr r3, [r5, #60] ; 0x3c <== NOT EXECUTED
356c0: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
356c4: e5952040 ldr r2, [r5, #64] ; 0x40 <== NOT EXECUTED
356c8: e3520000 cmp r2, #0 <== NOT EXECUTED
356cc: 12433001 subne r3, r3, #1 <== NOT EXECUTED
356d0: 158d3008 strne r3, [sp, #8] <== NOT EXECUTED
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
356d4: e594301c ldr r3, [r4, #28] <== 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);
356d8: e58d200c str r2, [sp, #12] <== NOT EXECUTED
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
356dc: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
356e0: e1a01009 mov r1, r9 <== NOT EXECUTED
356e4: e28d2008 add r2, sp, #8 <== NOT EXECUTED
356e8: 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);
356ec: e58d7010 str r7, [sp, #16] <== NOT EXECUTED
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
356f0: ebfff7ef bl 336b4 <rtems_rfs_block_map_find> <== NOT EXECUTED
map, &bpos, &block);
if (rc > 0)
356f4: e3500000 cmp r0, #0 <== NOT EXECUTED
356f8: da000009 ble 35724 <rtems_rfs_file_set_size+0x110> <== NOT EXECUTED
{
/*
* Have we reached the EOF ?
*/
if (rc != ENXIO)
356fc: e3500006 cmp r0, #6 <== NOT EXECUTED
35700: 1a000073 bne 358d4 <rtems_rfs_file_set_size+0x2c0> <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
35704: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
35708: e1a01009 mov r1, r9 <== NOT EXECUTED
3570c: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
35710: e3a02001 mov r2, #1 <== NOT EXECUTED
35714: e28d3014 add r3, sp, #20 <== NOT EXECUTED
35718: ebfff982 bl 33d28 <rtems_rfs_block_map_grow> <== NOT EXECUTED
map, 1, &block);
if (rc > 0)
3571c: e3500000 cmp r0, #0 <== NOT EXECUTED
35720: ca00006b bgt 358d4 <rtems_rfs_file_set_size+0x2c0> <== NOT EXECUTED
return rc;
}
if (count < (length - bpos.boff))
35724: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
35728: e157000b cmp r7, fp <== NOT EXECUTED
3572c: e0632006 rsb r2, r3, r6 <== NOT EXECUTED
35730: 1a000007 bne 35754 <rtems_rfs_file_set_size+0x140> <== NOT EXECUTED
35734: e152000a cmp r2, sl <== NOT EXECUTED
35738: 9a000005 bls 35754 <rtems_rfs_file_set_size+0x140> <== NOT EXECUTED
{
length = count + bpos.boff;
3573c: e083600a add r6, r3, sl <== 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;
35740: e3a02001 mov r2, #1 <== 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;
35744: e5856040 str r6, [r5, #64] ; 0x40 <== NOT EXECUTED
map->dirty = true;
35748: e5c58034 strb r8, [r5, #52] ; 0x34 <== NOT EXECUTED
3574c: e58d2000 str r2, [sp] <== NOT EXECUTED
35750: ea000001 b 3575c <rtems_rfs_file_set_size+0x148> <== 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;
35754: e5857040 str r7, [r5, #64] ; 0x40 <== NOT EXECUTED
map->dirty = true;
35758: e5c58034 strb r8, [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),
3575c: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
35760: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
35764: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
35768: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED
3576c: e59d3000 ldr r3, [sp] <== NOT EXECUTED
35770: ebfffbda bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
35774: e3500000 cmp r0, #0 <== NOT EXECUTED
35778: ca000055 bgt 358d4 <rtems_rfs_file_set_size+0x2c0> <== NOT EXECUTED
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
memset (dst + bpos.boff, 0, length - bpos.boff);
3577c: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
35780: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED
35784: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
35788: e3a01000 mov r1, #0 <== NOT EXECUTED
3578c: e0632006 rsb r2, r3, r6 <== NOT EXECUTED
35790: e0800003 add r0, r0, r3 <== NOT EXECUTED
35794: eb002b10 bl 403dc <memset> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
35798: 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));
3579c: e5c48004 strb r8, [r4, #4] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
357a0: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
357a4: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
357a8: ebfffb83 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
if (rc > 0)
357ac: e3500000 cmp r0, #0 <== NOT EXECUTED
357b0: ca000047 bgt 358d4 <rtems_rfs_file_set_size+0x2c0> <== NOT EXECUTED
return rc;
count -= length - bpos.boff;
357b4: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
357b8: e0633006 rsb r3, r3, r6 <== NOT EXECUTED
357bc: e05aa003 subs sl, sl, r3 <== NOT EXECUTED
357c0: e2cbb000 sbc fp, fp, #0 <== NOT EXECUTED
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
while (count)
357c4: e19a300b orrs r3, sl, fp <== NOT EXECUTED
357c8: 1affffbb bne 356bc <rtems_rfs_file_set_size+0xa8> <== NOT EXECUTED
357cc: ea000032 b 3589c <rtems_rfs_file_set_size+0x288> <== 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);
357d0: e594a01c ldr sl, [r4, #28] <== NOT EXECUTED
357d4: e59a8098 ldr r8, [sl, #152] ; 0x98 <== NOT EXECUTED
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
357d8: e3e00000 mvn r0, #0 <== NOT EXECUTED
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
357dc: e5989008 ldr r9, [r8, #8] <== NOT EXECUTED
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
357e0: e0900006 adds r0, r0, r6 <== NOT EXECUTED
357e4: e3e01000 mvn r1, #0 <== NOT EXECUTED
357e8: e0a11007 adc r1, r1, r7 <== NOT EXECUTED
357ec: e1a02009 mov r2, r9 <== NOT EXECUTED
357f0: e3a03000 mov r3, #0 <== NOT EXECUTED
357f4: eb008199 bl 55e60 <__udivdi3> <== NOT EXECUTED
357f8: e595303c ldr r3, [r5, #60] ; 0x3c <== NOT EXECUTED
357fc: 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)
35800: e0922003 adds r2, r2, r3 <== NOT EXECUTED
35804: 0a000004 beq 3581c <rtems_rfs_file_set_size+0x208> <== NOT EXECUTED
{
int rc;
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
35808: e1a00008 mov r0, r8 <== NOT EXECUTED
3580c: e28a1034 add r1, sl, #52 ; 0x34 <== NOT EXECUTED
35810: ebfff84c bl 33948 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
rtems_rfs_file_map (handle),
blocks);
if (rc > 0)
35814: e3500000 cmp r0, #0 <== NOT EXECUTED
35818: ca00002d bgt 358d4 <rtems_rfs_file_set_size+0x2c0> <== NOT EXECUTED
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
3581c: e1a02009 mov r2, r9 <== NOT EXECUTED
35820: e3a03000 mov r3, #0 <== NOT EXECUTED
35824: e1a00006 mov r0, r6 <== NOT EXECUTED
35828: e1a01007 mov r1, r7 <== NOT EXECUTED
3582c: eb00829c bl 562a4 <__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;
35830: 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),
35834: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
map->dirty = true;
35838: e3a02001 mov r2, #1 <== NOT EXECUTED
3583c: e3530000 cmp r3, #0 <== NOT EXECUTED
35840: e5c52034 strb r2, [r5, #52] ; 0x34 <== NOT EXECUTED
35844: 0a000002 beq 35854 <rtems_rfs_file_set_size+0x240> <== 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);
35848: e595203c ldr r2, [r5, #60] ; 0x3c <== NOT EXECUTED
3584c: e3520000 cmp r2, #0 <== NOT EXECUTED
35850: 0a000008 beq 35878 <rtems_rfs_file_set_size+0x264> <== 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),
35854: e595203c ldr r2, [r5, #60] ; 0x3c <== NOT EXECUTED
35858: e1530002 cmp r3, r2 <== NOT EXECUTED
3585c: 2a000005 bcs 35878 <rtems_rfs_file_set_size+0x264> <== NOT EXECUTED
35860: e2422001 sub r2, r2, #1 <== NOT EXECUTED
35864: e1530002 cmp r3, r2 <== NOT EXECUTED
35868: 1a00000b bne 3589c <rtems_rfs_file_set_size+0x288> <== NOT EXECUTED
3586c: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
35870: e1530000 cmp r3, r0 <== NOT EXECUTED
35874: 9a000008 bls 3589c <rtems_rfs_file_set_size+0x288> <== NOT EXECUTED
rtems_rfs_block_map_size (map)))
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
35878: e595303c ldr r3, [r5, #60] ; 0x3c <== NOT EXECUTED
3587c: e5843010 str r3, [r4, #16] <== NOT EXECUTED
35880: e5952040 ldr r2, [r5, #64] ; 0x40 <== NOT EXECUTED
35884: e3520000 cmp r2, #0 <== NOT EXECUTED
35888: e3a01000 mov r1, #0 <== NOT EXECUTED
3588c: 12433001 subne r3, r3, #1 <== NOT EXECUTED
35890: e5841018 str r1, [r4, #24] <== NOT EXECUTED
35894: e5842014 str r2, [r4, #20] <== NOT EXECUTED
35898: 15843010 strne r3, [r4, #16] <== NOT EXECUTED
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
3589c: e594601c ldr r6, [r4, #28] <== NOT EXECUTED
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
358a0: 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);
358a4: e595303c ldr r3, [r5, #60] ; 0x3c <== NOT EXECUTED
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
358a8: e5862088 str r2, [r6, #136] ; 0x88 <== 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);
358ac: e5863084 str r3, [r6, #132] ; 0x84 <== NOT EXECUTED
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
358b0: e5944000 ldr r4, [r4] <== NOT EXECUTED
358b4: e2144002 ands r4, r4, #2 <== NOT EXECUTED
358b8: 1a000004 bne 358d0 <rtems_rfs_file_set_size+0x2bc> <== NOT EXECUTED
handle->shared->mtime = time (NULL);
358bc: e1a00004 mov r0, r4 <== NOT EXECUTED
358c0: eb004d00 bl 48cc8 <time> <== NOT EXECUTED
358c4: e5860090 str r0, [r6, #144] ; 0x90 <== NOT EXECUTED
358c8: e1a00004 mov r0, r4 <== NOT EXECUTED
358cc: ea000000 b 358d4 <rtems_rfs_file_set_size+0x2c0> <== NOT EXECUTED
358d0: e3a00000 mov r0, #0 <== NOT EXECUTED
}
return 0;
}
358d4: e28dd018 add sp, sp, #24 <== NOT EXECUTED
358d8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
000364f8 <rtems_rfs_format>:
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
364f8: 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)
364fc: e5d13015 ldrb r3, [r1, #21] <== NOT EXECUTED
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
36500: e24dd0ec sub sp, sp, #236 ; 0xec <== NOT EXECUTED
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
36504: e3530000 cmp r3, #0 <== NOT EXECUTED
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
36508: e1a07001 mov r7, r1 <== NOT EXECUTED
3650c: e58d000c str r0, [sp, #12] <== NOT EXECUTED
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
printf ("rtems-rfs: format: %s\n", name);
36510: 159f0b5c ldrne r0, [pc, #2908] ; 37074 <rtems_rfs_format+0xb7c><== NOT EXECUTED
36514: 159d100c ldrne r1, [sp, #12] <== NOT EXECUTED
36518: 1b002bd6 blne 41478 <printf> <== NOT EXECUTED
memset (&fs, 0, sizeof (rtems_rfs_file_system));
3651c: e28d4018 add r4, sp, #24 <== NOT EXECUTED
36520: e3a01000 mov r1, #0 <== NOT EXECUTED
36524: e3a02080 mov r2, #128 ; 0x80 <== NOT EXECUTED
36528: e1a00004 mov r0, r4 <== NOT EXECUTED
3652c: eb0027aa bl 403dc <memset> <== NOT EXECUTED
the_chain->last = _Chain_Head(the_chain);
36530: e2843070 add r3, r4, #112 ; 0x70 <== NOT EXECUTED
36534: e58d3090 str r3, [sp, #144] ; 0x90 <== 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;
36538: e3a03005 mov r3, #5 <== NOT EXECUTED
3653c: 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);
36540: e284e064 add lr, r4, #100 ; 0x64 <== NOT EXECUTED
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
36544: 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);
36548: e2842074 add r2, r4, #116 ; 0x74 <== NOT EXECUTED
3654c: e58d3054 str r3, [sp, #84] ; 0x54 <== NOT EXECUTED
36550: 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;
36554: e3a03002 mov r3, #2 <== NOT EXECUTED
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
36558: 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);
3655c: e2846054 add r6, r4, #84 ; 0x54 <== NOT EXECUTED
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
36560: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED
36564: e1a01004 mov r1, r4 <== NOT EXECUTED
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
36568: e58d5070 str r5, [sp, #112] ; 0x70 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
3656c: e58da058 str sl, [sp, #88] ; 0x58 <== NOT EXECUTED
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
36570: e58d8060 str r8, [sp, #96] ; 0x60 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
36574: e58d6068 str r6, [sp, #104] ; 0x68 <== NOT EXECUTED
36578: e58de078 str lr, [sp, #120] ; 0x78 <== NOT EXECUTED
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
3657c: e58dc080 str ip, [sp, #128] ; 0x80 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
36580: e58d2088 str r2, [sp, #136] ; 0x88 <== 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;
36584: e58d3018 str r3, [sp, #24] <== NOT EXECUTED
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
36588: ebfff7f5 bl 34564 <rtems_rfs_buffer_open> <== NOT EXECUTED
if (rc > 0)
3658c: e2505000 subs r5, r0, #0 <== NOT EXECUTED
36590: da000004 ble 365a8 <rtems_rfs_format+0xb0> <== NOT EXECUTED
{
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
36594: eb0033ca bl 434c4 <strerror> <== NOT EXECUTED
36598: e1a01005 mov r1, r5 <== NOT EXECUTED
3659c: e1a02000 mov r2, r0 <== NOT EXECUTED
365a0: e59f0ad0 ldr r0, [pc, #2768] ; 37078 <rtems_rfs_format+0xb80><== NOT EXECUTED
365a4: ea0002ac b 3705c <rtems_rfs_format+0xb64> <== NOT EXECUTED
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
365a8: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
365ac: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED
365b0: e3510000 cmp r1, #0 <== NOT EXECUTED
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
365b4: 059f0ac0 ldreq r0, [pc, #2752] ; 3707c <rtems_rfs_format+0xb84><== NOT EXECUTED
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
365b8: 0a00014e beq 36af8 <rtems_rfs_format+0x600> <== 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;
365bc: e5973000 ldr r3, [r7] <== NOT EXECUTED
if (!fs->block_size)
365c0: e3530000 cmp r3, #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;
365c4: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
if (!fs->block_size)
365c8: 1a00001c bne 36640 <rtems_rfs_format+0x148> <== NOT EXECUTED
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
365cc: e1a00004 mov r0, r4 <== NOT EXECUTED
365d0: ebfffe54 bl 35f28 <rtems_rfs_fs_media_size> <== NOT EXECUTED
if (total_size >= GIGS (1))
365d4: e3510000 cmp r1, #0 <== NOT EXECUTED
365d8: 1a000001 bne 365e4 <rtems_rfs_format+0xec> <== NOT EXECUTED
365dc: e3500601 cmp r0, #1048576 ; 0x100000 <== NOT EXECUTED
365e0: 3a00000e bcc 36620 <rtems_rfs_format+0x128> <== NOT EXECUTED
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
365e4: e3a03601 mov r3, #1048576 ; 0x100000 <== NOT EXECUTED
365e8: e0933000 adds r3, r3, r0 <== NOT EXECUTED
365ec: e3a04000 mov r4, #0 <== NOT EXECUTED
365f0: e0a44001 adc r4, r4, r1 <== NOT EXECUTED
365f4: e1a01a23 lsr r1, r3, #20 <== NOT EXECUTED
365f8: e1811604 orr r1, r1, r4, lsl #12 <== NOT EXECUTED
365fc: e3a0301f mov r3, #31 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
36600: e3a02001 mov r2, #1 <== NOT EXECUTED
36604: e0110312 ands r0, r1, r2, lsl r3 <== NOT EXECUTED
36608: 1a000001 bne 36614 <rtems_rfs_format+0x11c> <== NOT EXECUTED
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
int b;
for (b = 31; b > 0; b--)
3660c: e2533001 subs r3, r3, #1 <== NOT EXECUTED
36610: 1afffffb bne 36604 <rtems_rfs_format+0x10c> <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
36614: e3a02001 mov r2, #1 <== NOT EXECUTED
36618: e1a03312 lsl r3, r2, r3 <== NOT EXECUTED
3661c: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
}
if (fs->block_size < 512)
36620: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
36624: e3530c02 cmp r3, #512 ; 0x200 <== NOT EXECUTED
fs->block_size = 512;
36628: 33a03c02 movcc r3, #512 ; 0x200 <== NOT EXECUTED
3662c: 358d3020 strcc r3, [sp, #32] <== NOT EXECUTED
if (fs->block_size > (4 * 1024))
36630: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
36634: e3530a01 cmp r3, #4096 ; 0x1000 <== NOT EXECUTED
fs->block_size = (4 * 1024);
36638: 83a03a01 movhi r3, #4096 ; 0x1000 <== NOT EXECUTED
3663c: 858d3020 strhi r3, [sp, #32] <== NOT EXECUTED
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
36640: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
36644: e59d4020 ldr r4, [sp, #32] <== NOT EXECUTED
36648: e5935024 ldr r5, [r3, #36] ; 0x24 <== NOT EXECUTED
3664c: e1a00004 mov r0, r4 <== NOT EXECUTED
36650: e1a01005 mov r1, r5 <== NOT EXECUTED
36654: eb007a7b bl 55048 <__umodsi3> <== NOT EXECUTED
36658: e3500000 cmp r0, #0 <== NOT EXECUTED
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
3665c: 11a01004 movne r1, r4 <== NOT EXECUTED
36660: 11a02005 movne r2, r5 <== NOT EXECUTED
36664: 159f0a14 ldrne r0, [pc, #2580] ; 37080 <rtems_rfs_format+0xb88><== NOT EXECUTED
36668: 1a00027b bne 3705c <rtems_rfs_format+0xb64> <== NOT EXECUTED
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
3666c: e5973004 ldr r3, [r7, #4] <== NOT EXECUTED
if (!fs->group_blocks)
36670: 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);
36674: 01a04184 lsleq r4, r4, #3 <== 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;
36678: e58d303c str r3, [sp, #60] ; 0x3c <== 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);
3667c: 058d403c streq r4, [sp, #60] ; 0x3c <== NOT EXECUTED
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
36680: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED
36684: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED
36688: e1530182 cmp r3, r2, lsl #3 <== NOT EXECUTED
{
printf ("group block count is higher than bits in block\n");
3668c: 859f09f0 ldrhi r0, [pc, #2544] ; 37084 <rtems_rfs_format+0xb8c><== NOT EXECUTED
* block.
*/
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
36690: 8a00010b bhi 36ac4 <rtems_rfs_format+0x5cc> <== 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;
36694: e28d0018 add r0, sp, #24 <== NOT EXECUTED
36698: ebfffe22 bl 35f28 <rtems_rfs_fs_media_size> <== NOT EXECUTED
3669c: e59d4020 ldr r4, [sp, #32] <== NOT EXECUTED
366a0: e3a03000 mov r3, #0 <== NOT EXECUTED
366a4: e1a02004 mov r2, r4 <== NOT EXECUTED
366a8: eb007dec bl 55e60 <__udivdi3> <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
366ac: 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;
366b0: e1a05000 mov r5, r0 <== NOT EXECUTED
366b4: e58d001c str r0, [sp, #28] <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
366b8: 03a04001 moveq r4, #1 <== NOT EXECUTED
366bc: 0a000003 beq 366d0 <rtems_rfs_format+0x1d8> <== NOT EXECUTED
return 1;
return ((dividend - 1) / divisor) + 1;
366c0: e1a01184 lsl r1, r4, #3 <== NOT EXECUTED
366c4: e2450001 sub r0, r5, #1 <== NOT EXECUTED
366c8: eb0079ca bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
366cc: e2804001 add r4, 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;
366d0: e5973008 ldr r3, [r7, #8] <== NOT EXECUTED
if (!fs->group_inodes)
366d4: 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),
366d8: e58d4038 str r4, [sp, #56] ; 0x38 <== NOT EXECUTED
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
366dc: e58d3040 str r3, [sp, #64] ; 0x40 <== NOT EXECUTED
if (!fs->group_inodes)
366e0: 1a000012 bne 36730 <rtems_rfs_format+0x238> <== 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)
366e4: e597300c ldr r3, [r7, #12] <== NOT EXECUTED
366e8: e3530000 cmp r3, #0 <== NOT EXECUTED
366ec: 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) -
366f0: e2450001 sub r0, r5, #1 <== NOT EXECUTED
366f4: e0000093 mul r0, r3, r0 <== NOT EXECUTED
366f8: e3a01064 mov r1, #100 ; 0x64 <== NOT EXECUTED
366fc: eb0079bd bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
36700: e3500000 cmp r0, #0 <== NOT EXECUTED
36704: 03a04001 moveq r4, #1 <== NOT EXECUTED
36708: 0a000003 beq 3671c <rtems_rfs_format+0x224> <== NOT EXECUTED
return 1;
return ((dividend - 1) / divisor) + 1;
3670c: e1a01004 mov r1, r4 <== NOT EXECUTED
36710: e2400001 sub r0, r0, #1 <== NOT EXECUTED
36714: eb0079b7 bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
36718: e2804001 add r4, 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);
3671c: e59d0020 ldr r0, [sp, #32] <== NOT EXECUTED
36720: e3a01038 mov r1, #56 ; 0x38 <== NOT EXECUTED
36724: eb0079b3 bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
36728: e0000094 mul r0, r4, r0 <== NOT EXECUTED
3672c: e58d0040 str r0, [sp, #64] ; 0x40 <== 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;
36730: e59d0020 ldr r0, [sp, #32] <== NOT EXECUTED
36734: e3a01038 mov r1, #56 ; 0x38 <== NOT EXECUTED
36738: eb0079ae bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
3673c: e1a04000 mov r4, r0 <== NOT EXECUTED
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
36740: e59d0040 ldr r0, [sp, #64] ; 0x40 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
36744: 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;
36748: e58d4044 str r4, [sp, #68] ; 0x44 <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
3674c: 12400001 subne r0, r0, #1 <== NOT EXECUTED
36750: 11a01004 movne r1, r4 <== NOT EXECUTED
36754: 1b0079a7 blne 54df8 <__aeabi_uidiv> <== NOT EXECUTED
36758: 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,
3675c: e0020094 mul r2, r4, r0 <== NOT EXECUTED
fs->inodes_per_block) * fs->inodes_per_block;
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
36760: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
36764: e1a03183 lsl r3, r3, #3 <== NOT EXECUTED
36768: e1520003 cmp r2, r3 <== 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 =
3676c: e58d2040 str r2, [sp, #64] ; 0x40 <== 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);
36770: 858d3040 strhi r3, [sp, #64] ; 0x40 <== NOT EXECUTED
fs->max_name_length = config->max_name_length;
36774: e5973010 ldr r3, [r7, #16] <== NOT EXECUTED
if (!fs->max_name_length)
36778: 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;
3677c: e58d3030 str r3, [sp, #48] ; 0x30 <== NOT EXECUTED
if (!fs->max_name_length)
{
fs->max_name_length = 512;
36780: 02833c02 addeq r3, r3, #512 ; 0x200 <== NOT EXECUTED
36784: 058d3030 streq r3, [sp, #48] ; 0x30 <== NOT EXECUTED
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
36788: e5d73015 ldrb r3, [r7, #21] <== NOT EXECUTED
3678c: e3530000 cmp r3, #0 <== NOT EXECUTED
36790: 0a00003b beq 36884 <rtems_rfs_format+0x38c> <== NOT EXECUTED
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
36794: e28d4018 add r4, sp, #24 <== NOT EXECUTED
36798: e1a00004 mov r0, r4 <== NOT EXECUTED
3679c: ebfffde1 bl 35f28 <rtems_rfs_fs_media_size> <== NOT EXECUTED
367a0: e1a02001 mov r2, r1 <== NOT EXECUTED
367a4: e1a01000 mov r1, r0 <== NOT EXECUTED
367a8: e59f08d8 ldr r0, [pc, #2264] ; 37088 <rtems_rfs_format+0xb90><== NOT EXECUTED
367ac: eb002b31 bl 41478 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
367b0: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
367b4: e59f08d0 ldr r0, [pc, #2256] ; 3708c <rtems_rfs_format+0xb94><== NOT EXECUTED
367b8: e593101c ldr r1, [r3, #28] <== NOT EXECUTED
367bc: eb002b2d bl 41478 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
367c0: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
367c4: e59f08c4 ldr r0, [pc, #2244] ; 37090 <rtems_rfs_format+0xb98><== NOT EXECUTED
367c8: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED
367cc: eb002b29 bl 41478 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
367d0: e1a00004 mov r0, r4 <== NOT EXECUTED
367d4: ebfffdcc bl 35f0c <rtems_rfs_fs_size> <== NOT EXECUTED
367d8: e1a02001 mov r2, r1 <== NOT EXECUTED
367dc: e1a01000 mov r1, r0 <== NOT EXECUTED
367e0: e59f08ac ldr r0, [pc, #2220] ; 37094 <rtems_rfs_format+0xb9c><== NOT EXECUTED
367e4: eb002b23 bl 41478 <printf> <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
367e8: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED
367ec: e59f08a4 ldr r0, [pc, #2212] ; 37098 <rtems_rfs_format+0xba0><== NOT EXECUTED
367f0: eb002b20 bl 41478 <printf> <== NOT EXECUTED
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
367f4: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED
367f8: e59f089c ldr r0, [pc, #2204] ; 3709c <rtems_rfs_format+0xba4><== NOT EXECUTED
367fc: eb002b1d bl 41478 <printf> <== NOT EXECUTED
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
36800: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED
36804: e59f0894 ldr r0, [pc, #2196] ; 370a0 <rtems_rfs_format+0xba8><== NOT EXECUTED
36808: e1a01181 lsl r1, r1, #3 <== NOT EXECUTED
3680c: eb002b19 bl 41478 <printf> <== NOT EXECUTED
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
36810: e3a01038 mov r1, #56 ; 0x38 <== NOT EXECUTED
36814: e59f0888 ldr r0, [pc, #2184] ; 370a4 <rtems_rfs_format+0xbac><== NOT EXECUTED
36818: eb002b16 bl 41478 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
3681c: e1a00004 mov r0, r4 <== NOT EXECUTED
36820: ebffff16 bl 36480 <rtems_rfs_inode_overhead> <== NOT EXECUTED
36824: e59d2040 ldr r2, [sp, #64] ; 0x40 <== NOT EXECUTED
36828: e59d3038 ldr r3, [sp, #56] ; 0x38 <== NOT EXECUTED
3682c: e3a0100a mov r1, #10 <== NOT EXECUTED
36830: e0040392 mul r4, r2, r3 <== NOT EXECUTED
36834: e1a06000 mov r6, r0 <== NOT EXECUTED
36838: eb0079b2 bl 54f08 <__aeabi_idiv> <== NOT EXECUTED
3683c: e3a0100a mov r1, #10 <== NOT EXECUTED
36840: e1a05000 mov r5, r0 <== NOT EXECUTED
36844: e1a00006 mov r0, r6 <== NOT EXECUTED
36848: eb007a31 bl 55114 <__modsi3> <== NOT EXECUTED
3684c: e1a02005 mov r2, r5 <== NOT EXECUTED
36850: e1a03000 mov r3, r0 <== NOT EXECUTED
36854: e1a01004 mov r1, r4 <== NOT EXECUTED
36858: e59f0848 ldr r0, [pc, #2120] ; 370a8 <rtems_rfs_format+0xbb0><== NOT EXECUTED
3685c: eb002b05 bl 41478 <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);
36860: e59d1038 ldr r1, [sp, #56] ; 0x38 <== NOT EXECUTED
36864: e59f0840 ldr r0, [pc, #2112] ; 370ac <rtems_rfs_format+0xbb4><== NOT EXECUTED
36868: eb002b02 bl 41478 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
3686c: e59d103c ldr r1, [sp, #60] ; 0x3c <== NOT EXECUTED
36870: e59f0838 ldr r0, [pc, #2104] ; 370b0 <rtems_rfs_format+0xbb8><== NOT EXECUTED
36874: eb002aff bl 41478 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
36878: e59f0834 ldr r0, [pc, #2100] ; 370b4 <rtems_rfs_format+0xbbc><== NOT EXECUTED
3687c: e59d1040 ldr r1, [sp, #64] ; 0x40 <== NOT EXECUTED
36880: eb002afc bl 41478 <printf> <== NOT EXECUTED
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
36884: e28d6018 add r6, sp, #24 <== NOT EXECUTED
36888: e1a00006 mov r0, r6 <== NOT EXECUTED
3688c: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED
36890: ebfff716 bl 344f0 <rtems_rfs_buffer_setblksize> <== NOT EXECUTED
if (rc > 0)
36894: e2504000 subs r4, r0, #0 <== NOT EXECUTED
36898: da000004 ble 368b0 <rtems_rfs_format+0x3b8> <== NOT EXECUTED
{
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
3689c: eb003308 bl 434c4 <strerror> <== NOT EXECUTED
368a0: e1a01004 mov r1, r4 <== NOT EXECUTED
368a4: e1a02000 mov r2, r0 <== NOT EXECUTED
368a8: e59f0808 ldr r0, [pc, #2056] ; 370b8 <rtems_rfs_format+0xbc0><== NOT EXECUTED
368ac: ea0001ea b 3705c <rtems_rfs_format+0xb64> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
368b0: e3a04000 mov r4, #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);
368b4: e28d80d8 add r8, sp, #216 ; 0xd8 <== NOT EXECUTED
368b8: e1a00006 mov r0, r6 <== NOT EXECUTED
368bc: e1a01008 mov r1, r8 <== NOT EXECUTED
368c0: e1a02004 mov r2, r4 <== NOT EXECUTED
368c4: e1a03004 mov r3, r4 <== NOT EXECUTED
368c8: e5cd40d8 strb r4, [sp, #216] ; 0xd8 <== NOT EXECUTED
handle->bnum = 0;
368cc: e58d40dc str r4, [sp, #220] ; 0xdc <== NOT EXECUTED
handle->buffer = NULL;
368d0: e58d40e0 str r4, [sp, #224] ; 0xe0 <== NOT EXECUTED
368d4: ebfff781 bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
368d8: e2505000 subs r5, r0, #0 <== NOT EXECUTED
368dc: da000008 ble 36904 <rtems_rfs_format+0x40c> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
368e0: e1a01008 mov r1, r8 <== NOT EXECUTED
368e4: e1a00006 mov r0, r6 <== NOT EXECUTED
368e8: ebfffefa bl 364d8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
368ec: e1a00005 mov r0, r5 <== NOT EXECUTED
368f0: eb0032f3 bl 434c4 <strerror> <== NOT EXECUTED
368f4: e1a01005 mov r1, r5 <== NOT EXECUTED
368f8: e1a02000 mov r2, r0 <== NOT EXECUTED
368fc: e59f07b8 ldr r0, [pc, #1976] ; 370bc <rtems_rfs_format+0xbc4><== NOT EXECUTED
36900: ea00006d b 36abc <rtems_rfs_format+0x5c4> <== NOT EXECUTED
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
36904: e59d30e0 ldr r3, [sp, #224] ; 0xe0 <== NOT EXECUTED
36908: e593a020 ldr sl, [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));
3690c: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED
36910: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED
36914: e1a0000a mov r0, sl <== NOT EXECUTED
36918: eb0026af bl 403dc <memset> <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
3691c: e3a03028 mov r3, #40 ; 0x28 <== NOT EXECUTED
36920: e5ca3000 strb r3, [sl] <== NOT EXECUTED
36924: e3a03009 mov r3, #9 <== NOT EXECUTED
36928: e5ca3001 strb r3, [sl, #1] <== NOT EXECUTED
3692c: e3a05001 mov r5, #1 <== NOT EXECUTED
36930: e2833017 add r3, r3, #23 <== NOT EXECUTED
36934: e5ca3002 strb r3, [sl, #2] <== NOT EXECUTED
36938: e5ca5003 strb r5, [sl, #3] <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
3693c: e5ca4004 strb r4, [sl, #4] <== NOT EXECUTED
36940: e5ca4005 strb r4, [sl, #5] <== NOT EXECUTED
36944: e5ca4006 strb r4, [sl, #6] <== NOT EXECUTED
36948: e5ca4007 strb r4, [sl, #7] <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
3694c: e5dd301f ldrb r3, [sp, #31] <== NOT EXECUTED
36950: e5ca300c strb r3, [sl, #12] <== NOT EXECUTED
36954: e1dd31be ldrh r3, [sp, #30] <== NOT EXECUTED
36958: e5ca300d strb r3, [sl, #13] <== NOT EXECUTED
3695c: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED
36960: e1a03423 lsr r3, r3, #8 <== NOT EXECUTED
36964: e5ca300e strb r3, [sl, #14] <== NOT EXECUTED
36968: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED
3696c: e5ca300f strb r3, [sl, #15] <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
36970: e5dd3023 ldrb r3, [sp, #35] ; 0x23 <== NOT EXECUTED
36974: e5ca3008 strb r3, [sl, #8] <== NOT EXECUTED
36978: e1dd32b2 ldrh r3, [sp, #34] ; 0x22 <== NOT EXECUTED
3697c: e5ca3009 strb r3, [sl, #9] <== NOT EXECUTED
36980: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
36984: e1a03423 lsr r3, r3, #8 <== NOT EXECUTED
36988: e5ca300a strb r3, [sl, #10] <== NOT EXECUTED
3698c: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
36990: e5ca300b strb r3, [sl, #11] <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
36994: e5dd302f ldrb r3, [sp, #47] ; 0x2f <== NOT EXECUTED
36998: e5ca3010 strb r3, [sl, #16] <== NOT EXECUTED
3699c: e1dd32be ldrh r3, [sp, #46] ; 0x2e <== NOT EXECUTED
369a0: e5ca3011 strb r3, [sl, #17] <== NOT EXECUTED
369a4: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED
369a8: e1a03423 lsr r3, r3, #8 <== NOT EXECUTED
369ac: e5ca3012 strb r3, [sl, #18] <== NOT EXECUTED
369b0: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED
369b4: e5ca3013 strb r3, [sl, #19] <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
369b8: e5dd3033 ldrb r3, [sp, #51] ; 0x33 <== NOT EXECUTED
369bc: e5ca3014 strb r3, [sl, #20] <== NOT EXECUTED
369c0: e1dd33b2 ldrh r3, [sp, #50] ; 0x32 <== NOT EXECUTED
369c4: e5ca3015 strb r3, [sl, #21] <== NOT EXECUTED
369c8: e59d3030 ldr r3, [sp, #48] ; 0x30 <== NOT EXECUTED
369cc: e1a03423 lsr r3, r3, #8 <== NOT EXECUTED
369d0: e5ca3016 strb r3, [sl, #22] <== NOT EXECUTED
369d4: e59d3030 ldr r3, [sp, #48] ; 0x30 <== NOT EXECUTED
369d8: e5ca3017 strb r3, [sl, #23] <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
369dc: e5dd303b ldrb r3, [sp, #59] ; 0x3b <== NOT EXECUTED
369e0: e5ca3018 strb r3, [sl, #24] <== NOT EXECUTED
369e4: e1dd33ba ldrh r3, [sp, #58] ; 0x3a <== NOT EXECUTED
369e8: e5ca3019 strb r3, [sl, #25] <== NOT EXECUTED
369ec: e59d3038 ldr r3, [sp, #56] ; 0x38 <== NOT EXECUTED
369f0: e1a03423 lsr r3, r3, #8 <== NOT EXECUTED
369f4: e5ca301a strb r3, [sl, #26] <== NOT EXECUTED
369f8: e59d3038 ldr r3, [sp, #56] ; 0x38 <== NOT EXECUTED
369fc: e5ca301b strb r3, [sl, #27] <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
36a00: e5dd303f ldrb r3, [sp, #63] ; 0x3f <== NOT EXECUTED
36a04: e5ca301c strb r3, [sl, #28] <== NOT EXECUTED
36a08: e1dd33be ldrh r3, [sp, #62] ; 0x3e <== NOT EXECUTED
36a0c: e5ca301d strb r3, [sl, #29] <== NOT EXECUTED
36a10: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED
36a14: e1a03423 lsr r3, r3, #8 <== NOT EXECUTED
36a18: e5ca301e strb r3, [sl, #30] <== NOT EXECUTED
36a1c: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED
36a20: e5ca301f strb r3, [sl, #31] <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
36a24: e5dd3043 ldrb r3, [sp, #67] ; 0x43 <== NOT EXECUTED
36a28: e5ca3020 strb r3, [sl, #32] <== NOT EXECUTED
36a2c: e1dd34b2 ldrh r3, [sp, #66] ; 0x42 <== NOT EXECUTED
36a30: e5ca3021 strb r3, [sl, #33] ; 0x21 <== NOT EXECUTED
36a34: e59d3040 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED
36a38: e1a03423 lsr r3, r3, #8 <== NOT EXECUTED
36a3c: e5ca3022 strb r3, [sl, #34] ; 0x22 <== NOT EXECUTED
36a40: e59d3040 ldr r3, [sp, #64] ; 0x40 <== 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);
36a44: e1a00006 mov r0, r6 <== 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);
36a48: e5ca3023 strb r3, [sl, #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);
36a4c: e1a01008 mov r1, r8 <== 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);
36a50: e3a03038 mov r3, #56 ; 0x38 <== NOT EXECUTED
36a54: e5ca4024 strb r4, [sl, #36] ; 0x24 <== NOT EXECUTED
36a58: e5ca4025 strb r4, [sl, #37] ; 0x25 <== NOT EXECUTED
36a5c: e5ca4026 strb r4, [sl, #38] ; 0x26 <== NOT EXECUTED
36a60: e5ca3027 strb r3, [sl, #39] ; 0x27 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
36a64: e5cd50d8 strb r5, [sp, #216] ; 0xd8 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (fs, &handle);
36a68: ebfff6d3 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rc > 0)
36a6c: e250a000 subs sl, r0, #0 <== NOT EXECUTED
36a70: da000008 ble 36a98 <rtems_rfs_format+0x5a0> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
36a74: e1a01008 mov r1, r8 <== NOT EXECUTED
36a78: e1a00006 mov r0, r6 <== NOT EXECUTED
36a7c: ebfffe95 bl 364d8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
36a80: e1a0000a mov r0, sl <== NOT EXECUTED
36a84: eb00328e bl 434c4 <strerror> <== NOT EXECUTED
36a88: e1a0100a mov r1, sl <== NOT EXECUTED
36a8c: e1a02000 mov r2, r0 <== NOT EXECUTED
36a90: e59f0628 ldr r0, [pc, #1576] ; 370c0 <rtems_rfs_format+0xbc8><== NOT EXECUTED
36a94: ea000008 b 36abc <rtems_rfs_format+0x5c4> <== NOT EXECUTED
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
36a98: e1a00006 mov r0, r6 <== NOT EXECUTED
36a9c: e1a01008 mov r1, r8 <== NOT EXECUTED
36aa0: ebfffe8c bl 364d8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
if (rc > 0)
36aa4: e250a000 subs sl, r0, #0 <== NOT EXECUTED
36aa8: da0000e2 ble 36e38 <rtems_rfs_format+0x940> <== NOT EXECUTED
{
printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
36aac: eb003284 bl 434c4 <strerror> <== NOT EXECUTED
36ab0: e1a02000 mov r2, r0 <== NOT EXECUTED
36ab4: e59f0608 ldr r0, [pc, #1544] ; 370c4 <rtems_rfs_format+0xbcc><== NOT EXECUTED
36ab8: e1a0100a mov r1, sl <== NOT EXECUTED
36abc: eb002a6d bl 41478 <printf> <== NOT EXECUTED
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
36ac0: e59f0600 ldr r0, [pc, #1536] ; 370c8 <rtems_rfs_format+0xbd0><== NOT EXECUTED
36ac4: eb002b10 bl 4170c <puts> <== NOT EXECUTED
36ac8: ea000164 b 37060 <rtems_rfs_format+0xb68> <== NOT EXECUTED
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
36acc: e59da03c ldr sl, [sp, #60] ; 0x3c <== NOT EXECUTED
36ad0: e002049a mul r2, sl, r4 <== NOT EXECUTED
if (group_base > rtems_rfs_fs_blocks (fs))
36ad4: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
36ad8: e2827001 add r7, r2, #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))
36adc: e5d9c014 ldrb ip, [r9, #20] <== NOT EXECUTED
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
36ae0: e1570003 cmp r7, r3 <== NOT EXECUTED
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
36ae4: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
36ae8: e58dc014 str ip, [sp, #20] <== NOT EXECUTED
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
36aec: 9a000003 bls 36b00 <rtems_rfs_format+0x608> <== NOT EXECUTED
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
36af0: e59f05d4 ldr r0, [pc, #1492] ; 370cc <rtems_rfs_format+0xbd4><== NOT EXECUTED
36af4: e1a01004 mov r1, r4 <== NOT EXECUTED
36af8: eb002a5e bl 41478 <printf> <== NOT EXECUTED
36afc: ea000157 b 37060 <rtems_rfs_format+0xb68> <== 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))
36b00: e087200a add r2, r7, sl <== NOT EXECUTED
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
36b04: e59d0004 ldr r0, [sp, #4] <== 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))
36b08: e1520003 cmp r2, r3 <== NOT EXECUTED
group_size = rtems_rfs_fs_blocks (fs) - group_base;
36b0c: 8067a003 rsbhi sl, r7, r3 <== NOT EXECUTED
if (verbose)
36b10: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
36b14: 159f05b4 ldrne r0, [pc, #1460] ; 370d0 <rtems_rfs_format+0xbd8><== NOT EXECUTED
36b18: 11a01004 movne r1, r4 <== NOT EXECUTED
36b1c: 11a02007 movne r2, r7 <== NOT EXECUTED
36b20: 11a0300a movne r3, sl <== NOT EXECUTED
36b24: 1b002a53 blne 41478 <printf> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: handle open failed: %d: %s\n",
rc, strerror (rc));
return false;
}
if (verbose)
36b28: e59d2004 ldr r2, [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;
handle->bnum = 0;
36b2c: e3a0c000 mov ip, #0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
36b30: e3a03000 mov r3, #0 <== NOT EXECUTED
36b34: e3520000 cmp r2, #0 <== NOT EXECUTED
36b38: e5cd30d8 strb r3, [sp, #216] ; 0xd8 <== NOT EXECUTED
handle->bnum = 0;
36b3c: e58dc0dc str ip, [sp, #220] ; 0xdc <== NOT EXECUTED
handle->buffer = NULL;
36b40: e58dc0e0 str ip, [sp, #224] ; 0xe0 <== NOT EXECUTED
printf (", blocks");
36b44: 159f0588 ldrne r0, [pc, #1416] ; 370d4 <rtems_rfs_format+0xbdc><== NOT EXECUTED
36b48: 1b002a4a blne 41478 <printf> <== NOT EXECUTED
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
36b4c: e1a00005 mov r0, r5 <== NOT EXECUTED
36b50: e1a01006 mov r1, r6 <== NOT EXECUTED
36b54: e1a02008 mov r2, r8 <== NOT EXECUTED
36b58: e1a0300a mov r3, sl <== NOT EXECUTED
36b5c: e58d7000 str r7, [sp] <== NOT EXECUTED
36b60: eb001613 bl 3c3b4 <rtems_rfs_bitmap_open> <== NOT EXECUTED
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
36b64: e250b000 subs fp, r0, #0 <== NOT EXECUTED
36b68: da000009 ble 36b94 <rtems_rfs_format+0x69c> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
36b6c: e1a01008 mov r1, r8 <== NOT EXECUTED
36b70: e1a00006 mov r0, r6 <== NOT EXECUTED
36b74: ebfffe57 bl 364d8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
36b78: e1a0000b mov r0, fp <== NOT EXECUTED
36b7c: eb003250 bl 434c4 <strerror> <== NOT EXECUTED
36b80: e1a01004 mov r1, r4 <== NOT EXECUTED
36b84: e1a03000 mov r3, r0 <== NOT EXECUTED
36b88: e1a0200b mov r2, fp <== NOT EXECUTED
36b8c: e59f0544 ldr r0, [pc, #1348] ; 370d8 <rtems_rfs_format+0xbe0><== NOT EXECUTED
36b90: ea000013 b 36be4 <rtems_rfs_format+0x6ec> <== 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));
36b94: e59d30e0 ldr r3, [sp, #224] ; 0xe0 <== NOT EXECUTED
36b98: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED
36b9c: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED
36ba0: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED
36ba4: eb00260c bl 403dc <memset> <== NOT EXECUTED
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
36ba8: e1a00005 mov r0, r5 <== NOT EXECUTED
36bac: eb001612 bl 3c3fc <rtems_rfs_bitmap_map_clear_all> <== NOT EXECUTED
if (rc > 0)
36bb0: e250b000 subs fp, r0, #0 <== NOT EXECUTED
36bb4: da00000c ble 36bec <rtems_rfs_format+0x6f4> <== NOT EXECUTED
{
rtems_rfs_bitmap_close (&bitmap);
36bb8: e1a00005 mov r0, r5 <== NOT EXECUTED
36bbc: eb0015ba bl 3c2ac <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
36bc0: e1a01008 mov r1, r8 <== NOT EXECUTED
36bc4: e1a00006 mov r0, r6 <== NOT EXECUTED
36bc8: ebfffe42 bl 364d8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
36bcc: e1a0000b mov r0, fp <== NOT EXECUTED
36bd0: eb00323b bl 434c4 <strerror> <== NOT EXECUTED
36bd4: e1a03000 mov r3, r0 <== NOT EXECUTED
36bd8: e59f04fc ldr r0, [pc, #1276] ; 370dc <rtems_rfs_format+0xbe4><== NOT EXECUTED
36bdc: e1a01004 mov r1, r4 <== NOT EXECUTED
36be0: e1a0200b mov r2, fp <== NOT EXECUTED
36be4: eb002a23 bl 41478 <printf> <== NOT EXECUTED
36be8: ea00011c b 37060 <rtems_rfs_format+0xb68> <== NOT EXECUTED
}
/*
* Forced allocation of the block bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
36bec: e3a01000 mov r1, #0 <== NOT EXECUTED
36bf0: e1a00005 mov r0, r5 <== NOT EXECUTED
36bf4: eb00167e bl 3c5f4 <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);
36bf8: e3a01001 mov r1, #1 <== NOT EXECUTED
36bfc: e1a00005 mov r0, r5 <== NOT EXECUTED
36c00: eb00167b bl 3c5f4 <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);
36c04: e59d0040 ldr r0, [sp, #64] ; 0x40 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
36c08: 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);
36c0c: e59d1044 ldr r1, [sp, #68] ; 0x44 <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
36c10: 12400001 subne r0, r0, #1 <== NOT EXECUTED
36c14: 1b007877 blne 54df8 <__aeabi_uidiv> <== NOT EXECUTED
36c18: e2800001 add r0, r0, #1 <== NOT EXECUTED
36c1c: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
36c20: e3a0b000 mov fp, #0 <== NOT EXECUTED
36c24: ea000001 b 36c30 <rtems_rfs_format+0x738> <== 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);
36c28: eb001671 bl 3c5f4 <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++)
36c2c: e28bb001 add fp, fp, #1 <== NOT EXECUTED
36c30: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED
36c34: e15b0002 cmp fp, r2 <== NOT EXECUTED
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
36c38: e28b1002 add r1, fp, #2 <== NOT EXECUTED
36c3c: e1a00005 mov r0, r5 <== 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++)
36c40: bafffff8 blt 36c28 <rtems_rfs_format+0x730> <== NOT EXECUTED
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
/*
* Close the block bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
36c44: eb001598 bl 3c2ac <rtems_rfs_bitmap_close> <== NOT EXECUTED
if (rc > 0)
36c48: e250b000 subs fp, r0, #0 <== NOT EXECUTED
36c4c: da000009 ble 36c78 <rtems_rfs_format+0x780> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
36c50: e28d10d8 add r1, sp, #216 ; 0xd8 <== NOT EXECUTED
36c54: e28d0018 add r0, sp, #24 <== NOT EXECUTED
36c58: ebfffe1e bl 364d8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
36c5c: e1a0000b mov r0, fp <== NOT EXECUTED
36c60: eb003217 bl 434c4 <strerror> <== NOT EXECUTED
36c64: e1a01004 mov r1, r4 <== NOT EXECUTED
36c68: e1a03000 mov r3, r0 <== NOT EXECUTED
36c6c: e1a0200b mov r2, fp <== NOT EXECUTED
36c70: e59f0468 ldr r0, [pc, #1128] ; 370e0 <rtems_rfs_format+0xbe8><== NOT EXECUTED
36c74: eaffffda b 36be4 <rtems_rfs_format+0x6ec> <== NOT EXECUTED
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
36c78: e59d3004 ldr r3, [sp, #4] <== 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);
36c7c: e3a0c001 mov ip, #1 <== NOT EXECUTED
if (verbose)
36c80: e3530000 cmp r3, #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);
36c84: e5cdc0d8 strb ip, [sp, #216] ; 0xd8 <== NOT EXECUTED
if (verbose)
printf (", inodes");
36c88: 159f0454 ldrne r0, [pc, #1108] ; 370e4 <rtems_rfs_format+0xbec><== NOT EXECUTED
36c8c: 1b0029f9 blne 41478 <printf> <== NOT EXECUTED
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
36c90: e1a0300a mov r3, sl <== NOT EXECUTED
36c94: e2877001 add r7, r7, #1 <== NOT EXECUTED
36c98: e1a00005 mov r0, r5 <== NOT EXECUTED
36c9c: e1a01006 mov r1, r6 <== NOT EXECUTED
36ca0: e1a02008 mov r2, r8 <== NOT EXECUTED
36ca4: e58d7000 str r7, [sp] <== NOT EXECUTED
36ca8: eb0015c1 bl 3c3b4 <rtems_rfs_bitmap_open> <== NOT EXECUTED
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
36cac: e250a000 subs sl, r0, #0 <== NOT EXECUTED
36cb0: da000009 ble 36cdc <rtems_rfs_format+0x7e4> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
36cb4: e1a01008 mov r1, r8 <== NOT EXECUTED
36cb8: e1a00006 mov r0, r6 <== NOT EXECUTED
36cbc: ebfffe05 bl 364d8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
36cc0: e1a0000a mov r0, sl <== NOT EXECUTED
36cc4: eb0031fe bl 434c4 <strerror> <== NOT EXECUTED
36cc8: e1a01004 mov r1, r4 <== NOT EXECUTED
36ccc: e1a03000 mov r3, r0 <== NOT EXECUTED
36cd0: e1a0200a mov r2, sl <== NOT EXECUTED
36cd4: e59f040c ldr r0, [pc, #1036] ; 370e8 <rtems_rfs_format+0xbf0><== NOT EXECUTED
36cd8: eaffffc1 b 36be4 <rtems_rfs_format+0x6ec> <== 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));
36cdc: e59d30e0 ldr r3, [sp, #224] ; 0xe0 <== NOT EXECUTED
36ce0: e3a01000 mov r1, #0 <== NOT EXECUTED
36ce4: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED
36ce8: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED
36cec: eb0025ba bl 403dc <memset> <== NOT EXECUTED
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
36cf0: e1a00005 mov r0, r5 <== NOT EXECUTED
36cf4: eb0015c0 bl 3c3fc <rtems_rfs_bitmap_map_clear_all> <== NOT EXECUTED
if (rc > 0)
36cf8: e250a000 subs sl, r0, #0 <== NOT EXECUTED
36cfc: da00000b ble 36d30 <rtems_rfs_format+0x838> <== NOT EXECUTED
{
rtems_rfs_bitmap_close (&bitmap);
36d00: e1a00005 mov r0, r5 <== NOT EXECUTED
36d04: eb001568 bl 3c2ac <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
36d08: e1a01008 mov r1, r8 <== NOT EXECUTED
36d0c: e1a00006 mov r0, r6 <== NOT EXECUTED
36d10: ebfffdf0 bl 364d8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
36d14: e1a0000a mov r0, sl <== NOT EXECUTED
36d18: eb0031e9 bl 434c4 <strerror> <== NOT EXECUTED
36d1c: e1a01004 mov r1, r4 <== NOT EXECUTED
36d20: e1a03000 mov r3, r0 <== NOT EXECUTED
36d24: e1a0200a mov r2, sl <== NOT EXECUTED
36d28: e59f03bc ldr r0, [pc, #956] ; 370ec <rtems_rfs_format+0xbf4><== NOT EXECUTED
36d2c: eaffffac b 36be4 <rtems_rfs_format+0x6ec> <== NOT EXECUTED
}
/*
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
36d30: e1a00005 mov r0, r5 <== NOT EXECUTED
36d34: eb00155c bl 3c2ac <rtems_rfs_bitmap_close> <== NOT EXECUTED
if (rc > 0)
36d38: e250a000 subs sl, r0, #0 <== NOT EXECUTED
36d3c: da000009 ble 36d68 <rtems_rfs_format+0x870> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
36d40: e1a01008 mov r1, r8 <== NOT EXECUTED
36d44: e1a00006 mov r0, r6 <== NOT EXECUTED
36d48: ebfffde2 bl 364d8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
36d4c: e1a0000a mov r0, sl <== NOT EXECUTED
36d50: eb0031db bl 434c4 <strerror> <== NOT EXECUTED
36d54: e1a01004 mov r1, r4 <== NOT EXECUTED
36d58: e1a03000 mov r3, r0 <== NOT EXECUTED
36d5c: e1a0200a mov r2, sl <== NOT EXECUTED
36d60: e59f0388 ldr r0, [pc, #904] ; 370f0 <rtems_rfs_format+0xbf8><== NOT EXECUTED
36d64: eaffff9e b 36be4 <rtems_rfs_format+0x6ec> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
36d68: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED
36d6c: e3500000 cmp r0, #0 <== NOT EXECUTED
36d70: 159d3010 ldrne r3, [sp, #16] <== 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);
36d74: e3a02001 mov r2, #1 <== NOT EXECUTED
36d78: e5cd20d8 strb r2, [sp, #216] ; 0xd8 <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
36d7c: 1283a003 addne sl, r3, #3 <== NOT EXECUTED
36d80: 13a07000 movne r7, #0 <== NOT EXECUTED
36d84: 1a00001a bne 36df4 <rtems_rfs_format+0x8fc> <== NOT EXECUTED
36d88: ea000020 b 36e10 <rtems_rfs_format+0x918> <== NOT EXECUTED
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
36d8c: ebfff653 bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
36d90: e3500000 cmp r0, #0 <== NOT EXECUTED
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
36d94: e28ab001 add fp, sl, #1 <== NOT EXECUTED
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
36d98: da00000c ble 36dd0 <rtems_rfs_format+0x8d8> <== NOT EXECUTED
36d9c: e1a0b000 mov fp, r0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
36da0: e1a01008 mov r1, r8 <== NOT EXECUTED
36da4: e1a00006 mov r0, r6 <== NOT EXECUTED
36da8: ebfffdca bl 364d8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
36dac: e1a0000b mov r0, fp <== NOT EXECUTED
36db0: eb0031c3 bl 434c4 <strerror> <== NOT EXECUTED
36db4: e1a01004 mov r1, r4 <== NOT EXECUTED
36db8: e58d0000 str r0, [sp] <== NOT EXECUTED
36dbc: e1a0200a mov r2, sl <== NOT EXECUTED
36dc0: e1a0300b mov r3, fp <== NOT EXECUTED
36dc4: e59f0328 ldr r0, [pc, #808] ; 370f4 <rtems_rfs_format+0xbfc><== NOT EXECUTED
36dc8: eb0029aa bl 41478 <printf> <== NOT EXECUTED
36dcc: ea0000a3 b 37060 <rtems_rfs_format+0xb68> <== 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));
36dd0: e59d30e0 ldr r3, [sp, #224] ; 0xe0 <== NOT EXECUTED
36dd4: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED
36dd8: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED
36ddc: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED
36de0: eb00257d bl 403dc <memset> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
36de4: e3a0c001 mov ip, #1 <== NOT EXECUTED
36de8: e5cdc0d8 strb ip, [sp, #216] ; 0xd8 <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
36dec: e2877001 add r7, r7, #1 <== NOT EXECUTED
36df0: e1a0a00b mov sl, fp <== NOT EXECUTED
36df4: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED
36df8: e157000c cmp r7, ip <== NOT EXECUTED
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
36dfc: e1a0200a mov r2, sl <== NOT EXECUTED
36e00: e1a01008 mov r1, r8 <== NOT EXECUTED
36e04: e3a03000 mov r3, #0 <== NOT EXECUTED
36e08: e1a00006 mov r0, r6 <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
36e0c: baffffde blt 36d8c <rtems_rfs_format+0x894> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
36e10: e1a00006 mov r0, r6 <== NOT EXECUTED
36e14: e1a01008 mov r1, r8 <== NOT EXECUTED
36e18: ebfffdae bl 364d8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
if (rc > 0)
36e1c: e250a000 subs sl, r0, #0 <== NOT EXECUTED
36e20: da000091 ble 3706c <rtems_rfs_format+0xb74> <== NOT EXECUTED
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
36e24: eb0031a6 bl 434c4 <strerror> <== NOT EXECUTED
36e28: e1a0100a mov r1, sl <== NOT EXECUTED
36e2c: e1a02000 mov r2, r0 <== NOT EXECUTED
36e30: e59f02c0 ldr r0, [pc, #704] ; 370f8 <rtems_rfs_format+0xc00><== NOT EXECUTED
36e34: ea000088 b 3705c <rtems_rfs_format+0xb64> <== NOT EXECUTED
printf (", blocks");
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
36e38: e28d50c0 add r5, sp, #192 ; 0xc0 <== NOT EXECUTED
36e3c: e1a09007 mov r9, r7 <== NOT EXECUTED
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
36e40: e59d3038 ldr r3, [sp, #56] ; 0x38 <== NOT EXECUTED
36e44: e5d90015 ldrb r0, [r9, #21] <== NOT EXECUTED
36e48: e1540003 cmp r4, r3 <== NOT EXECUTED
36e4c: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
36e50: baffff1d blt 36acc <rtems_rfs_format+0x5d4> <== NOT EXECUTED
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
if (config->verbose)
36e54: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("\n");
36e58: 13a0000a movne r0, #10 <== NOT EXECUTED
36e5c: 1b0029fa blne 4164c <putchar> <== NOT EXECUTED
rc = rtems_rfs_buffer_close (&fs);
36e60: e28d0018 add r0, sp, #24 <== NOT EXECUTED
36e64: ebfff5b4 bl 3453c <rtems_rfs_buffer_close> <== NOT EXECUTED
if (rc > 0)
36e68: e2504000 subs r4, r0, #0 <== NOT EXECUTED
36e6c: da000004 ble 36e84 <rtems_rfs_format+0x98c> <== NOT EXECUTED
{
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
36e70: eb003193 bl 434c4 <strerror> <== NOT EXECUTED
36e74: e1a01004 mov r1, r4 <== NOT EXECUTED
36e78: e1a02000 mov r2, r0 <== NOT EXECUTED
36e7c: e59f0278 ldr r0, [pc, #632] ; 370fc <rtems_rfs_format+0xc04><== NOT EXECUTED
36e80: ea000075 b 3705c <rtems_rfs_format+0xb64> <== NOT EXECUTED
int rc;
/*
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL,
36e84: e3a01000 mov r1, #0 <== NOT EXECUTED
36e88: e28dc0e8 add ip, sp, #232 ; 0xe8 <== NOT EXECUTED
36e8c: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED
36e90: e3a02006 mov r2, #6 <== NOT EXECUTED
36e94: e1a03001 mov r3, r1 <== NOT EXECUTED
36e98: e58dc000 str ip, [sp] <== NOT EXECUTED
36e9c: ebfffc44 bl 35fb4 <rtems_rfs_fs_open> <== NOT EXECUTED
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
36ea0: e3500000 cmp r0, #0 <== NOT EXECUTED
36ea4: aa000008 bge 36ecc <rtems_rfs_format+0x9d4> <== NOT EXECUTED
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
36ea8: eb001814 bl 3cf00 <__errno> <== NOT EXECUTED
36eac: e5904000 ldr r4, [r0] <== NOT EXECUTED
36eb0: eb001812 bl 3cf00 <__errno> <== NOT EXECUTED
36eb4: e5900000 ldr r0, [r0] <== NOT EXECUTED
36eb8: eb003181 bl 434c4 <strerror> <== NOT EXECUTED
36ebc: e1a01004 mov r1, r4 <== NOT EXECUTED
36ec0: e1a02000 mov r2, r0 <== NOT EXECUTED
36ec4: e59f0234 ldr r0, [pc, #564] ; 37100 <rtems_rfs_format+0xc08><== NOT EXECUTED
36ec8: ea00005a b 37038 <rtems_rfs_format+0xb40> <== NOT EXECUTED
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
36ecc: e59d00e8 ldr r0, [sp, #232] ; 0xe8 <== NOT EXECUTED
36ed0: e3a01001 mov r1, #1 <== NOT EXECUTED
36ed4: e28d20e4 add r2, sp, #228 ; 0xe4 <== NOT EXECUTED
36ed8: eb000303 bl 37aec <rtems_rfs_inode_alloc> <== NOT EXECUTED
if (rc > 0)
36edc: e2506000 subs r6, r0, #0 <== NOT EXECUTED
36ee0: da000005 ble 36efc <rtems_rfs_format+0xa04> <== NOT EXECUTED
{
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
36ee4: eb003176 bl 434c4 <strerror> <== NOT EXECUTED
36ee8: e1a01006 mov r1, r6 <== NOT EXECUTED
36eec: e1a02000 mov r2, r0 <== NOT EXECUTED
36ef0: e59f020c ldr r0, [pc, #524] ; 37104 <rtems_rfs_format+0xc0c><== NOT EXECUTED
36ef4: eb00295f bl 41478 <printf> <== NOT EXECUTED
36ef8: ea000019 b 36f64 <rtems_rfs_format+0xa6c> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
return rc;
}
if (ino != RTEMS_RFS_ROOT_INO)
36efc: e59d40e4 ldr r4, [sp, #228] ; 0xe4 <== NOT EXECUTED
36f00: e3540001 cmp r4, #1 <== NOT EXECUTED
36f04: 0a000005 beq 36f20 <rtems_rfs_format+0xa28> <== NOT EXECUTED
{
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
36f08: e1a01004 mov r1, r4 <== NOT EXECUTED
36f0c: e59f01f4 ldr r0, [pc, #500] ; 37108 <rtems_rfs_format+0xc10><== NOT EXECUTED
36f10: eb002958 bl 41478 <printf> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
36f14: e59d00e8 ldr r0, [sp, #232] ; 0xe8 <== NOT EXECUTED
36f18: ebfffc0a bl 35f48 <rtems_rfs_fs_close> <== NOT EXECUTED
36f1c: ea000046 b 3703c <rtems_rfs_format+0xb44> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
36f20: e28d5098 add r5, sp, #152 ; 0x98 <== NOT EXECUTED
36f24: e59d00e8 ldr r0, [sp, #232] ; 0xe8 <== NOT EXECUTED
36f28: e1a01004 mov r1, r4 <== NOT EXECUTED
36f2c: e1a02005 mov r2, r5 <== NOT EXECUTED
36f30: e1a03004 mov r3, r4 <== NOT EXECUTED
36f34: eb000292 bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
36f38: e2506000 subs r6, r0, #0 <== NOT EXECUTED
36f3c: da00000b ble 36f70 <rtems_rfs_format+0xa78> <== NOT EXECUTED
{
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
36f40: eb00315f bl 434c4 <strerror> <== NOT EXECUTED
36f44: e1a01006 mov r1, r6 <== NOT EXECUTED
36f48: e1a02000 mov r2, r0 <== NOT EXECUTED
36f4c: e59f01b8 ldr r0, [pc, #440] ; 3710c <rtems_rfs_format+0xc14><== NOT EXECUTED
36f50: eb002948 bl 41478 <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_group_bitmap_free (fs, true, ino);
36f54: e1a01004 mov r1, r4 <== NOT EXECUTED
36f58: e59d00e8 ldr r0, [sp, #232] ; 0xe8 <== NOT EXECUTED
36f5c: e59d20e4 ldr r2, [sp, #228] ; 0xe4 <== NOT EXECUTED
36f60: eb0000c2 bl 37270 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
36f64: e59d00e8 ldr r0, [sp, #232] ; 0xe8 <== NOT EXECUTED
36f68: ebfffbf6 bl 35f48 <rtems_rfs_fs_close> <== NOT EXECUTED
36f6c: ea000035 b 37048 <rtems_rfs_format+0xb50> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
36f70: e3a0c000 mov ip, #0 <== NOT EXECUTED
36f74: e1a0100c mov r1, ip <== NOT EXECUTED
36f78: e1a00005 mov r0, r5 <== NOT EXECUTED
36f7c: e59f218c ldr r2, [pc, #396] ; 37110 <rtems_rfs_format+0xc18><== NOT EXECUTED
36f80: e1a0300c mov r3, ip <== NOT EXECUTED
36f84: e58dc000 str ip, [sp] <== NOT EXECUTED
36f88: eb0001d4 bl 376e0 <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)
36f8c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
36f90: da000004 ble 36fa8 <rtems_rfs_format+0xab0> <== NOT EXECUTED
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
36f94: eb00314a bl 434c4 <strerror> <== NOT EXECUTED
36f98: e1a01004 mov r1, r4 <== NOT EXECUTED
36f9c: e1a02000 mov r2, r0 <== NOT EXECUTED
36fa0: e59f016c ldr r0, [pc, #364] ; 37114 <rtems_rfs_format+0xc1c><== NOT EXECUTED
36fa4: eb002933 bl 41478 <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
36fa8: e59dc0e4 ldr ip, [sp, #228] ; 0xe4 <== NOT EXECUTED
36fac: e59d00e8 ldr r0, [sp, #232] ; 0xe8 <== NOT EXECUTED
36fb0: e28d1098 add r1, sp, #152 ; 0x98 <== NOT EXECUTED
36fb4: e59f215c ldr r2, [pc, #348] ; 37118 <rtems_rfs_format+0xc20><== NOT EXECUTED
36fb8: e3a03001 mov r3, #1 <== NOT EXECUTED
36fbc: e58dc000 str ip, [sp] <== NOT EXECUTED
36fc0: ebfff7f7 bl 34fa4 <rtems_rfs_dir_add_entry> <== NOT EXECUTED
if (rc > 0)
36fc4: e2504000 subs r4, r0, #0 <== NOT EXECUTED
36fc8: da000004 ble 36fe0 <rtems_rfs_format+0xae8> <== NOT EXECUTED
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
36fcc: eb00313c bl 434c4 <strerror> <== NOT EXECUTED
36fd0: e1a01004 mov r1, r4 <== NOT EXECUTED
36fd4: e1a02000 mov r2, r0 <== NOT EXECUTED
36fd8: e59f013c ldr r0, [pc, #316] ; 3711c <rtems_rfs_format+0xc24><== NOT EXECUTED
36fdc: eb002925 bl 41478 <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
36fe0: e59d00e8 ldr r0, [sp, #232] ; 0xe8 <== NOT EXECUTED
36fe4: e28d1098 add r1, sp, #152 ; 0x98 <== NOT EXECUTED
36fe8: eb000242 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
36fec: e2504000 subs r4, r0, #0 <== NOT EXECUTED
36ff0: da000004 ble 37008 <rtems_rfs_format+0xb10> <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
36ff4: eb003132 bl 434c4 <strerror> <== NOT EXECUTED
36ff8: e1a01004 mov r1, r4 <== NOT EXECUTED
36ffc: e1a02000 mov r2, r0 <== NOT EXECUTED
37000: e59f0118 ldr r0, [pc, #280] ; 37120 <rtems_rfs_format+0xc28><== NOT EXECUTED
37004: eb00291b bl 41478 <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
37008: e59d00e8 ldr r0, [sp, #232] ; 0xe8 <== NOT EXECUTED
3700c: ebfffbcd bl 35f48 <rtems_rfs_fs_close> <== NOT EXECUTED
if (rc < 0)
37010: e2506000 subs r6, r0, #0 <== NOT EXECUTED
37014: aa00000a bge 37044 <rtems_rfs_format+0xb4c> <== NOT EXECUTED
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
37018: eb0017b8 bl 3cf00 <__errno> <== NOT EXECUTED
3701c: e5904000 ldr r4, [r0] <== NOT EXECUTED
37020: eb0017b6 bl 3cf00 <__errno> <== NOT EXECUTED
37024: e5900000 ldr r0, [r0] <== NOT EXECUTED
37028: eb003125 bl 434c4 <strerror> <== NOT EXECUTED
3702c: e1a02000 mov r2, r0 <== NOT EXECUTED
37030: e59f00ec ldr r0, [pc, #236] ; 37124 <rtems_rfs_format+0xc2c><== NOT EXECUTED
37034: e1a01004 mov r1, r4 <== NOT EXECUTED
37038: eb00290e bl 41478 <printf> <== NOT EXECUTED
3703c: e3a00000 mov r0, #0 <== NOT EXECUTED
37040: ea000007 b 37064 <rtems_rfs_format+0xb6c> <== NOT EXECUTED
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
37044: dafffffc ble 3703c <rtems_rfs_format+0xb44> <== NOT EXECUTED
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
37048: e1a00006 mov r0, r6 <== NOT EXECUTED
3704c: eb00311c bl 434c4 <strerror> <== NOT EXECUTED
37050: e1a02000 mov r2, r0 <== NOT EXECUTED
37054: e59f00cc ldr r0, [pc, #204] ; 37128 <rtems_rfs_format+0xc30><== NOT EXECUTED
37058: e1a01006 mov r1, r6 <== NOT EXECUTED
3705c: eb002905 bl 41478 <printf> <== NOT EXECUTED
37060: e3e00000 mvn r0, #0 <== NOT EXECUTED
rc, strerror (rc));
return -1;
}
return 0;
}
37064: e28dd0ec add sp, sp, #236 ; 0xec <== NOT EXECUTED
37068: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
3706c: e2844001 add r4, r4, #1 <== NOT EXECUTED
37070: eaffff72 b 36e40 <rtems_rfs_format+0x948> <== NOT EXECUTED
00035f48 <rtems_rfs_fs_close>:
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
35f48: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
35f4c: e3a05000 mov r5, #0 <== NOT EXECUTED
35f50: e1a04000 mov r4, r0 <== NOT EXECUTED
35f54: e1a06005 mov r6, r5 <== 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++)
35f58: ea000004 b 35f70 <rtems_rfs_fs_close+0x28> <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[group]);
35f5c: e594101c ldr r1, [r4, #28] <== NOT EXECUTED
35f60: e0811005 add r1, r1, r5 <== NOT EXECUTED
35f64: eb00053f bl 37468 <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++)
35f68: e2866001 add r6, r6, #1 <== NOT EXECUTED
35f6c: e2855050 add r5, r5, #80 ; 0x50 <== NOT EXECUTED
35f70: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED
35f74: e1560003 cmp r6, r3 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[group]);
35f78: e1a00004 mov r0, r4 <== 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++)
35f7c: bafffff6 blt 35f5c <rtems_rfs_fs_close+0x14> <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[group]);
rtems_rfs_buffer_close (fs);
35f80: ebfff96d bl 3453c <rtems_rfs_buffer_close> <== NOT EXECUTED
free (fs);
35f84: e1a00004 mov r0, r4 <== NOT EXECUTED
35f88: ebff45c9 bl 76b4 <free> <== NOT EXECUTED
return 0;
}
35f8c: e3a00000 mov r0, #0 <== NOT EXECUTED
35f90: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00035f28 <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);
35f28: e590300c ldr r3, [r0, #12] <== NOT EXECUTED
35f2c: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED
35f30: e593201c ldr r2, [r3, #28] <== NOT EXECUTED
return blocks * block_size;
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
35f34: e92d4010 push {r4, lr} <== NOT EXECUTED
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
35f38: 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;
}
35f3c: e1a01004 mov r1, r4 <== NOT EXECUTED
35f40: e1a00003 mov r0, r3 <== NOT EXECUTED
35f44: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00035fb4 <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)
{
35fb4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
35fb8: e24dd03c sub sp, sp, #60 ; 0x3c <== NOT EXECUTED
35fbc: 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));
35fc0: 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)
{
35fc4: e59d4060 ldr r4, [sp, #96] ; 0x60 <== NOT EXECUTED
35fc8: e1a07001 mov r7, r1 <== NOT EXECUTED
35fcc: e1a06002 mov r6, r2 <== NOT EXECUTED
35fd0: 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));
35fd4: ebff475d bl 7d50 <malloc> <== NOT EXECUTED
if (!*fs)
35fd8: 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));
35fdc: e5840000 str r0, [r4] <== NOT EXECUTED
if (!*fs)
35fe0: 1a000002 bne 35ff0 <rtems_rfs_fs_open+0x3c> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: no memory for file system data\n");
errno = ENOMEM;
35fe4: eb001bc5 bl 3cf00 <__errno> <== NOT EXECUTED
35fe8: e3a0300c mov r3, #12 <== NOT EXECUTED
35fec: ea0000fe b 363ec <rtems_rfs_fs_open+0x438> <== NOT EXECUTED
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
35ff0: e3a01000 mov r1, #0 <== NOT EXECUTED
35ff4: e3a02080 mov r2, #128 ; 0x80 <== NOT EXECUTED
35ff8: eb0028f7 bl 403dc <memset> <== NOT EXECUTED
(*fs)->user = user;
35ffc: e5941000 ldr r1, [r4] <== 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;
36000: e3a05000 mov r5, #0 <== NOT EXECUTED
the_chain->last = _Chain_Head(the_chain);
36004: 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);
36008: e281b044 add fp, r1, #68 ; 0x44 <== NOT EXECUTED
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
3600c: 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);
36010: e281a054 add sl, r1, #84 ; 0x54 <== NOT EXECUTED
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
36014: 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);
36018: e281c064 add ip, r1, #100 ; 0x64 <== NOT EXECUTED
3601c: e2812074 add r2, r1, #116 ; 0x74 <== NOT EXECUTED
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
36020: e2813070 add r3, r1, #112 ; 0x70 <== NOT EXECUTED
36024: 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;
36028: e5816000 str r6, [r1] <== NOT EXECUTED
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
(*fs)->user = user;
3602c: 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);
36030: e581b040 str fp, [r1, #64] ; 0x40 <== NOT EXECUTED
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
36034: 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);
36038: e581a050 str sl, [r1, #80] ; 0x50 <== NOT EXECUTED
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
3603c: 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);
36040: e581c060 str ip, [r1, #96] ; 0x60 <== NOT EXECUTED
36044: e5812070 str r2, [r1, #112] ; 0x70 <== NOT EXECUTED
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
36048: 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;
3604c: 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;
36050: e5815044 str r5, [r1, #68] ; 0x44 <== NOT EXECUTED
36054: e5815054 str r5, [r1, #84] ; 0x54 <== NOT EXECUTED
36058: e5815064 str r5, [r1, #100] ; 0x64 <== NOT EXECUTED
3605c: e5815074 str r5, [r1, #116] ; 0x74 <== NOT EXECUTED
(*fs)->buffers_count = 0;
36060: e581504c str r5, [r1, #76] ; 0x4c <== NOT EXECUTED
(*fs)->release_count = 0;
36064: e581505c str r5, [r1, #92] ; 0x5c <== NOT EXECUTED
(*fs)->release_modified_count = 0;
36068: e581506c str r5, [r1, #108] ; 0x6c <== NOT EXECUTED
group_base = 0;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
3606c: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
36070: ebfff93b bl 34564 <rtems_rfs_buffer_open> <== NOT EXECUTED
if (rc > 0)
36074: e2506000 subs r6, r0, #0 <== NOT EXECUTED
36078: da000005 ble 36094 <rtems_rfs_fs_open+0xe0> <== NOT EXECUTED
{
free (*fs);
3607c: e5940000 ldr r0, [r4] <== NOT EXECUTED
36080: ebff458b bl 76b4 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
rc, strerror (rc));
errno = rc;
36084: eb001b9d bl 3cf00 <__errno> <== NOT EXECUTED
36088: e5806000 str r6, [r0] <== NOT EXECUTED
3608c: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
36090: ea0000e6 b 36430 <rtems_rfs_fs_open+0x47c> <== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
36094: e5946000 ldr r6, [r4] <== 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);
36098: e28d7030 add r7, sp, #48 ; 0x30 <== NOT EXECUTED
3609c: e1a02005 mov r2, r5 <== NOT EXECUTED
360a0: e1a00006 mov r0, r6 <== NOT EXECUTED
360a4: e1a01007 mov r1, r7 <== NOT EXECUTED
360a8: 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;
360ac: e5cd5030 strb r5, [sp, #48] ; 0x30 <== NOT EXECUTED
handle->bnum = 0;
360b0: e58d5034 str r5, [sp, #52] ; 0x34 <== NOT EXECUTED
handle->buffer = NULL;
360b4: e58d5038 str r5, [sp, #56] ; 0x38 <== NOT EXECUTED
360b8: ebfff988 bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
360bc: e2508000 subs r8, r0, #0 <== NOT EXECUTED
360c0: ca0000ac bgt 36378 <rtems_rfs_fs_open+0x3c4> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
360c4: e59d3038 ldr r3, [sp, #56] ; 0x38 <== NOT EXECUTED
360c8: 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)
360cc: e5d32003 ldrb r2, [r3, #3] <== NOT EXECUTED
360d0: e5d31000 ldrb r1, [r3] <== NOT EXECUTED
360d4: e5d30001 ldrb r0, [r3, #1] <== NOT EXECUTED
360d8: e1821c01 orr r1, r2, r1, lsl #24 <== NOT EXECUTED
360dc: e5d32002 ldrb r2, [r3, #2] <== NOT EXECUTED
360e0: e1811800 orr r1, r1, r0, lsl #16 <== NOT EXECUTED
360e4: e1811402 orr r1, r1, r2, lsl #8 <== NOT EXECUTED
360e8: e59f2368 ldr r2, [pc, #872] ; 36458 <rtems_rfs_fs_open+0x4a4><== NOT EXECUTED
360ec: e1510002 cmp r1, r2 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
rtems_rfs_buffer_handle_close (fs, &handle);
360f0: 11a00006 movne r0, r6 <== NOT EXECUTED
360f4: 11a01007 movne r1, r7 <== NOT EXECUTED
sb = rtems_rfs_buffer_data (&handle);
#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
360f8: 1a00001d bne 36174 <rtems_rfs_fs_open+0x1c0> <== 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);
360fc: e5d3000d ldrb r0, [r3, #13] <== NOT EXECUTED
36100: e5d3200c ldrb r2, [r3, #12] <== NOT EXECUTED
36104: e5d3100f ldrb r1, [r3, #15] <== NOT EXECUTED
36108: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
3610c: e1800c02 orr r0, r0, r2, lsl #24 <== NOT EXECUTED
36110: e5d3200e ldrb r2, [r3, #14] <== NOT EXECUTED
36114: e1800001 orr r0, r0, r1 <== NOT EXECUTED
36118: e1800402 orr r0, r0, r2, lsl #8 <== NOT EXECUTED
3611c: e5860004 str r0, [r6, #4] <== NOT EXECUTED
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
36120: e5d35009 ldrb r5, [r3, #9] <== NOT EXECUTED
36124: e5d32008 ldrb r2, [r3, #8] <== NOT EXECUTED
36128: e5d3100b ldrb r1, [r3, #11] <== NOT EXECUTED
3612c: e1a05805 lsl r5, r5, #16 <== NOT EXECUTED
36130: e1855c02 orr r5, r5, r2, lsl #24 <== NOT EXECUTED
36134: e5d3200a ldrb r2, [r3, #10] <== NOT EXECUTED
36138: e1855001 orr r5, r5, r1 <== NOT EXECUTED
3613c: e1855402 orr r5, r5, r2, lsl #8 <== NOT EXECUTED
36140: e5865008 str r5, [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);
36144: e596200c ldr r2, [r6, #12] <== NOT EXECUTED
36148: e592c01c ldr ip, [r2, #28] <== NOT EXECUTED
3614c: e592e024 ldr lr, [r2, #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))
36150: e0887095 umull r7, r8, r5, r0 <== 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);
36154: e0821c9e umull r1, r2, lr, ip <== NOT EXECUTED
36158: e1580002 cmp r8, r2 <== NOT EXECUTED
3615c: 8a000002 bhi 3616c <rtems_rfs_fs_open+0x1b8> <== NOT EXECUTED
36160: 1a000006 bne 36180 <rtems_rfs_fs_open+0x1cc> <== NOT EXECUTED
36164: e1570001 cmp r7, r1 <== NOT EXECUTED
36168: 9a000004 bls 36180 <rtems_rfs_fs_open+0x1cc> <== NOT EXECUTED
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
rtems_rfs_buffer_handle_close (fs, &handle);
3616c: e1a00006 mov r0, r6 <== NOT EXECUTED
36170: e28d1030 add r1, sp, #48 ; 0x30 <== NOT EXECUTED
36174: ebffff86 bl 35f94 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
36178: e3a08005 mov r8, #5 <== NOT EXECUTED
3617c: ea00007d b 36378 <rtems_rfs_fs_open+0x3c4> <== 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)
36180: e5d31025 ldrb r1, [r3, #37] ; 0x25 <== NOT EXECUTED
36184: e5d32024 ldrb r2, [r3, #36] ; 0x24 <== NOT EXECUTED
36188: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED
3618c: e5d30027 ldrb r0, [r3, #39] ; 0x27 <== NOT EXECUTED
36190: e1811c02 orr r1, r1, r2, lsl #24 <== NOT EXECUTED
36194: e5d32026 ldrb r2, [r3, #38] ; 0x26 <== NOT EXECUTED
36198: e1811000 orr r1, r1, r0 <== NOT EXECUTED
3619c: e1811402 orr r1, r1, r2, lsl #8 <== NOT EXECUTED
361a0: e3510038 cmp r1, #56 ; 0x38 <== NOT EXECUTED
361a4: 1afffff0 bne 3616c <rtems_rfs_fs_open+0x1b8> <== 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);
361a8: e5d32011 ldrb r2, [r3, #17] <== NOT EXECUTED
361ac: e5d30010 ldrb r0, [r3, #16] <== NOT EXECUTED
361b0: e5d3c013 ldrb ip, [r3, #19] <== NOT EXECUTED
361b4: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
361b8: e1822c00 orr r2, r2, r0, lsl #24 <== NOT EXECUTED
361bc: e5d30012 ldrb r0, [r3, #18] <== NOT EXECUTED
361c0: e182200c orr r2, r2, ip <== NOT EXECUTED
361c4: e1822400 orr r2, r2, r0, lsl #8 <== NOT EXECUTED
361c8: e5862014 str r2, [r6, #20] <== NOT EXECUTED
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
361cc: e5d32015 ldrb r2, [r3, #21] <== NOT EXECUTED
361d0: e5d30014 ldrb r0, [r3, #20] <== NOT EXECUTED
361d4: e5d3c017 ldrb ip, [r3, #23] <== NOT EXECUTED
361d8: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
361dc: e1822c00 orr r2, r2, r0, lsl #24 <== NOT EXECUTED
361e0: e5d30016 ldrb r0, [r3, #22] <== NOT EXECUTED
361e4: e182200c orr r2, r2, ip <== NOT EXECUTED
361e8: e1822400 orr r2, r2, r0, lsl #8 <== NOT EXECUTED
361ec: e5862018 str r2, [r6, #24] <== NOT EXECUTED
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
361f0: e5d30019 ldrb r0, [r3, #25] <== NOT EXECUTED
361f4: e5d32018 ldrb r2, [r3, #24] <== NOT EXECUTED
361f8: e5d3c01b ldrb ip, [r3, #27] <== NOT EXECUTED
361fc: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
36200: e1800c02 orr r0, r0, r2, lsl #24 <== NOT EXECUTED
36204: e5d3201a ldrb r2, [r3, #26] <== NOT EXECUTED
36208: e180000c orr r0, r0, ip <== NOT EXECUTED
3620c: e1800402 orr r0, r0, r2, lsl #8 <== NOT EXECUTED
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
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);
36210: e1a02125 lsr r2, r5, #2 <== NOT EXECUTED
return EIO;
}
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);
36214: e5860020 str r0, [r6, #32] <== 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 =
36218: e00a0292 mul sl, r2, r2 <== 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);
3621c: e5d3701d ldrb r7, [r3, #29] <== NOT EXECUTED
36220: e5d3c01c ldrb ip, [r3, #28] <== NOT EXECUTED
36224: e5d3e01f ldrb lr, [r3, #31] <== NOT EXECUTED
36228: e1a07807 lsl r7, r7, #16 <== NOT EXECUTED
3622c: e1877c0c orr r7, r7, ip, lsl #24 <== NOT EXECUTED
36230: e5d3c01e ldrb ip, [r3, #30] <== NOT EXECUTED
36234: e187700e orr r7, r7, lr <== NOT EXECUTED
36238: e187740c orr r7, r7, ip, lsl #8 <== NOT EXECUTED
3623c: e5867024 str r7, [r6, #36] ; 0x24 <== NOT EXECUTED
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
36240: e5d38021 ldrb r8, [r3, #33] ; 0x21 <== NOT EXECUTED
36244: e5d3c020 ldrb ip, [r3, #32] <== NOT EXECUTED
36248: e5d3e023 ldrb lr, [r3, #35] ; 0x23 <== NOT EXECUTED
3624c: e1a08808 lsl r8, r8, #16 <== NOT EXECUTED
36250: e1888c0c orr r8, r8, ip, lsl #24 <== NOT EXECUTED
36254: e5d3c022 ldrb ip, [r3, #34] ; 0x22 <== NOT EXECUTED
36258: e188300e orr r3, r8, lr <== NOT EXECUTED
3625c: e183340c orr r3, r3, ip, lsl #8 <== NOT EXECUTED
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
36260: e3a08005 mov r8, #5 <== NOT EXECUTED
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
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;
36264: e00c0390 mul ip, r0, r3 <== 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 =
36268: e00e0a98 mul lr, r8, sl <== 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 =
3626c: e0000298 mul r0, r8, r2 <== NOT EXECUTED
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
36270: e586e038 str lr, [r6, #56] ; 0x38 <== 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 =
36274: e5860034 str r0, [r6, #52] ; 0x34 <== NOT EXECUTED
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
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;
36278: e586c010 str ip, [r6, #16] <== NOT EXECUTED
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
3627c: e1a00005 mov r0, r5 <== 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);
36280: e5863028 str r3, [r6, #40] ; 0x28 <== NOT EXECUTED
fs->blocks_per_block =
36284: e5862030 str r2, [r6, #48] ; 0x30 <== 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;
36288: eb007ada bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
if (fs->group_blocks >
3628c: e1570185 cmp r7, r5, lsl #3 <== 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;
36290: e586002c str r0, [r6, #44] ; 0x2c <== NOT EXECUTED
36294: e28d5030 add r5, sp, #48 ; 0x30 <== NOT EXECUTED
if (fs->group_blocks >
36298: 8a000007 bhi 362bc <rtems_rfs_fs_open+0x308> <== 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);
3629c: e1a01005 mov r1, r5 <== NOT EXECUTED
362a0: e1a00006 mov r0, r6 <== NOT EXECUTED
362a4: ebffff3a bl 35f94 <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));
362a8: e1a00006 mov r0, r6 <== NOT EXECUTED
362ac: e5961008 ldr r1, [r6, #8] <== NOT EXECUTED
362b0: ebfff88e bl 344f0 <rtems_rfs_buffer_setblksize> <== NOT EXECUTED
if (rc > 0)
362b4: e2508000 subs r8, r0, #0 <== NOT EXECUTED
362b8: da000002 ble 362c8 <rtems_rfs_fs_open+0x314> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
362bc: e1a00006 mov r0, r6 <== NOT EXECUTED
362c0: e1a01005 mov r1, r5 <== NOT EXECUTED
362c4: ea000023 b 36358 <rtems_rfs_fs_open+0x3a4> <== 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));
362c8: e5960020 ldr r0, [r6, #32] <== NOT EXECUTED
362cc: e3a01050 mov r1, #80 ; 0x50 <== NOT EXECUTED
362d0: ebff4387 bl 70f4 <calloc> <== NOT EXECUTED
if (!fs->groups)
362d4: e3500000 cmp r0, #0 <== NOT EXECUTED
362d8: 13a07000 movne r7, #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));
362dc: e586001c str r0, [r6, #28] <== NOT EXECUTED
if (!fs->groups)
362e0: 11a05007 movne r5, r7 <== NOT EXECUTED
362e4: 1a00001e bne 36364 <rtems_rfs_fs_open+0x3b0> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
362e8: e1a00006 mov r0, r6 <== NOT EXECUTED
362ec: e1a01005 mov r1, r5 <== NOT EXECUTED
362f0: ebffff27 bl 35f94 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
362f4: e3a0800c mov r8, #12 <== NOT EXECUTED
362f8: ea00001e b 36378 <rtems_rfs_fs_open+0x3c4> <== NOT EXECUTED
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
{
rc = rtems_rfs_group_open (fs,
rtems_rfs_fs_block (fs, group, 0),
362fc: e5962024 ldr r2, [r6, #36] ; 0x24 <== NOT EXECUTED
* 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++)
{
rc = rtems_rfs_group_open (fs,
36300: e0010592 mul r1, r2, r5 <== NOT EXECUTED
36304: e596301c ldr r3, [r6, #28] <== NOT EXECUTED
36308: e0833007 add r3, r3, r7 <== NOT EXECUTED
3630c: e58d3000 str r3, [sp] <== NOT EXECUTED
36310: e2811001 add r1, r1, #1 <== NOT EXECUTED
36314: e5963028 ldr r3, [r6, #40] ; 0x28 <== NOT EXECUTED
36318: eb00046c bl 374d0 <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)
3631c: e2508000 subs r8, r0, #0 <== NOT EXECUTED
* 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++)
{
rc = rtems_rfs_group_open (fs,
36320: e2877050 add r7, r7, #80 ; 0x50 <== NOT EXECUTED
rtems_rfs_fs_block (fs, group, 0),
fs->group_blocks,
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
36324: da00000d ble 36360 <rtems_rfs_fs_open+0x3ac> <== NOT EXECUTED
36328: e3a07000 mov r7, #0 <== NOT EXECUTED
3632c: e1a0a007 mov sl, r7 <== NOT EXECUTED
36330: ea000004 b 36348 <rtems_rfs_fs_open+0x394> <== NOT EXECUTED
{
int g;
for (g = 0; g < group; g++)
rtems_rfs_group_close (fs, &fs->groups[g]);
36334: e596101c ldr r1, [r6, #28] <== NOT EXECUTED
36338: e0811007 add r1, r1, r7 <== NOT EXECUTED
3633c: eb000449 bl 37468 <rtems_rfs_group_close> <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
36340: e28aa001 add sl, sl, #1 <== NOT EXECUTED
36344: e2877050 add r7, r7, #80 ; 0x50 <== NOT EXECUTED
36348: e15a0005 cmp sl, r5 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
3634c: e1a00006 mov r0, r6 <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
36350: bafffff7 blt 36334 <rtems_rfs_fs_open+0x380> <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
rtems_rfs_buffer_handle_close (fs, &handle);
36354: e28d1030 add r1, sp, #48 ; 0x30 <== NOT EXECUTED
36358: ebffff0d bl 35f94 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
3635c: ea000005 b 36378 <rtems_rfs_fs_open+0x3c4> <== 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++)
36360: e2855001 add r5, r5, #1 <== NOT EXECUTED
36364: e5963020 ldr r3, [r6, #32] <== NOT EXECUTED
36368: e1550003 cmp r5, r3 <== NOT EXECUTED
{
rc = rtems_rfs_group_open (fs,
3636c: e1a00006 mov r0, r6 <== 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++)
36370: baffffe1 blt 362fc <rtems_rfs_fs_open+0x348> <== NOT EXECUTED
36374: ea00002f b 36438 <rtems_rfs_fs_open+0x484> <== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
36378: e5940000 ldr r0, [r4] <== NOT EXECUTED
3637c: ebfff86e bl 3453c <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
36380: e5940000 ldr r0, [r4] <== NOT EXECUTED
36384: ebff44ca bl 76b4 <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;
36388: eb001adc bl 3cf00 <__errno> <== NOT EXECUTED
3638c: e5808000 str r8, [r0] <== NOT EXECUTED
36390: eaffff3d b 3608c <rtems_rfs_fs_open+0xd8> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
36394: e5940000 ldr r0, [r4] <== NOT EXECUTED
36398: e5903000 ldr r3, [r0] <== NOT EXECUTED
3639c: e3130004 tst r3, #4 <== NOT EXECUTED
363a0: 1a000013 bne 363f4 <rtems_rfs_fs_open+0x440> <== 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);
363a4: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED
363a8: e5d23003 ldrb r3, [r2, #3] <== NOT EXECUTED
363ac: e5d22002 ldrb r2, [r2, #2] <== NOT EXECUTED
363b0: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
363b4: e59f20a0 ldr r2, [pc, #160] ; 3645c <rtems_rfs_fs_open+0x4a8><== NOT EXECUTED
363b8: e1530002 cmp r3, r2 <== NOT EXECUTED
363bc: 0a000002 beq 363cc <rtems_rfs_fs_open+0x418> <== NOT EXECUTED
363c0: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
363c4: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED
363c8: 0a000009 beq 363f4 <rtems_rfs_fs_open+0x440> <== NOT EXECUTED
{
rtems_rfs_inode_close (*fs, &inode);
363cc: e28d1008 add r1, sp, #8 <== NOT EXECUTED
363d0: eb000548 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
363d4: e5940000 ldr r0, [r4] <== NOT EXECUTED
363d8: ebfff857 bl 3453c <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
363dc: e5940000 ldr r0, [r4] <== NOT EXECUTED
363e0: ebff44b3 bl 76b4 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: invalid root inode mode\n");
errno = EIO;
363e4: eb001ac5 bl 3cf00 <__errno> <== NOT EXECUTED
363e8: e3a03005 mov r3, #5 <== NOT EXECUTED
363ec: e5803000 str r3, [r0] <== NOT EXECUTED
363f0: eaffff25 b 3608c <rtems_rfs_fs_open+0xd8> <== NOT EXECUTED
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
363f4: e28d1008 add r1, sp, #8 <== NOT EXECUTED
363f8: eb00053e bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
363fc: e2505000 subs r5, r0, #0 <== NOT EXECUTED
36400: da000006 ble 36420 <rtems_rfs_fs_open+0x46c> <== NOT EXECUTED
{
rtems_rfs_buffer_close (*fs);
36404: e5940000 ldr r0, [r4] <== NOT EXECUTED
36408: ebfff84b bl 3453c <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
3640c: e5940000 ldr r0, [r4] <== NOT EXECUTED
36410: ebff44a7 bl 76b4 <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;
36414: eb001ab9 bl 3cf00 <__errno> <== NOT EXECUTED
36418: e5805000 str r5, [r0] <== NOT EXECUTED
3641c: eaffff1a b 3608c <rtems_rfs_fs_open+0xd8> <== NOT EXECUTED
return -1;
}
errno = 0;
36420: eb001ab6 bl 3cf00 <__errno> <== NOT EXECUTED
36424: e3a03000 mov r3, #0 <== NOT EXECUTED
36428: e5803000 str r3, [r0] <== NOT EXECUTED
3642c: e1a00003 mov r0, r3 <== NOT EXECUTED
return 0;
}
36430: e28dd03c add sp, sp, #60 ; 0x3c <== NOT EXECUTED
36434: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
36438: e3a01001 mov r1, #1 <== NOT EXECUTED
3643c: e5940000 ldr r0, [r4] <== NOT EXECUTED
36440: e28d2008 add r2, sp, #8 <== NOT EXECUTED
36444: e1a03001 mov r3, r1 <== NOT EXECUTED
36448: eb00054d bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
3644c: e2505000 subs r5, r0, #0 <== NOT EXECUTED
36450: daffffcf ble 36394 <rtems_rfs_fs_open+0x3e0> <== NOT EXECUTED
36454: eaffffea b 36404 <rtems_rfs_fs_open+0x450> <== NOT EXECUTED
00035f0c <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)
{
35f0c: e5901008 ldr r1, [r0, #8] <== NOT EXECUTED
35f10: e5902004 ldr r2, [r0, #4] <== NOT EXECUTED
35f14: e92d4010 push {r4, lr} <== NOT EXECUTED
35f18: 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;
}
35f1c: e1a01004 mov r1, r4 <== NOT EXECUTED
35f20: e1a00003 mov r0, r3 <== NOT EXECUTED
35f24: e8bd8010 pop {r4, pc} <== NOT EXECUTED
000372e4 <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)
{
372e4: 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)
372e8: e21290ff ands r9, r2, #255 ; 0xff <== NOT EXECUTED
{
size = fs->group_inodes;
372ec: 15906028 ldrne r6, [r0, #40] ; 0x28 <== NOT EXECUTED
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
372f0: 05906024 ldreq r6, [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)
{
372f4: e1a04001 mov r4, r1 <== NOT EXECUTED
int direction;
if (inode)
{
size = fs->group_inodes;
goal -= RTEMS_RFS_ROOT_INO;
372f8: 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)
{
372fc: e24dd014 sub sp, sp, #20 <== NOT EXECUTED
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
37300: e1a01006 mov r1, r6 <== 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)
{
37304: e1a05000 mov r5, r0 <== NOT EXECUTED
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
37308: 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)
{
3730c: e58d3000 str r3, [sp] <== NOT EXECUTED
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
37310: eb0076b8 bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (goal % size);
37314: e1a01006 mov r1, r6 <== NOT EXECUTED
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
37318: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (goal % size);
3731c: e1a00004 mov r0, r4 <== NOT EXECUTED
37320: eb007748 bl 55048 <__umodsi3> <== NOT EXECUTED
37324: e3a04001 mov 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)
bit = direction > 0 ? 0 : size - 1;
37328: e2466001 sub r6, r6, #1 <== NOT EXECUTED
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
3732c: e3a07000 mov r7, #0 <== NOT EXECUTED
37330: e58d000c str r0, [sp, #12] <== 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;
37334: e58d6008 str r6, [sp, #8] <== NOT EXECUTED
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
37338: e1a08004 mov r8, r4 <== NOT EXECUTED
}
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
3733c: e3a0b050 mov fp, #80 ; 0x50 <== NOT EXECUTED
37340: ea000001 b 3734c <rtems_rfs_group_bitmap_alloc+0x68> <== NOT EXECUTED
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
37344: e3e04000 mvn r4, #0 <== NOT EXECUTED
37348: e3a08000 mov r8, #0 <== 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);
3734c: e59d6004 ldr r6, [sp, #4] <== NOT EXECUTED
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
37350: e3a02000 mov r2, #0 <== 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)
37354: e3570000 cmp r7, #0 <== NOT EXECUTED
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
37358: e5cd2013 strb r2, [sp, #19] <== 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);
3735c: e0266497 mla r6, r7, r4, r6 <== NOT EXECUTED
if (offset)
37360: 0a000003 beq 37374 <rtems_rfs_group_bitmap_alloc+0x90> <== NOT EXECUTED
bit = direction > 0 ? 0 : size - 1;
37364: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
37368: e3540001 cmp r4, #1 <== NOT EXECUTED
3736c: 03a03000 moveq r3, #0 <== NOT EXECUTED
37370: e58d300c str r3, [sp, #12] <== 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))
37374: e3560000 cmp r6, #0 <== NOT EXECUTED
37378: ba000002 blt 37388 <rtems_rfs_group_bitmap_alloc+0xa4> <== NOT EXECUTED
3737c: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED
37380: e1560003 cmp r6, r3 <== NOT EXECUTED
37384: ba000005 blt 373a0 <rtems_rfs_group_bitmap_alloc+0xbc> <== NOT EXECUTED
{
if (!updown)
37388: e3580000 cmp r8, #0 <== NOT EXECUTED
3738c: 0a000032 beq 3745c <rtems_rfs_group_bitmap_alloc+0x178> <== NOT EXECUTED
break;
direction = direction > 0 ? -1 : 1;
37390: e3540001 cmp r4, #1 <== NOT EXECUTED
37394: 13a04001 movne r4, #1 <== NOT EXECUTED
37398: 0affffe9 beq 37344 <rtems_rfs_group_bitmap_alloc+0x60> <== NOT EXECUTED
3739c: eaffffe9 b 37348 <rtems_rfs_group_bitmap_alloc+0x64> <== NOT EXECUTED
373a0: e595301c ldr r3, [r5, #28] <== NOT EXECUTED
updown = false;
continue;
}
if (inode)
373a4: e3590000 cmp r9, #0 <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
373a8: 102a369b mlane sl, fp, r6, r3 <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
373ac: 002a369b mlaeq sl, fp, r6, r3 <== NOT EXECUTED
updown = false;
continue;
}
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
373b0: 128aa02c addne sl, sl, #44 ; 0x2c <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
373b4: 028aa008 addeq sl, sl, #8 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
373b8: e1a0000a mov r0, sl <== NOT EXECUTED
373bc: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED
373c0: e28d2013 add r2, sp, #19 <== NOT EXECUTED
373c4: e28d300c add r3, sp, #12 <== NOT EXECUTED
373c8: eb00152e bl 3c888 <rtems_rfs_bitmap_map_alloc> <== NOT EXECUTED
if (rc > 0)
373cc: e3500000 cmp r0, #0 <== NOT EXECUTED
373d0: ca000022 bgt 37460 <rtems_rfs_group_bitmap_alloc+0x17c> <== NOT EXECUTED
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
373d4: e5953000 ldr r3, [r5] <== NOT EXECUTED
373d8: e3130001 tst r3, #1 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
373dc: 059a1000 ldreq r1, [sl] <== NOT EXECUTED
373e0: 01a00005 moveq r0, r5 <== NOT EXECUTED
373e4: 0bfff474 bleq 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (allocated)
373e8: e5dd3013 ldrb r3, [sp, #19] <== NOT EXECUTED
373ec: e3530000 cmp r3, #0 <== NOT EXECUTED
373f0: 0a000012 beq 37440 <rtems_rfs_group_bitmap_alloc+0x15c> <== NOT EXECUTED
{
if (inode)
373f4: e3590000 cmp r9, #0 <== NOT EXECUTED
373f8: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
373fc: 0a000006 beq 3741c <rtems_rfs_group_bitmap_alloc+0x138> <== NOT EXECUTED
*result = rtems_rfs_group_inode (fs, group, bit);
37400: e5951028 ldr r1, [r5, #40] ; 0x28 <== NOT EXECUTED
37404: e2833001 add r3, r3, #1 <== NOT EXECUTED
37408: e0223691 mla r2, r1, r6, r3 <== NOT EXECUTED
3740c: e59d3000 ldr r3, [sp] <== NOT EXECUTED
37410: e3a00000 mov r0, #0 <== NOT EXECUTED
37414: e5832000 str r2, [r3] <== NOT EXECUTED
37418: ea000010 b 37460 <rtems_rfs_group_bitmap_alloc+0x17c> <== NOT EXECUTED
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
3741c: e3a01050 mov r1, #80 ; 0x50 <== NOT EXECUTED
37420: e0020691 mul r2, r1, r6 <== NOT EXECUTED
37424: e595101c ldr r1, [r5, #28] <== NOT EXECUTED
37428: e7912002 ldr r2, [r1, r2] <== NOT EXECUTED
3742c: e0833002 add r3, r3, r2 <== NOT EXECUTED
37430: e59d2000 ldr r2, [sp] <== NOT EXECUTED
37434: e1a00009 mov r0, r9 <== NOT EXECUTED
37438: e5823000 str r3, [r2] <== NOT EXECUTED
3743c: ea000007 b 37460 <rtems_rfs_group_bitmap_alloc+0x17c> <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
inode ? "inode" : "block", *result);
return 0;
}
if (updown)
37440: e3580000 cmp r8, #0 <== NOT EXECUTED
37444: 0a000002 beq 37454 <rtems_rfs_group_bitmap_alloc+0x170> <== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
37448: e3540001 cmp r4, #1 <== NOT EXECUTED
3744c: 03e04000 mvneq r4, #0 <== NOT EXECUTED
37450: 13a04001 movne r4, #1 <== NOT EXECUTED
offset++;
37454: e2877001 add r7, r7, #1 <== NOT EXECUTED
37458: eaffffbb b 3734c <rtems_rfs_group_bitmap_alloc+0x68> <== NOT EXECUTED
3745c: 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;
}
37460: e28dd014 add sp, sp, #20 <== NOT EXECUTED
37464: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00037270 <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
37270: e92d40f0 push {r4, r5, r6, r7, lr} <== 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)
37274: e21150ff ands r5, r1, #255 ; 0xff <== NOT EXECUTED
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
37278: 15906028 ldrne r6, [r0, #40] ; 0x28 <== NOT EXECUTED
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
3727c: 05906024 ldreq r6, [r0, #36] ; 0x24 <== NOT EXECUTED
37280: e2427001 sub r7, r2, #1 <== NOT EXECUTED
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
37284: e1a04000 mov r4, r0 <== NOT EXECUTED
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
37288: e1a01006 mov r1, r6 <== NOT EXECUTED
3728c: e1a00007 mov r0, r7 <== NOT EXECUTED
37290: eb0076d8 bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
37294: e3550000 cmp r5, #0 <== NOT EXECUTED
37298: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
3729c: 13a02050 movne r2, #80 ; 0x50 <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
372a0: 03a02050 moveq r2, #80 ; 0x50 <== NOT EXECUTED
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
372a4: 10253092 mlane r5, r2, r0, r3 <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
372a8: 00253092 mlaeq r5, r2, r0, r3 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
372ac: e1a01006 mov r1, r6 <== NOT EXECUTED
372b0: e1a00007 mov r0, r7 <== NOT EXECUTED
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
372b4: 1285502c addne r5, r5, #44 ; 0x2c <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
372b8: 02855008 addeq r5, r5, #8 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
372bc: eb007761 bl 55048 <__umodsi3> <== NOT EXECUTED
372c0: e1a01000 mov r1, r0 <== NOT EXECUTED
372c4: e1a00005 mov r0, r5 <== NOT EXECUTED
372c8: eb0014aa bl 3c578 <rtems_rfs_bitmap_map_clear> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
372cc: 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);
372d0: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
372d4: e1a00004 mov r0, r4 <== NOT EXECUTED
372d8: ebfff4b7 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
return rc;
}
372dc: e1a00006 mov r0, r6 <== NOT EXECUTED
372e0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
000371c0 <rtems_rfs_group_bitmap_test>:
int
rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no,
bool* state)
{
371c0: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== 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)
371c4: e21150ff ands r5, 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)
{
371c8: e1a04000 mov r4, r0 <== NOT EXECUTED
371cc: e1a06002 mov r6, r2 <== NOT EXECUTED
371d0: e1a08003 mov r8, 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)
371d4: 0a000007 beq 371f8 <rtems_rfs_group_bitmap_test+0x38> <== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
371d8: e3520000 cmp r2, #0 <== NOT EXECUTED
371dc: da000020 ble 37264 <rtems_rfs_group_bitmap_test+0xa4> <== NOT EXECUTED
371e0: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
371e4: e1520003 cmp r2, r3 <== NOT EXECUTED
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
371e8: 92426001 subls r6, r2, #1 <== NOT EXECUTED
size = fs->group_inodes;
371ec: 95907028 ldrls r7, [r0, #40] ; 0x28 <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
inode ? "inode" : "block", no);
if (inode)
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
371f0: 9a000004 bls 37208 <rtems_rfs_group_bitmap_test+0x48> <== NOT EXECUTED
371f4: ea00001a b 37264 <rtems_rfs_group_bitmap_test+0xa4> <== NOT EXECUTED
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
371f8: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED
371fc: e1520003 cmp r2, r3 <== NOT EXECUTED
37200: 2a000017 bcs 37264 <rtems_rfs_group_bitmap_test+0xa4> <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
37204: e5907024 ldr r7, [r0, #36] ; 0x24 <== NOT EXECUTED
}
group = no / size;
37208: e1a01007 mov r1, r7 <== NOT EXECUTED
3720c: e1a00006 mov r0, r6 <== NOT EXECUTED
37210: eb0076f8 bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
37214: e3550000 cmp r5, #0 <== NOT EXECUTED
37218: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
3721c: 13a02050 movne r2, #80 ; 0x50 <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
37220: 03a02050 moveq r2, #80 ; 0x50 <== NOT EXECUTED
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
37224: 10253092 mlane r5, r2, r0, r3 <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
37228: 00253092 mlaeq r5, r2, r0, r3 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
3722c: e1a01007 mov r1, r7 <== NOT EXECUTED
37230: e1a00006 mov r0, r6 <== NOT EXECUTED
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
37234: 1285502c addne r5, r5, #44 ; 0x2c <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
37238: 02855008 addeq r5, r5, #8 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
3723c: eb007781 bl 55048 <__umodsi3> <== NOT EXECUTED
37240: e1a02008 mov r2, r8 <== NOT EXECUTED
37244: e1a01000 mov r1, r0 <== NOT EXECUTED
37248: e1a00005 mov r0, r5 <== NOT EXECUTED
3724c: eb0014b3 bl 3c520 <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
37250: 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);
37254: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
37258: e1a00004 mov r0, r4 <== NOT EXECUTED
3725c: ebfff4d6 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
return rc;
37260: ea000000 b 37268 <rtems_rfs_group_bitmap_test+0xa8> <== NOT EXECUTED
37264: e3a06016 mov r6, #22 <== NOT EXECUTED
}
37268: e1a00006 mov r0, r6 <== NOT EXECUTED
3726c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00037468 <rtems_rfs_group_close>:
return 0;
}
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
37468: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
3746c: e1a06000 mov r6, 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);
37470: e281002c add r0, r1, #44 ; 0x2c <== NOT EXECUTED
return 0;
}
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
37474: 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);
37478: eb00138b bl 3c2ac <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);
3747c: e2841044 add r1, r4, #68 ; 0x44 <== NOT EXECUTED
37480: e1a07000 mov r7, r0 <== NOT EXECUTED
37484: e1a00006 mov r0, r6 <== NOT EXECUTED
37488: ebfff44b bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
3748c: e3a03000 mov r3, #0 <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
37490: 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;
37494: e5c43044 strb r3, [r4, #68] ; 0x44 <== NOT EXECUTED
handle->bnum = 0;
37498: 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);
3749c: e2840008 add r0, r4, #8 <== NOT EXECUTED
374a0: eb001381 bl 3c2ac <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);
374a4: e2841020 add r1, r4, #32 <== NOT EXECUTED
if (rc > 0)
374a8: e2505000 subs r5, r0, #0 <== NOT EXECUTED
374ac: e1a00006 mov r0, r6 <== NOT EXECUTED
374b0: d1c75fc7 bicle r5, r7, r7, asr #31 <== NOT EXECUTED
374b4: ebfff440 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
374b8: e3a03000 mov r3, #0 <== NOT EXECUTED
handle->bnum = 0;
handle->buffer = NULL;
374bc: 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;
374c0: e5c43020 strb r3, [r4, #32] <== NOT EXECUTED
handle->bnum = 0;
374c4: 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;
}
374c8: e1a00005 mov r0, r5 <== NOT EXECUTED
374cc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
000374d0 <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)
{
374d0: e92d4ff3 push {r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
374d4: e1a06000 mov r6, r0 <== NOT EXECUTED
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
374d8: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED
374dc: e1510000 cmp r1, r0 <== 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)
{
374e0: e1a0c001 mov ip, r1 <== NOT EXECUTED
374e4: e1a07002 mov r7, r2 <== NOT EXECUTED
374e8: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
374ec: e59d402c ldr r4, [sp, #44] ; 0x2c <== NOT EXECUTED
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
374f0: 23a0b005 movcs fp, #5 <== NOT EXECUTED
374f4: 2a00003a bcs 375e4 <rtems_rfs_group_open+0x114> <== 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))
374f8: e0823001 add r3, r2, r1 <== NOT EXECUTED
374fc: e1530000 cmp r3, r0 <== NOT EXECUTED
size = rtems_rfs_fs_blocks (fs) - base;
37500: 20617000 rsbcs 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;
37504: 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,
37508: e2849008 add r9, r4, #8 <== NOT EXECUTED
3750c: 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;
37510: e8840082 stm r4, {r1, r7} <== NOT EXECUTED
37514: e5c45020 strb r5, [r4, #32] <== NOT EXECUTED
handle->bnum = 0;
37518: e5845024 str r5, [r4, #36] ; 0x24 <== NOT EXECUTED
handle->buffer = NULL;
3751c: 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,
37520: e1a00009 mov r0, r9 <== NOT EXECUTED
37524: e1a01006 mov r1, r6 <== NOT EXECUTED
37528: e1a02008 mov r2, r8 <== NOT EXECUTED
3752c: e1a03007 mov r3, r7 <== NOT EXECUTED
37530: e58dc000 str ip, [sp] <== NOT EXECUTED
37534: eb00139e bl 3c3b4 <rtems_rfs_bitmap_open> <== NOT EXECUTED
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
37538: e250b000 subs fp, r0, #0 <== NOT EXECUTED
3753c: ca000017 bgt 375a0 <rtems_rfs_group_open+0xd0> <== 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,
37540: e594c000 ldr ip, [r4] <== NOT EXECUTED
37544: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
37548: e284a044 add sl, r4, #68 ; 0x44 <== NOT EXECUTED
3754c: e1570003 cmp r7, r3 <== NOT EXECUTED
37550: 31a03007 movcc r3, r7 <== NOT EXECUTED
37554: e28cc001 add ip, ip, #1 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
37558: e5c45044 strb r5, [r4, #68] ; 0x44 <== NOT EXECUTED
handle->bnum = 0;
3755c: e5845048 str r5, [r4, #72] ; 0x48 <== NOT EXECUTED
handle->buffer = NULL;
37560: e584504c str r5, [r4, #76] ; 0x4c <== NOT EXECUTED
37564: e284002c add r0, r4, #44 ; 0x2c <== NOT EXECUTED
37568: e1a01006 mov r1, r6 <== NOT EXECUTED
3756c: e1a0200a mov r2, sl <== NOT EXECUTED
37570: e58dc000 str ip, [sp] <== NOT EXECUTED
37574: eb00138e bl 3c3b4 <rtems_rfs_bitmap_open> <== NOT EXECUTED
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
37578: e250b000 subs fp, r0, #0 <== NOT EXECUTED
3757c: da00000e ble 375bc <rtems_rfs_group_open+0xec> <== 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);
37580: e1a0100a mov r1, sl <== NOT EXECUTED
37584: e1a00006 mov r0, r6 <== NOT EXECUTED
37588: ebfff40b bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
3758c: e5c45044 strb r5, [r4, #68] ; 0x44 <== NOT EXECUTED
handle->bnum = 0;
37590: e5845048 str r5, [r4, #72] ; 0x48 <== NOT EXECUTED
handle->buffer = NULL;
37594: e584504c str r5, [r4, #76] ; 0x4c <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
rtems_rfs_bitmap_close (&group->block_bitmap);
37598: e1a00009 mov r0, r9 <== NOT EXECUTED
3759c: eb001342 bl 3c2ac <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);
375a0: e1a00006 mov r0, r6 <== NOT EXECUTED
375a4: e1a01008 mov r1, r8 <== NOT EXECUTED
375a8: ebfff403 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
handle->buffer = NULL;
375ac: 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;
375b0: e5c45020 strb r5, [r4, #32] <== NOT EXECUTED
handle->bnum = 0;
375b4: e5845024 str r5, [r4, #36] ; 0x24 <== NOT EXECUTED
375b8: ea000009 b 375e4 <rtems_rfs_group_open+0x114> <== 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))
375bc: e596b000 ldr fp, [r6] <== NOT EXECUTED
375c0: e21bb001 ands fp, fp, #1 <== NOT EXECUTED
375c4: 11a0b005 movne fp, r5 <== NOT EXECUTED
375c8: 1a000005 bne 375e4 <rtems_rfs_group_open+0x114> <== NOT EXECUTED
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
375cc: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED
375d0: e1a00006 mov r0, r6 <== NOT EXECUTED
375d4: ebfff3f8 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
375d8: e1a00006 mov r0, r6 <== NOT EXECUTED
375dc: e594102c ldr r1, [r4, #44] ; 0x2c <== NOT EXECUTED
375e0: ebfff3f5 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
}
return 0;
}
375e4: e1a0000b mov r0, fp <== NOT EXECUTED
375e8: e8bd8ffc pop {r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0003712c <rtems_rfs_group_usage>:
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
3712c: e3a03000 mov r3, #0 <== NOT EXECUTED
int
rtems_rfs_group_usage (rtems_rfs_file_system* fs,
size_t* blocks,
size_t* inodes)
{
37130: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
int g;
*blocks = 0;
37134: e5813000 str r3, [r1] <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
37138: e1a0c003 mov ip, r3 <== NOT EXECUTED
size_t* inodes)
{
int g;
*blocks = 0;
*inodes = 0;
3713c: e5823000 str r3, [r2] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
37140: e5906020 ldr r6, [r0, #32] <== NOT EXECUTED
37144: e1a04003 mov r4, r3 <== NOT EXECUTED
37148: ea00000e b 37188 <rtems_rfs_group_usage+0x5c> <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
3714c: e590301c ldr r3, [r0, #28] <== NOT EXECUTED
37150: e083300c add r3, r3, ip <== NOT EXECUTED
*blocks +=
37154: e2838014 add r8, r3, #20 <== NOT EXECUTED
37158: e8980180 ldm r8, {r7, r8} <== NOT EXECUTED
3715c: e0477008 sub r7, r7, r8 <== NOT EXECUTED
37160: e0855007 add r5, r5, r7 <== NOT EXECUTED
37164: e5815000 str r5, [r1] <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
37168: e2835038 add r5, r3, #56 ; 0x38 <== NOT EXECUTED
3716c: e8950028 ldm r5, {r3, r5} <== NOT EXECUTED
37170: e0433005 sub r3, r3, r5 <== NOT EXECUTED
37174: e5925000 ldr r5, [r2] <== NOT EXECUTED
37178: e0853003 add r3, r5, r3 <== NOT EXECUTED
3717c: e5823000 str r3, [r2] <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
37180: e2844001 add r4, r4, #1 <== NOT EXECUTED
37184: e28cc050 add ip, ip, #80 ; 0x50 <== NOT EXECUTED
37188: e1540006 cmp r4, r6 <== NOT EXECUTED
3718c: e5915000 ldr r5, [r1] <== NOT EXECUTED
37190: baffffed blt 3714c <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))
37194: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED
37198: e1530005 cmp r3, r5 <== NOT EXECUTED
3719c: 95813000 strls r3, [r1] <== NOT EXECUTED
371a0: 85815000 strhi r5, [r1] <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
371a4: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
371a8: e5921000 ldr r1, [r2] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
371ac: 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))
371b0: e1510003 cmp r1, r3 <== NOT EXECUTED
371b4: 95821000 strls r1, [r2] <== NOT EXECUTED
371b8: 85823000 strhi r3, [r2] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
371bc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00037aec <rtems_rfs_inode_alloc>:
int
rtems_rfs_inode_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
rtems_rfs_ino* ino)
{
37aec: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
37af0: e1a04002 mov r4, r2 <== NOT EXECUTED
rtems_rfs_bitmap_bit bit;
int rc;
rc = rtems_rfs_group_bitmap_alloc (fs, goal, true, &bit);
37af4: e1a0300d mov r3, sp <== NOT EXECUTED
37af8: e3a02001 mov r2, #1 <== NOT EXECUTED
37afc: ebfffdf8 bl 372e4 <rtems_rfs_group_bitmap_alloc> <== NOT EXECUTED
*ino = bit;
37b00: e59d3000 ldr r3, [sp] <== NOT EXECUTED
37b04: e5843000 str r3, [r4] <== NOT EXECUTED
return rc;
}
37b08: e8bd8018 pop {r3, r4, pc} <== NOT EXECUTED
000378f8 <rtems_rfs_inode_close>:
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
378f8: 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);
378fc: e3a02001 mov r2, #1 <== NOT EXECUTED
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
37900: 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);
37904: ebffffd1 bl 37850 <rtems_rfs_inode_unload> <== NOT EXECUTED
if ((rc == 0) && (handle->loads > 0))
37908: e3500000 cmp r0, #0 <== NOT EXECUTED
3790c: 1a000003 bne 37920 <rtems_rfs_inode_close+0x28> <== NOT EXECUTED
37910: e5940024 ldr r0, [r4, #36] ; 0x24 <== NOT EXECUTED
37914: e3500000 cmp r0, #0 <== NOT EXECUTED
37918: c3a00005 movgt r0, #5 <== NOT EXECUTED
3791c: d3a00000 movle r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
handle->loads);
rc = EIO;
}
handle->ino = 0;
37920: e3a03000 mov r3, #0 <== NOT EXECUTED
37924: e5843008 str r3, [r4, #8] <== NOT EXECUTED
return rc;
}
37928: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00037b0c <rtems_rfs_inode_create>:
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
37b0c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
37b10: e24dd064 sub sp, sp, #100 ; 0x64 <== NOT EXECUTED
37b14: e1dda8b8 ldrh sl, [sp, #136] ; 0x88 <== NOT EXECUTED
37b18: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
37b1c: e20a6a0f and r6, sl, #61440 ; 0xf000 <== NOT EXECUTED
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
37b20: e1dd39b0 ldrh r3, [sp, #144] ; 0x90 <== NOT EXECUTED
37b24: e1ddc9b4 ldrh ip, [sp, #148] ; 0x94 <== NOT EXECUTED
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
37b28: e3560a06 cmp r6, #24576 ; 0x6000 <== NOT EXECUTED
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
37b2c: e1a04000 mov r4, r0 <== NOT EXECUTED
37b30: e1a08001 mov r8, r1 <== NOT EXECUTED
37b34: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
37b38: e59d5098 ldr r5, [sp, #152] ; 0x98 <== NOT EXECUTED
37b3c: e1ddb8bc ldrh fp, [sp, #140] ; 0x8c <== NOT EXECUTED
37b40: e58d300c str r3, [sp, #12] <== NOT EXECUTED
37b44: e58dc010 str ip, [sp, #16] <== NOT EXECUTED
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
37b48: 0a000009 beq 37b74 <rtems_rfs_inode_create+0x68> <== NOT EXECUTED
37b4c: ca000003 bgt 37b60 <rtems_rfs_inode_create+0x54> <== NOT EXECUTED
37b50: e3560a02 cmp r6, #8192 ; 0x2000 <== NOT EXECUTED
37b54: 0a000006 beq 37b74 <rtems_rfs_inode_create+0x68> <== NOT EXECUTED
37b58: e3560901 cmp r6, #16384 ; 0x4000 <== NOT EXECUTED
37b5c: ea000002 b 37b6c <rtems_rfs_inode_create+0x60> <== NOT EXECUTED
37b60: e3560902 cmp r6, #32768 ; 0x8000 <== NOT EXECUTED
37b64: 0a000002 beq 37b74 <rtems_rfs_inode_create+0x68> <== NOT EXECUTED
37b68: e3560a0a cmp r6, #40960 ; 0xa000 <== NOT EXECUTED
37b6c: 13a09016 movne r9, #22 <== NOT EXECUTED
37b70: 1a000077 bne 37d54 <rtems_rfs_inode_create+0x248> <== NOT EXECUTED
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
37b74: e1a00004 mov r0, r4 <== NOT EXECUTED
37b78: e1a01008 mov r1, r8 <== NOT EXECUTED
37b7c: e1a02005 mov r2, r5 <== NOT EXECUTED
37b80: ebffffd9 bl 37aec <rtems_rfs_inode_alloc> <== NOT EXECUTED
if (rc > 0)
37b84: e2509000 subs r9, r0, #0 <== NOT EXECUTED
37b88: ca000071 bgt 37d54 <rtems_rfs_inode_create+0x248> <== NOT EXECUTED
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
37b8c: e28d7014 add r7, sp, #20 <== NOT EXECUTED
37b90: e1a00004 mov r0, r4 <== NOT EXECUTED
37b94: e5951000 ldr r1, [r5] <== NOT EXECUTED
37b98: e1a02007 mov r2, r7 <== NOT EXECUTED
37b9c: e3a03001 mov r3, #1 <== NOT EXECUTED
37ba0: ebffff77 bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
37ba4: e2509000 subs r9, r0, #0 <== NOT EXECUTED
37ba8: ca000066 bgt 37d48 <rtems_rfs_inode_create+0x23c> <== NOT EXECUTED
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
37bac: e59dc010 ldr ip, [sp, #16] <== NOT EXECUTED
37bb0: e1a0100b mov r1, fp <== NOT EXECUTED
37bb4: e1a0200a mov r2, sl <== NOT EXECUTED
37bb8: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
37bbc: e1a00007 mov r0, r7 <== NOT EXECUTED
37bc0: e58dc000 str ip, [sp] <== NOT EXECUTED
37bc4: ebfffec5 bl 376e0 <rtems_rfs_inode_initialise> <== NOT EXECUTED
if (rc > 0)
37bc8: e2509000 subs r9, r0, #0 <== NOT EXECUTED
37bcc: da000003 ble 37be0 <rtems_rfs_inode_create+0xd4> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
37bd0: e1a01007 mov r1, r7 <== NOT EXECUTED
37bd4: e1a00004 mov r0, r4 <== NOT EXECUTED
37bd8: ebffff46 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
37bdc: ea000059 b 37d48 <rtems_rfs_inode_create+0x23c> <== 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))
37be0: e3560901 cmp r6, #16384 ; 0x4000 <== NOT EXECUTED
37be4: 1a000011 bne 37c30 <rtems_rfs_inode_create+0x124> <== NOT EXECUTED
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
37be8: e595c000 ldr ip, [r5] <== NOT EXECUTED
37bec: e1a00004 mov r0, r4 <== NOT EXECUTED
37bf0: e1a01007 mov r1, r7 <== NOT EXECUTED
37bf4: e59f2164 ldr r2, [pc, #356] ; 37d60 <rtems_rfs_inode_create+0x254><== NOT EXECUTED
37bf8: e3a03001 mov r3, #1 <== NOT EXECUTED
37bfc: e58dc000 str ip, [sp] <== NOT EXECUTED
37c00: ebfff4e7 bl 34fa4 <rtems_rfs_dir_add_entry> <== NOT EXECUTED
if (rc == 0)
37c04: e2509000 subs r9, r0, #0 <== NOT EXECUTED
37c08: 1a000006 bne 37c28 <rtems_rfs_inode_create+0x11c> <== NOT EXECUTED
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
37c0c: e1a01007 mov r1, r7 <== NOT EXECUTED
37c10: e1a00004 mov r0, r4 <== NOT EXECUTED
37c14: e59f2148 ldr r2, [pc, #328] ; 37d64 <rtems_rfs_inode_create+0x258><== NOT EXECUTED
37c18: e3a03002 mov r3, #2 <== NOT EXECUTED
37c1c: e58d8000 str r8, [sp] <== NOT EXECUTED
37c20: ebfff4df bl 34fa4 <rtems_rfs_dir_add_entry> <== NOT EXECUTED
37c24: e1a09000 mov r9, r0 <== NOT EXECUTED
if (rc > 0)
37c28: e3590000 cmp r9, #0 <== NOT EXECUTED
37c2c: ca000007 bgt 37c50 <rtems_rfs_inode_create+0x144> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
37c30: e28d703c add r7, sp, #60 ; 0x3c <== NOT EXECUTED
37c34: e1a01008 mov r1, r8 <== NOT EXECUTED
37c38: e1a00004 mov r0, r4 <== NOT EXECUTED
37c3c: e1a02007 mov r2, r7 <== NOT EXECUTED
37c40: e3a03001 mov r3, #1 <== NOT EXECUTED
37c44: ebffff4e bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
37c48: e2509000 subs r9, r0, #0 <== NOT EXECUTED
37c4c: da000006 ble 37c6c <rtems_rfs_inode_create+0x160> <== NOT EXECUTED
{
rtems_rfs_inode_delete (fs, &inode);
37c50: e28d5014 add r5, sp, #20 <== NOT EXECUTED
37c54: e1a01005 mov r1, r5 <== NOT EXECUTED
37c58: e1a00004 mov r0, r4 <== NOT EXECUTED
37c5c: ebffff7b bl 37a50 <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
37c60: e1a00004 mov r0, r4 <== NOT EXECUTED
37c64: e1a01005 mov r1, r5 <== NOT EXECUTED
37c68: ea00002e b 37d28 <rtems_rfs_inode_create+0x21c> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
37c6c: e595c000 ldr ip, [r5] <== NOT EXECUTED
37c70: e99d000c ldmib sp, {r2, r3} <== NOT EXECUTED
37c74: e1a00004 mov r0, r4 <== NOT EXECUTED
37c78: e1a01007 mov r1, r7 <== NOT EXECUTED
37c7c: e58dc000 str ip, [sp] <== NOT EXECUTED
37c80: ebfff4c7 bl 34fa4 <rtems_rfs_dir_add_entry> <== NOT EXECUTED
if (rc > 0)
37c84: e2509000 subs r9, r0, #0 <== NOT EXECUTED
37c88: da000009 ble 37cb4 <rtems_rfs_inode_create+0x1a8> <== NOT EXECUTED
{
rtems_rfs_inode_delete (fs, &inode);
37c8c: e28d5014 add r5, sp, #20 <== NOT EXECUTED
37c90: e1a01005 mov r1, r5 <== NOT EXECUTED
37c94: e1a00004 mov r0, r4 <== NOT EXECUTED
37c98: ebffff6c bl 37a50 <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
37c9c: e1a01005 mov r1, r5 <== NOT EXECUTED
37ca0: e1a00004 mov r0, r4 <== NOT EXECUTED
37ca4: ebffff13 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
37ca8: e1a00004 mov r0, r4 <== NOT EXECUTED
37cac: e1a01007 mov r1, r7 <== NOT EXECUTED
37cb0: ea00001c b 37d28 <rtems_rfs_inode_create+0x21c> <== 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))
37cb4: e3560901 cmp r6, #16384 ; 0x4000 <== NOT EXECUTED
37cb8: 1a00000f bne 37cfc <rtems_rfs_inode_create+0x1f0> <== 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);
37cbc: e59d2048 ldr r2, [sp, #72] ; 0x48 <== NOT EXECUTED
37cc0: e5d21000 ldrb r1, [r2] <== NOT EXECUTED
37cc4: e5d23001 ldrb r3, [r2, #1] <== NOT EXECUTED
37cc8: e1833401 orr r3, r3, r1, lsl #8 <== NOT EXECUTED
if (links == 0xffff)
37ccc: e59f1094 ldr r1, [pc, #148] ; 37d68 <rtems_rfs_inode_create+0x25c><== NOT EXECUTED
37cd0: e1530001 cmp r3, r1 <== NOT EXECUTED
37cd4: 03a03000 moveq r3, #0 <== NOT EXECUTED
rtems_rfs_inode_set_links (&parent_inode,
37cd8: e2833001 add r3, r3, #1 <== NOT EXECUTED
37cdc: e1a03803 lsl r3, r3, #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);
37ce0: e1a01c23 lsr r1, r3, #24 <== NOT EXECUTED
37ce4: e5c21000 strb r1, [r2] <== NOT EXECUTED
37ce8: e59d2048 ldr r2, [sp, #72] ; 0x48 <== NOT EXECUTED
37cec: e1a03823 lsr r3, r3, #16 <== NOT EXECUTED
37cf0: e5c23001 strb r3, [r2, #1] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
37cf4: e3a03001 mov r3, #1 <== NOT EXECUTED
37cf8: e5cd304c strb r3, [sp, #76] ; 0x4c <== NOT EXECUTED
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
37cfc: e1a00004 mov r0, r4 <== NOT EXECUTED
37d00: e28d103c add r1, sp, #60 ; 0x3c <== NOT EXECUTED
37d04: ebfffefb bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
37d08: e2509000 subs r9, r0, #0 <== NOT EXECUTED
37d0c: e28d6014 add r6, sp, #20 <== NOT EXECUTED
37d10: da000006 ble 37d30 <rtems_rfs_inode_create+0x224> <== NOT EXECUTED
{
rtems_rfs_inode_delete (fs, &inode);
37d14: e1a01006 mov r1, r6 <== NOT EXECUTED
37d18: e1a00004 mov r0, r4 <== NOT EXECUTED
37d1c: ebffff4b bl 37a50 <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
37d20: e1a00004 mov r0, r4 <== NOT EXECUTED
37d24: e1a01006 mov r1, r6 <== NOT EXECUTED
37d28: ebfffef2 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
37d2c: ea000008 b 37d54 <rtems_rfs_inode_create+0x248> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
37d30: e1a01006 mov r1, r6 <== NOT EXECUTED
37d34: e1a00004 mov r0, r4 <== NOT EXECUTED
37d38: ebfffeee bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
37d3c: e2509000 subs r9, r0, #0 <== NOT EXECUTED
37d40: d3a09000 movle r9, #0 <== NOT EXECUTED
37d44: da000002 ble 37d54 <rtems_rfs_inode_create+0x248> <== NOT EXECUTED
{
rtems_rfs_inode_free (fs, *ino);
37d48: e1a00004 mov r0, r4 <== NOT EXECUTED
37d4c: e5951000 ldr r1, [r5] <== NOT EXECUTED
37d50: ebffff3b bl 37a44 <rtems_rfs_inode_free> <== NOT EXECUTED
return rc;
}
return 0;
}
37d54: e1a00009 mov r0, r9 <== NOT EXECUTED
37d58: e28dd064 add sp, sp, #100 ; 0x64 <== NOT EXECUTED
37d5c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00037a50 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
37a50: 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))
37a54: e591300c ldr r3, [r1, #12] <== NOT EXECUTED
37a58: e3530000 cmp r3, #0 <== NOT EXECUTED
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
37a5c: e1a05000 mov r5, r0 <== NOT EXECUTED
37a60: e24dd050 sub sp, sp, #80 ; 0x50 <== NOT EXECUTED
37a64: 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))
37a68: 01a00003 moveq r0, r3 <== NOT EXECUTED
37a6c: 0a00001c beq 37ae4 <rtems_rfs_inode_delete+0x94> <== NOT EXECUTED
rtems_rfs_block_map map;
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
37a70: e5911008 ldr r1, [r1, #8] <== NOT EXECUTED
37a74: ebfffff2 bl 37a44 <rtems_rfs_inode_free> <== NOT EXECUTED
if (rc > 0)
37a78: e3500000 cmp r0, #0 <== NOT EXECUTED
37a7c: ca000018 bgt 37ae4 <rtems_rfs_inode_delete+0x94> <== NOT EXECUTED
return rc;
/*
* Free the blocks the inode may have attached.
*/
rc = rtems_rfs_block_map_open (fs, handle, &map);
37a80: e1a00005 mov r0, r5 <== NOT EXECUTED
37a84: e1a01004 mov r1, r4 <== NOT EXECUTED
37a88: e1a0200d mov r2, sp <== NOT EXECUTED
37a8c: ebfff203 bl 342a0 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc == 0)
37a90: 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);
37a94: e1a0600d mov r6, sp <== NOT EXECUTED
if (rc == 0)
37a98: 1a000011 bne 37ae4 <rtems_rfs_inode_delete+0x94> <== NOT EXECUTED
{
int rrc;
rrc = rtems_rfs_block_map_free_all (fs, &map);
37a9c: e1a0100d mov r1, sp <== NOT EXECUTED
37aa0: e1a00005 mov r0, r5 <== NOT EXECUTED
37aa4: ebfff057 bl 33c08 <rtems_rfs_block_map_free_all> <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &map);
37aa8: e1a0100d mov r1, sp <== NOT EXECUTED
37aac: e1a00005 mov r0, r5 <== NOT EXECUTED
37ab0: ebfff188 bl 340d8 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
37ab4: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED
37ab8: e3a02038 mov r2, #56 ; 0x38 <== NOT EXECUTED
37abc: e594000c ldr r0, [r4, #12] <== NOT EXECUTED
37ac0: eb002245 bl 403dc <memset> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
37ac4: e3a03001 mov r3, #1 <== NOT EXECUTED
37ac8: e1a01004 mov r1, r4 <== NOT EXECUTED
37acc: 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);
37ad0: e1a00005 mov r0, r5 <== NOT EXECUTED
37ad4: ebfff2b8 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->loads = 0;
37ad8: e3a03000 mov r3, #0 <== NOT EXECUTED
handle->node = NULL;
37adc: 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;
37ae0: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
handle->node = NULL;
}
}
return rc;
}
37ae4: e28dd050 add sp, sp, #80 ; 0x50 <== NOT EXECUTED
37ae8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00037a44 <rtems_rfs_inode_free>:
}
int
rtems_rfs_inode_free (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
37a44: e1a02001 mov r2, r1 <== NOT EXECUTED
rtems_rfs_bitmap_bit bit;
bit = ino;
return rtems_rfs_group_bitmap_free (fs, true, bit);
37a48: e3a01001 mov r1, #1 <== NOT EXECUTED
37a4c: eafffe07 b 37270 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
000375ec <rtems_rfs_inode_get_size>:
}
rtems_rfs_pos
rtems_rfs_inode_get_size (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
375ec: e92d4003 push {r0, r1, lr} <== 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);
375f0: e591200c ldr r2, [r1, #12] <== NOT EXECUTED
375f4: e282300c add r3, r2, #12 <== NOT EXECUTED
rtems_rfs_block_size size;
size.count = rtems_rfs_inode_get_block_count (handle);
375f8: e5d31003 ldrb r1, [r3, #3] <== NOT EXECUTED
375fc: e5d2c00c ldrb ip, [r2, #12] <== NOT EXECUTED
37600: e5d3e001 ldrb lr, [r3, #1] <== NOT EXECUTED
37604: e181cc0c orr ip, r1, ip, lsl #24 <== NOT EXECUTED
37608: e5d31002 ldrb r1, [r3, #2] <== NOT EXECUTED
3760c: e18c380e orr r3, ip, lr, lsl #16 <== NOT EXECUTED
37610: e1833401 orr r3, r3, r1, lsl #8 <== NOT EXECUTED
37614: e58d3000 str r3, [sp] <== NOT EXECUTED
size.offset = rtems_rfs_inode_get_block_offset (handle);
37618: e5d2300b ldrb r3, [r2, #11] <== NOT EXECUTED
3761c: e5d2200a ldrb r2, [r2, #10] <== NOT EXECUTED
return rtems_rfs_block_get_size (fs, &size);
37620: 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);
37624: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
37628: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
return rtems_rfs_block_get_size (fs, &size);
3762c: ebffeff2 bl 335fc <rtems_rfs_block_get_size> <== NOT EXECUTED
}
37630: e8bd800c pop {r2, r3, pc} <== NOT EXECUTED
000376e0 <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)
{
376e0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
376e4: 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);
376e8: e590400c ldr r4, [r0, #12] <== NOT EXECUTED
376ec: e1a05c21 lsr r5, r1, #24 <== NOT EXECUTED
376f0: e1a0c000 mov ip, r0 <== NOT EXECUTED
376f4: e1dd00bc ldrh r0, [sp, #12] <== NOT EXECUTED
376f8: e5c45000 strb r5, [r4] <== NOT EXECUTED
376fc: e59c400c ldr r4, [ip, #12] <== NOT EXECUTED
37700: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED
37704: 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);
37708: e59c400c ldr r4, [ip, #12] <== NOT EXECUTED
3770c: e3a01000 mov r1, #0 <== NOT EXECUTED
37710: e5c41008 strb r1, [r4, #8] <== NOT EXECUTED
37714: e59c400c ldr r4, [ip, #12] <== NOT EXECUTED
37718: e5c41009 strb r1, [r4, #9] <== NOT EXECUTED
3771c: 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);
37720: e59c400c ldr r4, [ip, #12] <== NOT EXECUTED
37724: e1a05c22 lsr r5, r2, #24 <== NOT EXECUTED
37728: e5c45002 strb r5, [r4, #2] <== NOT EXECUTED
3772c: e59c400c ldr r4, [ip, #12] <== NOT EXECUTED
37730: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED
37734: e5c42003 strb r2, [r4, #3] <== NOT EXECUTED
37738: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED
3773c: 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);
37740: e59c200c ldr r2, [ip, #12] <== NOT EXECUTED
37744: e1830800 orr r0, r3, r0, lsl #16 <== NOT EXECUTED
37748: e1a04c20 lsr r4, r0, #24 <== NOT EXECUTED
3774c: e5c24004 strb r4, [r2, #4] <== NOT EXECUTED
37750: e59c200c ldr r2, [ip, #12] <== NOT EXECUTED
37754: e1a04820 lsr r4, r0, #16 <== NOT EXECUTED
37758: e5c24005 strb r4, [r2, #5] <== NOT EXECUTED
3775c: e59c200c ldr r2, [ip, #12] <== NOT EXECUTED
37760: e1a00420 lsr r0, r0, #8 <== NOT EXECUTED
37764: e5c20006 strb r0, [r2, #6] <== NOT EXECUTED
37768: e59c200c ldr r2, [ip, #12] <== NOT EXECUTED
3776c: 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);
37770: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED
37774: e5c3100a strb r1, [r3, #10] <== NOT EXECUTED
37778: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED
3777c: 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);
37780: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED
37784: e5c3100c strb r1, [r3, #12] <== NOT EXECUTED
37788: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED
3778c: e5c3100d strb r1, [r3, #13] <== NOT EXECUTED
37790: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED
37794: e5c3100e strb r1, [r3, #14] <== NOT EXECUTED
37798: e59c200c ldr r2, [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);
3779c: e3a03001 mov r3, #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);
377a0: e5c2100f strb r1, [r2, #15] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
377a4: e5cc3010 strb r3, [ip, #16] <== 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);
377a8: e1a04003 mov r4, r3 <== 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);
377ac: e1a00001 mov r0, r1 <== NOT EXECUTED
377b0: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED
377b4: e0833001 add r3, r3, r1 <== NOT EXECUTED
377b8: e5c3001c strb r0, [r3, #28] <== NOT EXECUTED
377bc: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED
377c0: e3a02000 mov r2, #0 <== NOT EXECUTED
377c4: e0833001 add r3, r3, r1 <== NOT EXECUTED
377c8: e5c3201d strb r2, [r3, #29] <== NOT EXECUTED
377cc: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED
377d0: e0833001 add r3, r3, r1 <== NOT EXECUTED
377d4: e5c3001e strb r0, [r3, #30] <== NOT EXECUTED
377d8: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED
377dc: e0833001 add r3, r3, r1 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
377e0: 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++)
377e4: 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);
377e8: e5c3001f strb r0, [r3, #31] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
377ec: e5cc4010 strb r4, [ip, #16] <== NOT EXECUTED
377f0: e3a03001 mov r3, #1 <== NOT EXECUTED
377f4: 1affffed bne 377b0 <rtems_rfs_inode_initialise+0xd0> <== 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);
377f8: e59c100c ldr r1, [ip, #12] <== NOT EXECUTED
377fc: e5c12030 strb r2, [r1, #48] ; 0x30 <== NOT EXECUTED
37800: e59c100c ldr r1, [ip, #12] <== NOT EXECUTED
37804: e5c12031 strb r2, [r1, #49] ; 0x31 <== NOT EXECUTED
37808: e59c100c ldr r1, [ip, #12] <== NOT EXECUTED
3780c: e5c12032 strb r2, [r1, #50] ; 0x32 <== NOT EXECUTED
37810: e59c100c ldr r1, [ip, #12] <== NOT EXECUTED
37814: 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);
37818: e59c100c ldr r1, [ip, #12] <== NOT EXECUTED
3781c: e5c12034 strb r2, [r1, #52] ; 0x34 <== NOT EXECUTED
37820: e59c100c ldr r1, [ip, #12] <== NOT EXECUTED
37824: e5c12035 strb r2, [r1, #53] ; 0x35 <== NOT EXECUTED
37828: e59c100c ldr r1, [ip, #12] <== NOT EXECUTED
3782c: e5c12036 strb r2, [r1, #54] ; 0x36 <== NOT EXECUTED
37830: 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);
37834: e1a01003 mov r1, r3 <== NOT EXECUTED
37838: e5c02037 strb r2, [r0, #55] ; 0x37 <== NOT EXECUTED
3783c: e1a0000c mov r0, ip <== NOT EXECUTED
37840: e1a02003 mov r2, r3 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
37844: e5cc3010 strb r3, [ip, #16] <== NOT EXECUTED
}
37848: e8bd4030 pop {r4, r5, lr} <== 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);
3784c: eaffff78 b 37634 <rtems_rfs_inode_time_stamp_now> <== NOT EXECUTED
0003792c <rtems_rfs_inode_load>:
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
3792c: e591300c ldr r3, [r1, #12] <== NOT EXECUTED
37930: e3530000 cmp r3, #0 <== NOT EXECUTED
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
37934: e92d4010 push {r4, lr} <== NOT EXECUTED
37938: 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))
3793c: 1a00000b bne 37970 <rtems_rfs_inode_load+0x44> <== NOT EXECUTED
{
int rc;
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
37940: e2811010 add r1, r1, #16 <== NOT EXECUTED
37944: e594201c ldr r2, [r4, #28] <== NOT EXECUTED
37948: e2833001 add r3, r3, #1 <== NOT EXECUTED
3794c: ebfff363 bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
handle->block, true);
if (rc > 0)
37950: e3500000 cmp r0, #0 <== NOT EXECUTED
37954: c8bd8010 popgt {r4, pc} <== NOT EXECUTED
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
37958: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED
handle->node += handle->offset;
3795c: e5941020 ldr r1, [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);
37960: e5932020 ldr r2, [r3, #32] <== NOT EXECUTED
handle->node += handle->offset;
37964: e3a00038 mov r0, #56 ; 0x38 <== NOT EXECUTED
37968: e0232190 mla r3, r0, r1, r2 <== NOT EXECUTED
3796c: e584300c str r3, [r4, #12] <== NOT EXECUTED
}
handle->loads++;
37970: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED
37974: e2833001 add r3, r3, #1 <== NOT EXECUTED
37978: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
3797c: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
}
37980: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00037984 <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)
37984: 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)
{
37988: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3798c: e1a04000 mov r4, r0 <== NOT EXECUTED
37990: e1a05002 mov r5, r2 <== NOT EXECUTED
37994: 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)
37998: 0a000027 beq 37a3c <rtems_rfs_inode_open+0xb8> <== NOT EXECUTED
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
3799c: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
379a0: e2417001 sub r7, r1, #1 <== NOT EXECUTED
379a4: e1570003 cmp r7, r3 <== NOT EXECUTED
379a8: 8a000023 bhi 37a3c <rtems_rfs_inode_open+0xb8> <== NOT EXECUTED
return EINVAL;
handle->ino = ino;
379ac: e5821008 str r1, [r2, #8] <== NOT EXECUTED
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
379b0: 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;
379b4: e3a06000 mov r6, #0 <== NOT EXECUTED
379b8: e582600c str r6, [r2, #12] <== NOT EXECUTED
handle->loads = 0;
379bc: e5826024 str r6, [r2, #36] ; 0x24 <== NOT EXECUTED
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
379c0: e1a01009 mov r1, r9 <== NOT EXECUTED
379c4: e1a00007 mov r0, r7 <== NOT EXECUTED
379c8: eb00759e bl 55048 <__umodsi3> <== NOT EXECUTED
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
379cc: e594a02c ldr sl, [r4, #44] ; 0x2c <== NOT EXECUTED
handle->offset = gino % fs->inodes_per_block;
379d0: 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;
379d4: e1a0b000 mov fp, r0 <== NOT EXECUTED
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
379d8: eb00759a bl 55048 <__umodsi3> <== NOT EXECUTED
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
379dc: 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;
379e0: e5850020 str r0, [r5, #32] <== NOT EXECUTED
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
379e4: e1a00007 mov r0, r7 <== NOT EXECUTED
379e8: eb007502 bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
379ec: e3a03050 mov r3, #80 ; 0x50 <== NOT EXECUTED
379f0: e0000093 mul r0, r3, r0 <== NOT EXECUTED
379f4: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
379f8: e1a0100a mov r1, sl <== NOT EXECUTED
379fc: e7937000 ldr r7, [r3, r0] <== NOT EXECUTED
37a00: e1a0000b mov r0, fp <== NOT EXECUTED
37a04: eb0074fb bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
37a08: e2877002 add r7, r7, #2 <== NOT EXECUTED
37a0c: e0870000 add r0, r7, r0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
37a10: 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);
37a14: 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;
37a18: 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;
37a1c: e5c56010 strb r6, [r5, #16] <== NOT EXECUTED
handle->bnum = 0;
37a20: e5856014 str r6, [r5, #20] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
37a24: 01a00008 moveq r0, r8 <== NOT EXECUTED
37a28: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
rc = rtems_rfs_inode_load (fs, handle);
37a2c: e1a00004 mov r0, r4 <== NOT EXECUTED
37a30: e1a01005 mov r1, r5 <== NOT EXECUTED
return rc;
}
37a34: 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);
37a38: eaffffbb b 3792c <rtems_rfs_inode_load> <== NOT EXECUTED
37a3c: e3a00016 mov r0, #22 <== NOT EXECUTED
return rc;
}
37a40: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00036480 <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,
36480: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
36484: e3a02038 mov r2, #56 ; 0x38 <== NOT EXECUTED
/**
* Return the inode overhead given a number of inodes.
*/
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
36488: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3648c: e1a04000 mov r4, r0 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
36490: e0100392 muls r0, r2, r3 <== 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,
36494: e5945008 ldr r5, [r4, #8] <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
36498: 03a00001 moveq r0, #1 <== NOT EXECUTED
3649c: 0a000003 beq 364b0 <rtems_rfs_inode_overhead+0x30> <== NOT EXECUTED
return 1;
return ((dividend - 1) / divisor) + 1;
364a0: e2400001 sub r0, r0, #1 <== NOT EXECUTED
364a4: e1a01005 mov r1, r5 <== NOT EXECUTED
364a8: eb007a52 bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
364ac: e2800001 add r0, r0, #1 <== 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))
364b0: 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));
364b4: 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))
364b8: e2433001 sub r3, r3, #1 <== NOT EXECUTED
bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
364bc: e1510003 cmp r1, r3 <== NOT EXECUTED
364c0: 21a01003 movcs r1, r3 <== NOT EXECUTED
364c4: e2800001 add r0, r0, #1 <== NOT EXECUTED
364c8: e3a03ffa mov r3, #1000 ; 0x3e8 <== NOT EXECUTED
364cc: e0000093 mul r0, r3, r0 <== NOT EXECUTED
364d0: eb007a8c bl 54f08 <__aeabi_idiv> <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block;
}
364d4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00037634 <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))
37634: e590300c ldr r3, [r0, #12] <== NOT EXECUTED
37638: e3530000 cmp r3, #0 <== NOT EXECUTED
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
3763c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
37640: e1a04000 mov r4, r0 <== NOT EXECUTED
37644: e20160ff and r6, r1, #255 ; 0xff <== NOT EXECUTED
37648: e20250ff and r5, r2, #255 ; 0xff <== NOT EXECUTED
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
3764c: 03a00006 moveq r0, #6 <== NOT EXECUTED
37650: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return ENXIO;
now = time (NULL);
37654: e3a00000 mov r0, #0 <== NOT EXECUTED
37658: eb00459a bl 48cc8 <time> <== NOT EXECUTED
if (atime)
3765c: e3560000 cmp r6, #0 <== NOT EXECUTED
37660: 0a00000c beq 37698 <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);
37664: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
37668: e1a02c20 lsr r2, r0, #24 <== NOT EXECUTED
3766c: e5c32010 strb r2, [r3, #16] <== NOT EXECUTED
37670: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
37674: e1a02820 lsr r2, r0, #16 <== NOT EXECUTED
37678: e5c32011 strb r2, [r3, #17] <== NOT EXECUTED
3767c: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
37680: e1a02420 lsr r2, r0, #8 <== NOT EXECUTED
37684: e5c32012 strb r2, [r3, #18] <== NOT EXECUTED
37688: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
3768c: e5c30013 strb r0, [r3, #19] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
37690: e3a03001 mov r3, #1 <== NOT EXECUTED
37694: e5c43010 strb r3, [r4, #16] <== NOT EXECUTED
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
37698: e3550000 cmp r5, #0 <== NOT EXECUTED
3769c: 01a00005 moveq r0, r5 <== NOT EXECUTED
376a0: 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);
376a4: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
376a8: e1a02c20 lsr r2, r0, #24 <== NOT EXECUTED
376ac: e5c32014 strb r2, [r3, #20] <== NOT EXECUTED
376b0: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
376b4: e1a02820 lsr r2, r0, #16 <== NOT EXECUTED
376b8: e5c32015 strb r2, [r3, #21] <== NOT EXECUTED
376bc: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
376c0: e1a02420 lsr r2, r0, #8 <== NOT EXECUTED
376c4: e5c32016 strb r2, [r3, #22] <== NOT EXECUTED
376c8: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
376cc: e5c30017 strb r0, [r3, #23] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
376d0: e3a03001 mov r3, #1 <== NOT EXECUTED
376d4: e5c43010 strb r3, [r4, #16] <== NOT EXECUTED
376d8: e3a00000 mov r0, #0 <== NOT EXECUTED
rtems_rfs_inode_set_mtime (handle, now);
return 0;
}
376dc: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00037850 <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))
37850: e591300c ldr r3, [r1, #12] <== NOT EXECUTED
37854: e3530000 cmp r3, #0 <== NOT EXECUTED
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
37858: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3785c: e20220ff and r2, r2, #255 ; 0xff <== NOT EXECUTED
37860: e1a04001 mov r4, r1 <== NOT EXECUTED
37864: 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))
37868: 0a000020 beq 378f0 <rtems_rfs_inode_unload+0xa0> <== NOT EXECUTED
{
if (handle->loads == 0)
3786c: e5910024 ldr r0, [r1, #36] ; 0x24 <== NOT EXECUTED
37870: e3500000 cmp r0, #0 <== NOT EXECUTED
37874: 02800005 addeq r0, r0, #5 <== NOT EXECUTED
37878: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
return EIO;
handle->loads--;
3787c: e2400001 sub r0, r0, #1 <== NOT EXECUTED
if (handle->loads == 0)
37880: e3500000 cmp r0, #0 <== NOT EXECUTED
if (rtems_rfs_inode_is_loaded (handle))
{
if (handle->loads == 0)
return EIO;
handle->loads--;
37884: e5810024 str r0, [r1, #36] ; 0x24 <== NOT EXECUTED
if (handle->loads == 0)
37888: 1a000018 bne 378f0 <rtems_rfs_inode_unload+0xa0> <== NOT EXECUTED
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
3788c: e5d13010 ldrb r3, [r1, #16] <== NOT EXECUTED
37890: e3530000 cmp r3, #0 <== NOT EXECUTED
37894: 0a00000f beq 378d8 <rtems_rfs_inode_unload+0x88> <== NOT EXECUTED
37898: e3520000 cmp r2, #0 <== NOT EXECUTED
3789c: 0a00000d beq 378d8 <rtems_rfs_inode_unload+0x88> <== NOT EXECUTED
rtems_rfs_inode_set_ctime (handle, time (NULL));
378a0: eb004508 bl 48cc8 <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);
378a4: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
378a8: e1a02c20 lsr r2, r0, #24 <== NOT EXECUTED
378ac: e5c32018 strb r2, [r3, #24] <== NOT EXECUTED
378b0: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
378b4: e1a02820 lsr r2, r0, #16 <== NOT EXECUTED
378b8: e5c32019 strb r2, [r3, #25] <== NOT EXECUTED
378bc: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
378c0: e1a02420 lsr r2, r0, #8 <== NOT EXECUTED
378c4: e5c3201a strb r2, [r3, #26] <== NOT EXECUTED
378c8: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
378cc: e5c3001b strb r0, [r3, #27] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
378d0: e3a03001 mov r3, #1 <== NOT EXECUTED
378d4: e5c43010 strb r3, [r4, #16] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
378d8: e1a00005 mov r0, r5 <== NOT EXECUTED
378dc: e2841010 add r1, r4, #16 <== NOT EXECUTED
378e0: ebfff335 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->node = NULL;
378e4: e3a03000 mov r3, #0 <== NOT EXECUTED
378e8: e584300c str r3, [r4, #12] <== NOT EXECUTED
378ec: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
378f0: e3a00000 mov r0, #0 <== NOT EXECUTED
}
}
return rc;
}
378f4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00038314 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
38314: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
38318: e24dd054 sub sp, sp, #84 ; 0x54 <== NOT EXECUTED
3831c: 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);
38320: e28d5004 add r5, sp, #4 <== NOT EXECUTED
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
38324: e1a08001 mov r8, r1 <== NOT EXECUTED
38328: e1a0a002 mov sl, r2 <== NOT EXECUTED
3832c: e1a06003 mov r6, 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);
38330: e1a0100b mov r1, fp <== NOT EXECUTED
38334: e1a02005 mov r2, r5 <== NOT EXECUTED
38338: e3a03001 mov r3, #1 <== NOT EXECUTED
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
3833c: e1a04000 mov r4, r0 <== NOT EXECUTED
38340: e5dd707c ldrb r7, [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);
38344: ebfffd8e bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
38348: e2509000 subs r9, r0, #0 <== NOT EXECUTED
3834c: 1a000043 bne 38460 <rtems_rfs_link+0x14c> <== 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)))
38350: e3570000 cmp r7, #0 <== NOT EXECUTED
38354: 1a00000a bne 38384 <rtems_rfs_link+0x70> <== 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);
38358: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
3835c: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED
38360: e1a03403 lsl r3, r3, #8 <== NOT EXECUTED
38364: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
38368: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED
3836c: 1a000004 bne 38384 <rtems_rfs_link+0x70> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &target_inode);
38370: e1a00004 mov r0, r4 <== NOT EXECUTED
38374: e1a01005 mov r1, r5 <== NOT EXECUTED
38378: ebfffd5e bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
3837c: e3a09086 mov r9, #134 ; 0x86 <== NOT EXECUTED
return ENOTSUP;
38380: ea000036 b 38460 <rtems_rfs_link+0x14c> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
38384: e28d502c add r5, sp, #44 ; 0x2c <== NOT EXECUTED
38388: e1a01006 mov r1, r6 <== NOT EXECUTED
3838c: e1a00004 mov r0, r4 <== NOT EXECUTED
38390: e1a02005 mov r2, r5 <== NOT EXECUTED
38394: e3a03001 mov r3, #1 <== NOT EXECUTED
38398: ebfffd79 bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
3839c: e2509000 subs r9, r0, #0 <== NOT EXECUTED
383a0: 1a00000a bne 383d0 <rtems_rfs_link+0xbc> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
383a4: e1a02008 mov r2, r8 <== NOT EXECUTED
383a8: e1a0300a mov r3, sl <== NOT EXECUTED
383ac: e1a00004 mov r0, r4 <== NOT EXECUTED
383b0: e1a01005 mov r1, r5 <== NOT EXECUTED
383b4: e58db000 str fp, [sp] <== NOT EXECUTED
383b8: ebfff2f9 bl 34fa4 <rtems_rfs_dir_add_entry> <== NOT EXECUTED
if (rc > 0)
383bc: e2509000 subs r9, r0, #0 <== NOT EXECUTED
383c0: da000006 ble 383e0 <rtems_rfs_link+0xcc> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &parent_inode);
383c4: e1a01005 mov r1, r5 <== NOT EXECUTED
383c8: e1a00004 mov r0, r4 <== NOT EXECUTED
383cc: ebfffd49 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
383d0: e1a00004 mov r0, r4 <== NOT EXECUTED
383d4: e28d1004 add r1, sp, #4 <== NOT EXECUTED
383d8: ebfffd46 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
383dc: ea00001f b 38460 <rtems_rfs_link+0x14c> <== 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);
383e0: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
383e4: e5d31000 ldrb r1, [r3] <== NOT EXECUTED
383e8: e5d32001 ldrb r2, [r3, #1] <== NOT EXECUTED
383ec: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED
if (links == 0xffff)
383f0: e59f1074 ldr r1, [pc, #116] ; 3846c <rtems_rfs_link+0x158> <== NOT EXECUTED
383f4: e1520001 cmp r2, r1 <== NOT EXECUTED
383f8: 03a02000 moveq r2, #0 <== NOT EXECUTED
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
383fc: e2822001 add r2, r2, #1 <== NOT EXECUTED
38400: e1a02802 lsl r2, r2, #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);
38404: e1a01c22 lsr r1, r2, #24 <== NOT EXECUTED
38408: e5c31000 strb r1, [r3] <== NOT EXECUTED
3840c: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
38410: e3a03001 mov r3, #1 <== NOT EXECUTED
38414: e1a02822 lsr r2, r2, #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);
38418: e5c02001 strb r2, [r0, #1] <== NOT EXECUTED
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
3841c: e1a01003 mov r1, r3 <== NOT EXECUTED
38420: e1a00005 mov r0, r5 <== NOT EXECUTED
38424: e1a02003 mov r2, r3 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
38428: e5cd3014 strb r3, [sp, #20] <== NOT EXECUTED
3842c: ebfffc80 bl 37634 <rtems_rfs_inode_time_stamp_now> <== NOT EXECUTED
if (rc > 0)
38430: e2509000 subs r9, r0, #0 <== NOT EXECUTED
38434: caffffe2 bgt 383c4 <rtems_rfs_link+0xb0> <== 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);
38438: e1a01005 mov r1, r5 <== NOT EXECUTED
3843c: e1a00004 mov r0, r4 <== NOT EXECUTED
38440: ebfffd2c bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
38444: e2509000 subs r9, r0, #0 <== NOT EXECUTED
38448: e28d1004 add r1, sp, #4 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &target_inode);
3844c: c1a00004 movgt r0, r4 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
if (rc > 0)
38450: caffffe0 bgt 383d8 <rtems_rfs_link+0xc4> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
38454: e1a00004 mov r0, r4 <== NOT EXECUTED
38458: ebfffd26 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
3845c: e1a09000 mov r9, r0 <== NOT EXECUTED
return rc;
}
38460: e1a00009 mov r0, r9 <== NOT EXECUTED
38464: e28dd054 add sp, sp, #84 ; 0x54 <== NOT EXECUTED
38468: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0003848c <rtems_rfs_mutex_create>:
RTEMS_NO_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
3848c: e92d4001 push {r0, lr} <== NOT EXECUTED
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
38490: e3a01001 mov r1, #1 <== NOT EXECUTED
38494: e58d0000 str r0, [sp] <== NOT EXECUTED
38498: e3a02024 mov r2, #36 ; 0x24 <== NOT EXECUTED
3849c: e3a03000 mov r3, #0 <== NOT EXECUTED
384a0: e59f0010 ldr r0, [pc, #16] ; 384b8 <rtems_rfs_mutex_create+0x2c><== NOT EXECUTED
384a4: ebff4c5c bl b61c <rtems_semaphore_create> <== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
384a8: e3500000 cmp r0, #0 <== NOT EXECUTED
384ac: 13a00005 movne r0, #5 <== NOT EXECUTED
384b0: 03a00000 moveq r0, #0 <== NOT EXECUTED
384b4: e8bd8008 pop {r3, pc} <== NOT EXECUTED
00038470 <rtems_rfs_mutex_destroy>:
return 0;
}
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
38470: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
38474: e5900000 ldr r0, [r0] <== NOT EXECUTED
38478: ebff4cd2 bl b7c8 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
3847c: e3500000 cmp r0, #0 <== NOT EXECUTED
38480: 13a00005 movne r0, #5 <== NOT EXECUTED
38484: 03a00000 moveq r0, #0 <== NOT EXECUTED
38488: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00034408 <rtems_rfs_release_chain>:
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
34408: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
3440c: e3a05000 mov r5, #0 <== NOT EXECUTED
34410: e1a04000 mov r4, r0 <== NOT EXECUTED
34414: e1a06001 mov r6, r1 <== NOT EXECUTED
34418: e202a0ff and sl, r2, #255 ; 0xff <== NOT EXECUTED
3441c: e2808004 add r8, r0, #4 <== NOT EXECUTED
while (!rtems_chain_is_empty (chain))
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
buffer->user = (void*) 0;
34420: e1a07005 mov r7, 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))
34424: ea00000d b 34460 <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 );
34428: ebff600d bl c464 <_Chain_Get> <== NOT EXECUTED
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
3442c: e5962000 ldr r2, [r6] <== NOT EXECUTED
34430: e2422001 sub r2, r2, #1 <== NOT EXECUTED
34434: e5862000 str r2, [r6] <== NOT EXECUTED
buffer->user = (void*) 0;
34438: e5807038 str r7, [r0, #56] ; 0x38 <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (buffer, modified);
3443c: e1a0100a mov r1, sl <== NOT EXECUTED
34440: eb002145 bl 3c95c <rtems_rfs_buffer_bdbuf_release> <== NOT EXECUTED
if ((rc > 0) && (rrc == 0))
34444: e3500000 cmp r0, #0 <== NOT EXECUTED
34448: d3a03000 movle r3, #0 <== NOT EXECUTED
3444c: c3a03001 movgt r3, #1 <== NOT EXECUTED
34450: e3550000 cmp r5, #0 <== NOT EXECUTED
34454: 13a03000 movne r3, #0 <== NOT EXECUTED
34458: e3530000 cmp r3, #0 <== NOT EXECUTED
3445c: 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))
34460: e5943000 ldr r3, [r4] <== NOT EXECUTED
34464: e1530008 cmp r3, r8 <== NOT EXECUTED
34468: e1a00004 mov r0, r4 <== NOT EXECUTED
3446c: 1affffed bne 34428 <rtems_rfs_release_chain+0x20> <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
rrc = rc;
}
return rrc;
}
34470: e1a00005 mov r0, r5 <== NOT EXECUTED
34474: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
0001e10c <rtems_rfs_rtems_chown>:
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
1e10c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
1e110: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
1e114: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
1e118: e5908000 ldr r8, [r0] <== NOT EXECUTED
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
1e11c: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED
1e120: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED
1e124: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_CHOWN))
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rtems_rfs_rtems_lock (fs);
1e128: e1a00004 mov r0, r4 <== NOT EXECUTED
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
1e12c: e1a06821 lsr r6, r1, #16 <== NOT EXECUTED
1e130: e1a07822 lsr r7, r2, #16 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_CHOWN))
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rtems_rfs_rtems_lock (fs);
1e134: ebffffe9 bl 1e0e0 <rtems_rfs_rtems_lock> <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1e138: e1a01008 mov r1, r8 <== NOT EXECUTED
1e13c: e1a00004 mov r0, r4 <== NOT EXECUTED
1e140: e1a0200d mov r2, sp <== NOT EXECUTED
1e144: e3a03001 mov r3, #1 <== NOT EXECUTED
1e148: eb00660d bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
1e14c: e2508000 subs r8, r0, #0 <== 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);
1e150: e1a0500d mov r5, sp <== NOT EXECUTED
if (rc > 0)
1e154: da000004 ble 1e16c <rtems_rfs_rtems_chown+0x60> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1e158: e1a00004 mov r0, r4 <== NOT EXECUTED
1e15c: ebffffe4 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: opening inode", rc);
1e160: eb007b66 bl 3cf00 <__errno> <== NOT EXECUTED
1e164: e5808000 str r8, [r0] <== NOT EXECUTED
1e168: ea000016 b 1e1c8 <rtems_rfs_rtems_chown+0xbc> <== 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);
1e16c: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
1e170: e1867807 orr r7, r6, r7, lsl #16 <== NOT EXECUTED
1e174: e1a02c27 lsr r2, r7, #24 <== NOT EXECUTED
1e178: e5c32004 strb r2, [r3, #4] <== NOT EXECUTED
1e17c: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
1e180: e1a02827 lsr r2, r7, #16 <== NOT EXECUTED
1e184: e5c32005 strb r2, [r3, #5] <== NOT EXECUTED
1e188: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
1e18c: e1a07427 lsr r7, r7, #8 <== NOT EXECUTED
1e190: e5c37006 strb r7, [r3, #6] <== NOT EXECUTED
1e194: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
}
#endif
rtems_rfs_inode_set_uid_gid (&inode, owner, group);
rc = rtems_rfs_inode_close (fs, &inode);
1e198: e1a0100d mov r1, sp <== NOT EXECUTED
1e19c: e5c36007 strb r6, [r3, #7] <== NOT EXECUTED
1e1a0: e1a00004 mov r0, r4 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1e1a4: e3a03001 mov r3, #1 <== NOT EXECUTED
1e1a8: e5cd3010 strb r3, [sp, #16] <== NOT EXECUTED
1e1ac: eb0065d1 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc)
1e1b0: e2505000 subs r5, r0, #0 <== NOT EXECUTED
1e1b4: 0a000005 beq 1e1d0 <rtems_rfs_rtems_chown+0xc4> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1e1b8: e1a00004 mov r0, r4 <== NOT EXECUTED
1e1bc: ebffffcc bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: closing inode", rc);
1e1c0: eb007b4e bl 3cf00 <__errno> <== NOT EXECUTED
1e1c4: e5805000 str r5, [r0] <== NOT EXECUTED
1e1c8: e3e00000 mvn r0, #0 <== NOT EXECUTED
1e1cc: ea000002 b 1e1dc <rtems_rfs_rtems_chown+0xd0> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
1e1d0: e1a00004 mov r0, r4 <== NOT EXECUTED
1e1d4: ebffffc6 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
1e1d8: e1a00005 mov r0, r5 <== NOT EXECUTED
return 0;
}
1e1dc: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
1e1e0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
000385c0 <rtems_rfs_rtems_device_close>:
* @return int
*/
static int
rtems_rfs_rtems_device_close (rtems_libio_t* iop)
{
385c0: e92d4007 push {r0, r1, r2, lr} <== NOT EXECUTED
385c4: e1a03000 mov r3, r0 <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.flags = 0;
385c8: e3a0c000 mov ip, #0 <== NOT EXECUTED
rtems_libio_open_close_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
385cc: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
385d0: 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);
385d4: e1a0200d mov r2, sp <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
385d8: e58d3000 str r3, [sp] <== NOT EXECUTED
args.flags = 0;
args.mode = 0;
385dc: e58dc008 str ip, [sp, #8] <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.flags = 0;
385e0: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
args.mode = 0;
status = rtems_io_close (major, minor, (void *) &args);
385e4: eb0007cf bl 3a528 <rtems_io_close> <== NOT EXECUTED
if (status)
385e8: e2503000 subs r3, r0, #0 <== NOT EXECUTED
385ec: 01a00003 moveq r0, r3 <== NOT EXECUTED
return rtems_deviceio_errno (status);
385f0: 1b000251 blne 38f3c <rtems_deviceio_errno> <== NOT EXECUTED
return 0;
}
385f4: e8bd800e pop {r1, r2, r3, pc} <== NOT EXECUTED
000384c8 <rtems_rfs_rtems_device_ftruncate>:
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, rtems_off64_t length)
{
return 0;
}
384c8: e3a00000 mov r0, #0 <== NOT EXECUTED
384cc: e12fff1e bx lr <== NOT EXECUTED
000384d0 <rtems_rfs_rtems_device_ioctl>:
static int
rtems_rfs_rtems_device_ioctl (rtems_libio_t* iop,
uint32_t command,
void* buffer)
{
384d0: e92d400f push {r0, r1, r2, r3, lr} <== NOT EXECUTED
384d4: e1a03000 mov r3, r0 <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
384d8: e593c034 ldr ip, [r3, #52] ; 0x34 <== NOT EXECUTED
rtems_libio_ioctl_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
384dc: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
args.iop = iop;
args.command = command;
args.buffer = buffer;
384e0: e98d0006 stmib sp, {r1, r2} <== NOT EXECUTED
status = rtems_io_control (major, minor, (void *) &args);
384e4: e1a0200d mov r2, sp <== NOT EXECUTED
384e8: e1a0100c mov r1, ip <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
384ec: e58d3000 str r3, [sp] <== NOT EXECUTED
args.command = command;
args.buffer = buffer;
status = rtems_io_control (major, minor, (void *) &args);
384f0: eb000820 bl 3a578 <rtems_io_control> <== NOT EXECUTED
if (status)
384f4: e3500000 cmp r0, #0 <== NOT EXECUTED
return rtems_deviceio_errno (status);
return args.ioctl_return;
384f8: 059d000c ldreq r0, [sp, #12] <== NOT EXECUTED
args.command = command;
args.buffer = buffer;
status = rtems_io_control (major, minor, (void *) &args);
if (status)
return rtems_deviceio_errno (status);
384fc: 1b00028e blne 38f3c <rtems_deviceio_errno> <== NOT EXECUTED
return args.ioctl_return;
}
38500: e28dd010 add sp, sp, #16 <== NOT EXECUTED
38504: e8bd8000 pop {pc} <== NOT EXECUTED
000384bc <rtems_rfs_rtems_device_lseek>:
rtems_rfs_rtems_device_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
return offset;
}
384bc: e1a00001 mov r0, r1 <== NOT EXECUTED
384c0: e1a01002 mov r1, r2 <== NOT EXECUTED
384c4: e12fff1e bx lr <== NOT EXECUTED
00038610 <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)
{
38610: 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);
38614: e5902028 ldr r2, [r0, #40] ; 0x28 <== NOT EXECUTED
38618: e5925034 ldr r5, [r2, #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);
3861c: e595207c ldr r2, [r5, #124] ; 0x7c <== NOT EXECUTED
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode)
{
38620: e24dd040 sub sp, sp, #64 ; 0x40 <== NOT EXECUTED
rtems_libio_open_close_args_t args;
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
38624: e5907038 ldr r7, [r0, #56] ; 0x38 <== NOT EXECUTED
38628: e3a01000 mov r1, #0 <== NOT EXECUTED
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode)
{
3862c: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_status_code status;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
38630: e28d600c add r6, sp, #12 <== NOT EXECUTED
38634: e5920000 ldr r0, [r2] <== NOT EXECUTED
38638: 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)
{
3863c: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
38640: ebff4c9e bl b8c0 <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);
38644: e1a01007 mov r1, r7 <== NOT EXECUTED
38648: e1a00005 mov r0, r5 <== NOT EXECUTED
3864c: e1a02006 mov r2, r6 <== NOT EXECUTED
38650: e3a03001 mov r3, #1 <== NOT EXECUTED
38654: ebfffcca bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
38658: e2507000 subs r7, r0, #0 <== NOT EXECUTED
3865c: da000004 ble 38674 <rtems_rfs_rtems_device_open+0x64> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
38660: e1a00005 mov r0, r5 <== NOT EXECUTED
38664: ebffffe3 bl 385f8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
38668: eb001224 bl 3cf00 <__errno> <== NOT EXECUTED
3866c: e5807000 str r7, [r0] <== NOT EXECUTED
38670: ea000016 b 386d0 <rtems_rfs_rtems_device_open+0xc0> <== 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]);
38674: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
38678: e283201c add r2, r3, #28 <== NOT EXECUTED
3867c: e5d2c006 ldrb ip, [r2, #6] <== NOT EXECUTED
38680: e5d3a01c ldrb sl, [r3, #28] <== NOT EXECUTED
38684: e5d23002 ldrb r3, [r2, #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);
38688: e1a01006 mov r1, r6 <== NOT EXECUTED
3868c: e1a00005 mov r0, r5 <== NOT EXECUTED
38690: e5d26007 ldrb r6, [r2, #7] <== NOT EXECUTED
38694: e5d27001 ldrb r7, [r2, #1] <== NOT EXECUTED
38698: e5d28003 ldrb r8, [r2, #3] <== NOT EXECUTED
3869c: e5d29004 ldrb r9, [r2, #4] <== NOT EXECUTED
386a0: e5d2b005 ldrb fp, [r2, #5] <== NOT EXECUTED
386a4: e88d1008 stm sp, {r3, ip} <== NOT EXECUTED
386a8: ebfffc92 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
386ac: e2502000 subs r2, r0, #0 <== NOT EXECUTED
386b0: e89d1008 ldm sp, {r3, ip} <== NOT EXECUTED
386b4: da000007 ble 386d8 <rtems_rfs_rtems_device_open+0xc8> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
386b8: e1a00005 mov r0, r5 <== NOT EXECUTED
386bc: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
386c0: ebffffcc bl 385f8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
386c4: eb00120d bl 3cf00 <__errno> <== NOT EXECUTED
386c8: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED
386cc: e5802000 str r2, [r0] <== NOT EXECUTED
386d0: e3e00000 mvn r0, #0 <== NOT EXECUTED
386d4: ea000016 b 38734 <rtems_rfs_rtems_device_open+0x124> <== NOT EXECUTED
386d8: e1a0b80b lsl fp, fp, #16 <== NOT EXECUTED
386dc: e18b9c09 orr r9, fp, r9, lsl #24 <== NOT EXECUTED
386e0: e1888c0a orr r8, r8, sl, lsl #24 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
386e4: e1a00005 mov r0, r5 <== NOT EXECUTED
386e8: e1887807 orr r7, r8, r7, lsl #16 <== NOT EXECUTED
386ec: e1896006 orr r6, r9, r6 <== NOT EXECUTED
386f0: e1877403 orr r7, r7, r3, lsl #8 <== NOT EXECUTED
386f4: e186640c orr r6, r6, ip, lsl #8 <== NOT EXECUTED
386f8: ebffffbe bl 385f8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
args.flags = iop->flags;
386fc: e594e014 ldr lr, [r4, #20] <== NOT EXECUTED
args.mode = mode;
38700: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
38704: e5847030 str r7, [r4, #48] ; 0x30 <== NOT EXECUTED
iop->data1 = (void*)((intptr_t) minor);
38708: e5846034 str r6, [r4, #52] ; 0x34 <== NOT EXECUTED
args.iop = iop;
args.flags = iop->flags;
args.mode = mode;
status = rtems_io_open (major, minor, (void *) &args);
3870c: e1a00007 mov r0, r7 <== NOT EXECUTED
38710: e1a01006 mov r1, r6 <== NOT EXECUTED
38714: e28d2034 add r2, sp, #52 ; 0x34 <== NOT EXECUTED
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
args.flags = iop->flags;
args.mode = mode;
38718: e58d303c str r3, [sp, #60] ; 0x3c <== NOT EXECUTED
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
args.flags = iop->flags;
3871c: e58de038 str lr, [sp, #56] ; 0x38 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
38720: e58d4034 str r4, [sp, #52] ; 0x34 <== NOT EXECUTED
args.flags = iop->flags;
args.mode = mode;
status = rtems_io_open (major, minor, (void *) &args);
38724: eb0007a7 bl 3a5c8 <rtems_io_open> <== NOT EXECUTED
if (status)
38728: e2503000 subs r3, r0, #0 <== NOT EXECUTED
3872c: 01a00003 moveq r0, r3 <== NOT EXECUTED
return rtems_deviceio_errno(status);
38730: 1b000201 blne 38f3c <rtems_deviceio_errno> <== NOT EXECUTED
return 0;
}
38734: e28dd040 add sp, sp, #64 ; 0x40 <== NOT EXECUTED
38738: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00038564 <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)
{
38564: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
38568: e1a03000 mov r3, r0 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
3856c: e593c014 ldr ip, [r3, #20] <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
38570: 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)
{
38574: e24dd01c sub sp, sp, #28 <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
38578: e283500c add r5, r3, #12 <== NOT EXECUTED
3857c: 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;
38580: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
38584: e58d100c str r1, [sp, #12] <== NOT EXECUTED
args.count = count;
38588: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
args.flags = iop->flags;
3858c: e58dc014 str ip, [sp, #20] <== NOT EXECUTED
args.bytes_moved = 0;
status = rtems_io_read (major, minor, (void *) &args);
38590: 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;
38594: e3a0c000 mov ip, #0 <== NOT EXECUTED
status = rtems_io_read (major, minor, (void *) &args);
38598: e1a0200d mov r2, sp <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
3859c: e98d0030 stmib sp, {r4, r5} <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
385a0: e58dc018 str ip, [sp, #24] <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
385a4: 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);
385a8: eb00081a bl 3a618 <rtems_io_read> <== NOT EXECUTED
if (status)
385ac: e3500000 cmp r0, #0 <== NOT EXECUTED
return rtems_deviceio_errno (status);
return (ssize_t) args.bytes_moved;
385b0: 059d0018 ldreq r0, [sp, #24] <== 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);
385b4: 1b000260 blne 38f3c <rtems_deviceio_errno> <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
385b8: e28dd01c add sp, sp, #28 <== NOT EXECUTED
385bc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00038508 <rtems_rfs_rtems_device_write>:
static ssize_t
rtems_rfs_rtems_device_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
38508: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3850c: e1a03000 mov r3, r0 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
38510: e593c014 ldr ip, [r3, #20] <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
38514: 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)
{
38518: e24dd01c sub sp, sp, #28 <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
3851c: e283500c add r5, r3, #12 <== NOT EXECUTED
38520: 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;
38524: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
38528: e58d100c str r1, [sp, #12] <== NOT EXECUTED
args.count = count;
3852c: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
args.flags = iop->flags;
38530: e58dc014 str ip, [sp, #20] <== NOT EXECUTED
args.bytes_moved = 0;
status = rtems_io_write (major, minor, (void *) &args);
38534: 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;
38538: e3a0c000 mov ip, #0 <== NOT EXECUTED
status = rtems_io_write (major, minor, (void *) &args);
3853c: e1a0200d mov r2, sp <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
38540: e98d0030 stmib sp, {r4, r5} <== NOT EXECUTED
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
38544: e58dc018 str ip, [sp, #24] <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
38548: 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);
3854c: eb000845 bl 3a668 <rtems_io_write> <== NOT EXECUTED
if (status)
38550: e3500000 cmp r0, #0 <== NOT EXECUTED
return rtems_deviceio_errno (status);
return (ssize_t) args.bytes_moved;
38554: 059d0018 ldreq r0, [sp, #24] <== 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);
38558: 1b000277 blne 38f3c <rtems_deviceio_errno> <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
3855c: e28dd01c add sp, sp, #28 <== NOT EXECUTED
38560: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
0003873c <rtems_rfs_rtems_dir_close>:
{
/*
* The RFS does not hold any resources. Nothing to do.
*/
return 0;
}
3873c: e3a00000 mov r0, #0 <== NOT EXECUTED
38740: e12fff1e bx lr <== NOT EXECUTED
00038744 <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)
38744: 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)
{
38748: e92d4010 push {r4, lr} <== NOT EXECUTED
switch (whence)
3874c: 93a03000 movls r3, #0 <== NOT EXECUTED
38750: 93a04000 movls r4, #0 <== NOT EXECUTED
38754: 9a000004 bls 3876c <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);
38758: eb0011e8 bl 3cf00 <__errno> <== NOT EXECUTED
3875c: e3a03016 mov r3, #22 <== NOT EXECUTED
38760: e5803000 str r3, [r0] <== NOT EXECUTED
38764: e3e04000 mvn r4, #0 <== NOT EXECUTED
38768: e3e03000 mvn r3, #0 <== NOT EXECUTED
break;
}
return 0;
}
3876c: e1a01004 mov r1, r4 <== NOT EXECUTED
38770: e1a00003 mov r0, r3 <== NOT EXECUTED
38774: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00038934 <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);
38934: 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)
{
38938: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
3893c: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
38940: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
38944: e5907038 ldr r7, [r0, #56] ; 0x38 <== NOT EXECUTED
38948: 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)
{
3894c: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED
38950: e1a02001 mov r2, r1 <== NOT EXECUTED
38954: e1a06000 mov r6, r0 <== NOT EXECUTED
38958: e5930000 ldr r0, [r3] <== NOT EXECUTED
3895c: ebff4bd7 bl b8c0 <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);
38960: e1a01007 mov r1, r7 <== NOT EXECUTED
38964: e1a00004 mov r0, r4 <== NOT EXECUTED
38968: e1a0200d mov r2, sp <== NOT EXECUTED
3896c: e3a03001 mov r3, #1 <== NOT EXECUTED
38970: ebfffc03 bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
38974: 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);
38978: e1a0500d mov r5, sp <== NOT EXECUTED
if (rc)
3897c: 0a000004 beq 38994 <rtems_rfs_rtems_dir_open+0x60> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
38980: e1a00004 mov r0, r4 <== NOT EXECUTED
38984: ebffff7b bl 38778 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
38988: eb00115c bl 3cf00 <__errno> <== NOT EXECUTED
3898c: e5807000 str r7, [r0] <== NOT EXECUTED
38990: ea00000d b 389cc <rtems_rfs_rtems_dir_open+0x98> <== 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);
38994: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
38998: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED
3899c: e1a03403 lsl r3, r3, #8 <== NOT EXECUTED
389a0: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
389a4: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED
389a8: 0a000009 beq 389d4 <rtems_rfs_rtems_dir_open+0xa0> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
389ac: e1a0100d mov r1, sp <== NOT EXECUTED
389b0: e1a00004 mov r0, r4 <== NOT EXECUTED
389b4: ebfffbcf bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
389b8: e1a00004 mov r0, r4 <== NOT EXECUTED
389bc: ebffff6d bl 38778 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
389c0: eb00114e bl 3cf00 <__errno> <== NOT EXECUTED
389c4: e3a03014 mov r3, #20 <== NOT EXECUTED
389c8: e5803000 str r3, [r0] <== NOT EXECUTED
389cc: e3e00000 mvn r0, #0 <== NOT EXECUTED
389d0: ea000009 b 389fc <rtems_rfs_rtems_dir_open+0xc8> <== NOT EXECUTED
}
iop->offset = 0;
389d4: e3a02000 mov r2, #0 <== NOT EXECUTED
389d8: e3a03000 mov r3, #0 <== NOT EXECUTED
389dc: e586200c str r2, [r6, #12] <== NOT EXECUTED
389e0: e5863010 str r3, [r6, #16] <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
389e4: e1a0100d mov r1, sp <== NOT EXECUTED
389e8: e1a00004 mov r0, r4 <== NOT EXECUTED
389ec: ebfffbc1 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
389f0: e1a00004 mov r0, r4 <== NOT EXECUTED
389f4: ebffff5f bl 38778 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
389f8: e1a00007 mov r0, r7 <== NOT EXECUTED
return 0;
}
389fc: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
38a00: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00038820 <rtems_rfs_rtems_dir_read>:
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
38820: 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);
38824: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
38828: e24dd038 sub sp, sp, #56 ; 0x38 <== NOT EXECUTED
3882c: e1a06000 mov r6, r0 <== NOT EXECUTED
38830: e1a09001 mov r9, r1 <== NOT EXECUTED
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
38834: e1a00002 mov r0, r2 <== NOT EXECUTED
38838: e3a01e11 mov r1, #272 ; 0x110 <== NOT EXECUTED
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
3883c: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
38840: eb00716c bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
38844: e595307c ldr r3, [r5, #124] ; 0x7c <== NOT EXECUTED
38848: e3a01000 mov r1, #0 <== NOT EXECUTED
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
3884c: e5964038 ldr r4, [r6, #56] ; 0x38 <== NOT EXECUTED
38850: e1a02001 mov r2, r1 <== NOT EXECUTED
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
38854: e1a0b000 mov fp, r0 <== NOT EXECUTED
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
38858: e28d800c add r8, sp, #12 <== NOT EXECUTED
3885c: e5930000 ldr r0, [r3] <== NOT EXECUTED
38860: ebff4c16 bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
38864: e1a01004 mov r1, r4 <== NOT EXECUTED
38868: e1a00005 mov r0, r5 <== NOT EXECUTED
3886c: e1a02008 mov r2, r8 <== NOT EXECUTED
38870: e3a03001 mov r3, #1 <== NOT EXECUTED
38874: ebfffc42 bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
38878: e2504000 subs r4, r0, #0 <== NOT EXECUTED
3887c: 01a07004 moveq r7, r4 <== NOT EXECUTED
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
38880: 028da034 addeq sl, sp, #52 ; 0x34 <== NOT EXECUTED
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
38884: 0a00001d beq 38900 <rtems_rfs_rtems_dir_read+0xe0> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
38888: e1a00005 mov r0, r5 <== NOT EXECUTED
3888c: ebffffb9 bl 38778 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
38890: eb00119a bl 3cf00 <__errno> <== NOT EXECUTED
38894: e5804000 str r4, [r0] <== NOT EXECUTED
38898: e3e04000 mvn r4, #0 <== NOT EXECUTED
3889c: ea000021 b 38928 <rtems_rfs_rtems_dir_read+0x108> <== NOT EXECUTED
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
388a0: e286300c add r3, r6, #12 <== NOT EXECUTED
388a4: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
388a8: e58dc000 str ip, [sp] <== NOT EXECUTED
388ac: e58da004 str sl, [sp, #4] <== NOT EXECUTED
388b0: ebfff076 bl 34a90 <rtems_rfs_dir_read> <== NOT EXECUTED
if (rc == ENOENT)
388b4: e3500002 cmp r0, #2 <== NOT EXECUTED
388b8: 0a000015 beq 38914 <rtems_rfs_rtems_dir_read+0xf4> <== NOT EXECUTED
{
rc = 0;
break;
}
if (rc > 0)
388bc: e3500000 cmp r0, #0 <== NOT EXECUTED
388c0: da000005 ble 388dc <rtems_rfs_rtems_dir_read+0xbc> <== NOT EXECUTED
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
388c4: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
388c8: eb00118c bl 3cf00 <__errno> <== NOT EXECUTED
388cc: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
388d0: e3e04000 mvn r4, #0 <== NOT EXECUTED
388d4: e5803000 str r3, [r0] <== NOT EXECUTED
388d8: ea00000d b 38914 <rtems_rfs_rtems_dir_read+0xf4> <== NOT EXECUTED
break;
}
iop->offset += size;
388dc: e286100c add r1, r6, #12 <== NOT EXECUTED
388e0: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
388e4: e59dc034 ldr ip, [sp, #52] ; 0x34 <== NOT EXECUTED
388e8: e090200c adds r2, r0, ip <== NOT EXECUTED
388ec: e2a13000 adc r3, r1, #0 <== NOT EXECUTED
388f0: e586200c str r2, [r6, #12] <== NOT EXECUTED
388f4: e5863010 str r3, [r6, #16] <== NOT EXECUTED
388f8: 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++)
388fc: e2877001 add r7, r7, #1 <== NOT EXECUTED
38900: e157000b cmp r7, fp <== NOT EXECUTED
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
38904: e1a00005 mov r0, r5 <== NOT EXECUTED
38908: e1a01008 mov r1, r8 <== NOT EXECUTED
* exisiting file, the remaining entries will be placed in the buffer and the
* returned value will be equal to -m actual- times the size of a directory
* entry.
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
3890c: e089c004 add ip, r9, r4 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
38910: 3affffe2 bcc 388a0 <rtems_rfs_rtems_dir_read+0x80> <== NOT EXECUTED
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
38914: e1a00005 mov r0, r5 <== NOT EXECUTED
38918: e28d100c add r1, sp, #12 <== NOT EXECUTED
3891c: ebfffbf5 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
38920: e1a00005 mov r0, r5 <== NOT EXECUTED
38924: ebffff93 bl 38778 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return bytes_transferred;
}
38928: e1a00004 mov r0, r4 <== NOT EXECUTED
3892c: e28dd038 add sp, sp, #56 ; 0x38 <== NOT EXECUTED
38930: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00038790 <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)
{
38790: e92d40f1 push {r0, 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);
38794: 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);
38798: 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)
3879c: 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)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
387a0: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
387a4: 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);
387a8: 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)
387ac: 1a000003 bne 387c0 <rtems_rfs_rtems_dir_rmnod+0x30> <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_rmnod: root inode", EBUSY);
387b0: eb0011d2 bl 3cf00 <__errno> <== NOT EXECUTED
387b4: e3a03010 mov r3, #16 <== NOT EXECUTED
387b8: e5803000 str r3, [r0] <== NOT EXECUTED
387bc: ea000011 b 38808 <rtems_rfs_rtems_dir_rmnod+0x78> <== 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);
387c0: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
387c4: e3a01000 mov r1, #0 <== NOT EXECUTED
387c8: e1a02001 mov r2, r1 <== NOT EXECUTED
387cc: e5930000 ldr r0, [r3] <== NOT EXECUTED
387d0: ebff4c3a bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_if_empty);
387d4: e1a02005 mov r2, r5 <== NOT EXECUTED
387d8: e3a0c001 mov ip, #1 <== NOT EXECUTED
387dc: e1a01007 mov r1, r7 <== NOT EXECUTED
387e0: e1a03006 mov r3, r6 <== NOT EXECUTED
387e4: e1a00004 mov r0, r4 <== NOT EXECUTED
387e8: e58dc000 str ip, [sp] <== NOT EXECUTED
387ec: ebfffe46 bl 3810c <rtems_rfs_unlink> <== NOT EXECUTED
if (rc)
387f0: e2505000 subs r5, r0, #0 <== NOT EXECUTED
387f4: 0a000005 beq 38810 <rtems_rfs_rtems_dir_rmnod+0x80> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
387f8: e1a00004 mov r0, r4 <== NOT EXECUTED
387fc: ebffffdd bl 38778 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_rmnod: unlinking", rc);
38800: eb0011be bl 3cf00 <__errno> <== NOT EXECUTED
38804: e5805000 str r5, [r0] <== NOT EXECUTED
38808: e3e00000 mvn r0, #0 <== NOT EXECUTED
3880c: ea000002 b 3881c <rtems_rfs_rtems_dir_rmnod+0x8c> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
38810: e1a00004 mov r0, r4 <== NOT EXECUTED
38814: ebffffd7 bl 38778 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
38818: e1a00005 mov r0, r5 <== NOT EXECUTED
return 0;
}
3881c: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
0001ee68 <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)
{
1ee68: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
1ee6c: 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)
{
1ee70: 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);
1ee74: 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)
{
1ee78: 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);
1ee7c: e58d103c str r1, [sp, #60] ; 0x3c <== NOT EXECUTED
rtems_rfs_ino node_ino;
uint32_t doff = 0;
1ee80: 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)
{
1ee84: e1a07002 mov r7, r2 <== NOT EXECUTED
1ee88: e1a08000 mov r8, 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;
1ee8c: 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);
1ee90: e5934034 ldr r4, [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);
1ee94: eb009316 bl 43af4 <strlen> <== NOT EXECUTED
1ee98: e0880000 add r0, r8, r0 <== NOT EXECUTED
1ee9c: e5870000 str r0, [r7] <== NOT EXECUTED
while (*name != path)
1eea0: ea000007 b 1eec4 <rtems_rfs_rtems_eval_for_make+0x5c> <== NOT EXECUTED
{
(*name)--;
1eea4: e5872000 str r2, [r7] <== NOT EXECUTED
if (rtems_filesystem_is_separator (**name))
1eea8: e5530001 ldrb r0, [r3, #-1] <== NOT EXECUTED
1eeac: ebffa835 bl 8f88 <rtems_filesystem_is_separator> <== NOT EXECUTED
1eeb0: e3500000 cmp r0, #0 <== NOT EXECUTED
{
(*name)++;
1eeb4: 15973000 ldrne r3, [r7] <== NOT EXECUTED
1eeb8: 12833001 addne r3, r3, #1 <== NOT EXECUTED
1eebc: 15873000 strne r3, [r7] <== NOT EXECUTED
break;
1eec0: 1a000003 bne 1eed4 <rtems_rfs_rtems_eval_for_make+0x6c> <== 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)
1eec4: e5973000 ldr r3, [r7] <== NOT EXECUTED
1eec8: e1530008 cmp r3, r8 <== NOT EXECUTED
{
(*name)--;
1eecc: e2432001 sub r2, r3, #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)
1eed0: 1afffff3 bne 1eea4 <rtems_rfs_rtems_eval_for_make+0x3c> <== NOT EXECUTED
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen(path));
1eed4: e1a00008 mov r0, r8 <== NOT EXECUTED
1eed8: eb009305 bl 43af4 <strlen> <== NOT EXECUTED
1eedc: e1a01000 mov r1, r0 <== NOT EXECUTED
1eee0: e1a00008 mov r0, r8 <== NOT EXECUTED
1eee4: ebffa17d bl 74e0 <rtems_filesystem_prefix_separators> <== NOT EXECUTED
path += stripped;
1eee8: e0888000 add r8, r8, r0 <== NOT EXECUTED
rtems_rfs_rtems_lock (fs);
1eeec: e1a00004 mov r0, r4 <== NOT EXECUTED
1eef0: ebfffc7a bl 1e0e0 <rtems_rfs_rtems_lock> <== NOT EXECUTED
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1eef4: e28d600c add r6, sp, #12 <== NOT EXECUTED
1eef8: ea000000 b 1ef00 <rtems_rfs_rtems_eval_for_make+0x98> <== NOT EXECUTED
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen(path));
path += stripped;
rtems_rfs_rtems_lock (fs);
1eefc: e1a08009 mov r8, r9 <== NOT EXECUTED
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1ef00: e1a00004 mov r0, r4 <== NOT EXECUTED
1ef04: e59d103c ldr r1, [sp, #60] ; 0x3c <== NOT EXECUTED
1ef08: e1a02006 mov r2, r6 <== NOT EXECUTED
1ef0c: e3a03001 mov r3, #1 <== NOT EXECUTED
1ef10: eb00629b bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
1ef14: e250a000 subs sl, r0, #0 <== NOT EXECUTED
1ef18: da000004 ble 1ef30 <rtems_rfs_rtems_eval_for_make+0xc8> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1ef1c: e1a00004 mov r0, r4 <== NOT EXECUTED
1ef20: ebfffc73 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: read ino", rc);
1ef24: eb0077f5 bl 3cf00 <__errno> <== NOT EXECUTED
1ef28: e580a000 str sl, [r0] <== NOT EXECUTED
1ef2c: ea000012 b 1ef7c <rtems_rfs_rtems_eval_for_make+0x114> <== 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);
1ef30: 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)) &&
1ef34: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED
1ef38: e1a03403 lsl r3, r3, #8 <== NOT EXECUTED
1ef3c: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
1ef40: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED
1ef44: 1a00000e bne 1ef84 <rtems_rfs_rtems_eval_for_make+0x11c> <== NOT EXECUTED
1ef48: e1a00006 mov r0, r6 <== NOT EXECUTED
1ef4c: e3a01001 mov r1, #1 <== NOT EXECUTED
1ef50: eb00018a bl 1f580 <rtems_rfs_rtems_eval_perms> <== NOT EXECUTED
1ef54: e3500000 cmp r0, #0 <== NOT EXECUTED
1ef58: 1a000009 bne 1ef84 <rtems_rfs_rtems_eval_for_make+0x11c> <== NOT EXECUTED
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
{
rtems_rfs_inode_close (fs, &inode);
1ef5c: e1a01006 mov r1, r6 <== NOT EXECUTED
1ef60: e1a00004 mov r0, r4 <== NOT EXECUTED
1ef64: eb006263 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
1ef68: e1a00004 mov r0, r4 <== NOT EXECUTED
1ef6c: ebfffc60 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: eval perms", EACCES);
1ef70: eb0077e2 bl 3cf00 <__errno> <== NOT EXECUTED
1ef74: e3a0300d mov r3, #13 <== NOT EXECUTED
1ef78: e5803000 str r3, [r0] <== NOT EXECUTED
1ef7c: e3e05000 mvn r5, #0 <== NOT EXECUTED
1ef80: ea0000bc b 1f278 <rtems_rfs_rtems_eval_for_make+0x410> <== NOT EXECUTED
}
/*
* Is this the end of the pathname we where given ?
*/
if (path == *name)
1ef84: e5973000 ldr r3, [r7] <== NOT EXECUTED
1ef88: e1580003 cmp r8, r3 <== NOT EXECUTED
1ef8c: 0a000076 beq 1f16c <rtems_rfs_rtems_eval_for_make+0x304> <== NOT EXECUTED
1ef90: e3a0a000 mov sl, #0 <== NOT EXECUTED
1ef94: ea000000 b 1ef9c <rtems_rfs_rtems_eval_for_make+0x134> <== NOT EXECUTED
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
(*path != '\0') &&
(node_len < (rtems_rfs_fs_max_name (fs) - 1)))
{
node_len++;
1ef98: 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) &&
1ef9c: e7d8000a ldrb r0, [r8, sl] <== NOT EXECUTED
1efa0: ebffa7f8 bl 8f88 <rtems_filesystem_is_separator> <== NOT EXECUTED
1efa4: e3500000 cmp r0, #0 <== NOT EXECUTED
* @param pathloc
* @param name
* @return int
*/
int
rtems_rfs_rtems_eval_for_make (const char* path,
1efa8: e088b00a add fp, r8, 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) &&
1efac: 1a000006 bne 1efcc <rtems_rfs_rtems_eval_for_make+0x164> <== NOT EXECUTED
1efb0: e7d8300a ldrb r3, [r8, sl] <== NOT EXECUTED
1efb4: e3530000 cmp r3, #0 <== NOT EXECUTED
1efb8: 0a000003 beq 1efcc <rtems_rfs_rtems_eval_for_make+0x164> <== NOT EXECUTED
(*path != '\0') &&
(node_len < (rtems_rfs_fs_max_name (fs) - 1)))
1efbc: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED
1efc0: e2433001 sub r3, r3, #1 <== NOT EXECUTED
1efc4: e15a0003 cmp sl, r3 <== NOT EXECUTED
1efc8: 3afffff2 bcc 1ef98 <rtems_rfs_rtems_eval_for_make+0x130> <== NOT EXECUTED
}
/*
* Eat any separators at start of the new path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen (path));
1efcc: e1a0000b mov r0, fp <== NOT EXECUTED
1efd0: eb0092c7 bl 43af4 <strlen> <== NOT EXECUTED
1efd4: e1a01000 mov r1, r0 <== NOT EXECUTED
1efd8: e1a0000b mov r0, fp <== NOT EXECUTED
1efdc: ebffa13f bl 74e0 <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))
1efe0: e5d82000 ldrb r2, [r8] <== NOT EXECUTED
1efe4: e352002e cmp r2, #46 ; 0x2e <== NOT EXECUTED
}
/*
* Eat any separators at start of the new path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen (path));
1efe8: e1a03000 mov r3, r0 <== NOT EXECUTED
path += stripped;
1efec: e08b9000 add r9, 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))
1eff0: 1a00000e bne 1f030 <rtems_rfs_rtems_eval_for_make+0x1c8> <== NOT EXECUTED
1eff4: e5d80001 ldrb r0, [r8, #1] <== NOT EXECUTED
1eff8: e3500000 cmp r0, #0 <== NOT EXECUTED
1effc: 0a000004 beq 1f014 <rtems_rfs_rtems_eval_for_make+0x1ac> <== NOT EXECUTED
1f000: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
1f004: ebffa7df bl 8f88 <rtems_filesystem_is_separator> <== NOT EXECUTED
1f008: e3500000 cmp r0, #0 <== NOT EXECUTED
1f00c: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
1f010: 0a000006 beq 1f030 <rtems_rfs_rtems_eval_for_make+0x1c8> <== NOT EXECUTED
{
if (*path)
1f014: e7db3003 ldrb r3, [fp, r3] <== NOT EXECUTED
1f018: e3530000 cmp r3, #0 <== NOT EXECUTED
1f01c: 0a000052 beq 1f16c <rtems_rfs_rtems_eval_for_make+0x304> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
1f020: e1a00004 mov r0, r4 <== NOT EXECUTED
1f024: e1a01006 mov r1, r6 <== NOT EXECUTED
1f028: eb006232 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
continue;
1f02c: eaffffb2 b 1eefc <rtems_rfs_rtems_eval_for_make+0x94> <== 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))
1f030: e7db3003 ldrb r3, [fp, r3] <== NOT EXECUTED
1f034: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED
1f038: 1a000033 bne 1f10c <rtems_rfs_rtems_eval_for_make+0x2a4> <== NOT EXECUTED
1f03c: e5d93001 ldrb r3, [r9, #1] <== NOT EXECUTED
1f040: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED
1f044: 1a000030 bne 1f10c <rtems_rfs_rtems_eval_for_make+0x2a4> <== NOT EXECUTED
1f048: e5d90002 ldrb r0, [r9, #2] <== NOT EXECUTED
1f04c: e3500000 cmp r0, #0 <== NOT EXECUTED
1f050: e289b002 add fp, r9, #2 <== NOT EXECUTED
1f054: 0a000002 beq 1f064 <rtems_rfs_rtems_eval_for_make+0x1fc> <== NOT EXECUTED
1f058: ebffa7ca bl 8f88 <rtems_filesystem_is_separator> <== NOT EXECUTED
1f05c: e3500000 cmp r0, #0 <== NOT EXECUTED
1f060: 0a000029 beq 1f10c <rtems_rfs_rtems_eval_for_make+0x2a4> <== NOT EXECUTED
{
/*
* If we are at the root inode of the file system we have a crossmount
* path.
*/
if (ino == RTEMS_RFS_ROOT_INO)
1f064: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED
1f068: e3530001 cmp r3, #1 <== NOT EXECUTED
1f06c: 1a000013 bne 1f0c0 <rtems_rfs_rtems_eval_for_make+0x258> <== 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);
1f070: e28d100c add r1, sp, #12 <== NOT EXECUTED
1f074: e1a00004 mov r0, r4 <== NOT EXECUTED
1f078: eb00621e bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
1f07c: e1a00004 mov r0, r4 <== NOT EXECUTED
1f080: ebfffc1b bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
*pathloc = pathloc->mt_entry->mt_point_node;
1f084: e595c010 ldr ip, [r5, #16] <== NOT EXECUTED
1f088: e28cc008 add ip, ip, #8 <== NOT EXECUTED
1f08c: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
1f090: e1a0e005 mov lr, r5 <== NOT EXECUTED
1f094: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
1f098: e59c2000 ldr r2, [ip] <== NOT EXECUTED
1f09c: e58e2000 str r2, [lr] <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)(path + 2, pathloc, name);
1f0a0: e1a01005 mov r1, r5 <== NOT EXECUTED
1f0a4: e595300c ldr r3, [r5, #12] <== NOT EXECUTED
1f0a8: e1a0000b mov r0, fp <== NOT EXECUTED
1f0ac: e1a02007 mov r2, r7 <== NOT EXECUTED
1f0b0: e1a0e00f mov lr, pc <== NOT EXECUTED
1f0b4: e593f004 ldr pc, [r3, #4] <== NOT EXECUTED
1f0b8: e1a05000 mov r5, r0 <== NOT EXECUTED
1f0bc: ea00006d b 1f278 <rtems_rfs_rtems_eval_for_make+0x410> <== NOT EXECUTED
1f0c0: 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)))
1f0c4: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED
1f0c8: e1a03403 lsl r3, r3, #8 <== NOT EXECUTED
1f0cc: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
1f0d0: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED
1f0d4: 0a000007 beq 1f0f8 <rtems_rfs_rtems_eval_for_make+0x290> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
1f0d8: e1a01006 mov r1, r6 <== NOT EXECUTED
1f0dc: e1a00004 mov r0, r4 <== NOT EXECUTED
1f0e0: eb006204 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
1f0e4: e1a00004 mov r0, r4 <== NOT EXECUTED
1f0e8: ebfffc01 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTSUP);
1f0ec: eb007783 bl 3cf00 <__errno> <== NOT EXECUTED
1f0f0: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
1f0f4: eaffff9f b 1ef78 <rtems_rfs_rtems_eval_for_make+0x110> <== NOT EXECUTED
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
1f0f8: e1a00004 mov r0, r4 <== NOT EXECUTED
1f0fc: e1a01006 mov r1, r6 <== NOT EXECUTED
1f100: e59f217c ldr r2, [pc, #380] ; 1f284 <rtems_rfs_rtems_eval_for_make+0x41c><== NOT EXECUTED
1f104: e3a03002 mov r3, #2 <== NOT EXECUTED
1f108: ea000003 b 1f11c <rtems_rfs_rtems_eval_for_make+0x2b4> <== NOT EXECUTED
else
{
/*
* Read the inode so we know it exists and what type it is.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
1f10c: e1a02008 mov r2, r8 <== NOT EXECUTED
1f110: e1a0300a mov r3, sl <== NOT EXECUTED
1f114: e1a00004 mov r0, r4 <== NOT EXECUTED
1f118: e1a01006 mov r1, r6 <== NOT EXECUTED
1f11c: e28dc03c add ip, sp, #60 ; 0x3c <== NOT EXECUTED
1f120: e28de034 add lr, sp, #52 ; 0x34 <== NOT EXECUTED
1f124: e88d5000 stm sp, {ip, lr} <== NOT EXECUTED
1f128: eb005842 bl 35238 <rtems_rfs_dir_lookup_ino> <== NOT EXECUTED
node, node_len - stripped, &ino, &doff);
if (rc > 0)
1f12c: e2508000 subs r8, r0, #0 <== NOT EXECUTED
1f130: da000003 ble 1f144 <rtems_rfs_rtems_eval_for_make+0x2dc> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
1f134: e1a01006 mov r1, r6 <== NOT EXECUTED
1f138: e1a00004 mov r0, r4 <== NOT EXECUTED
1f13c: eb0061ed bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
1f140: ea000004 b 1f158 <rtems_rfs_rtems_eval_for_make+0x2f0> <== 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);
1f144: e1a00004 mov r0, r4 <== NOT EXECUTED
1f148: e1a01006 mov r1, r6 <== NOT EXECUTED
1f14c: eb0061e9 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
1f150: e2508000 subs r8, r0, #0 <== NOT EXECUTED
1f154: daffff68 ble 1eefc <rtems_rfs_rtems_eval_for_make+0x94> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1f158: e1a00004 mov r0, r4 <== NOT EXECUTED
1f15c: ebfffbe4 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: closing node", rc);
1f160: eb007766 bl 3cf00 <__errno> <== NOT EXECUTED
1f164: e5808000 str r8, [r0] <== NOT EXECUTED
1f168: eaffff83 b 1ef7c <rtems_rfs_rtems_eval_for_make+0x114> <== NOT EXECUTED
1f16c: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
}
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
1f170: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED
1f174: e1a03403 lsl r3, r3, #8 <== NOT EXECUTED
1f178: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
1f17c: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED
1f180: e28d600c add r6, sp, #12 <== NOT EXECUTED
1f184: 0a000007 beq 1f1a8 <rtems_rfs_rtems_eval_for_make+0x340> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
1f188: e1a01006 mov r1, r6 <== NOT EXECUTED
1f18c: e1a00004 mov r0, r4 <== NOT EXECUTED
1f190: eb0061d8 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
1f194: e1a00004 mov r0, r4 <== NOT EXECUTED
1f198: ebfffbd5 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTDIR);
1f19c: eb007757 bl 3cf00 <__errno> <== NOT EXECUTED
1f1a0: e3a03014 mov r3, #20 <== NOT EXECUTED
1f1a4: eaffff73 b 1ef78 <rtems_rfs_rtems_eval_for_make+0x110> <== NOT EXECUTED
}
if (!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_WX))
1f1a8: e1a00006 mov r0, r6 <== NOT EXECUTED
1f1ac: e3a01003 mov r1, #3 <== NOT EXECUTED
1f1b0: eb0000f2 bl 1f580 <rtems_rfs_rtems_eval_perms> <== NOT EXECUTED
1f1b4: e3500000 cmp r0, #0 <== NOT EXECUTED
1f1b8: 0affff67 beq 1ef5c <rtems_rfs_rtems_eval_for_make+0xf4> <== NOT EXECUTED
}
/*
* Make sure the name does not already exists in the directory.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, *name, strlen (*name),
1f1bc: e5977000 ldr r7, [r7] <== NOT EXECUTED
1f1c0: e1a00007 mov r0, r7 <== NOT EXECUTED
1f1c4: eb00924a bl 43af4 <strlen> <== NOT EXECUTED
1f1c8: e28dc038 add ip, sp, #56 ; 0x38 <== NOT EXECUTED
1f1cc: e1a03000 mov r3, r0 <== NOT EXECUTED
1f1d0: e1a02007 mov r2, r7 <== NOT EXECUTED
1f1d4: e58dc000 str ip, [sp] <== NOT EXECUTED
1f1d8: e1a00004 mov r0, r4 <== NOT EXECUTED
1f1dc: e28dc034 add ip, sp, #52 ; 0x34 <== NOT EXECUTED
1f1e0: e1a01006 mov r1, r6 <== NOT EXECUTED
1f1e4: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
1f1e8: eb005812 bl 35238 <rtems_rfs_dir_lookup_ino> <== NOT EXECUTED
&node_ino, &doff);
if (rc == 0)
1f1ec: e2507000 subs r7, r0, #0 <== NOT EXECUTED
1f1f0: 1a000007 bne 1f214 <rtems_rfs_rtems_eval_for_make+0x3ac> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
1f1f4: e1a01006 mov r1, r6 <== NOT EXECUTED
1f1f8: e1a00004 mov r0, r4 <== NOT EXECUTED
1f1fc: eb0061bd bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
1f200: e1a00004 mov r0, r4 <== NOT EXECUTED
1f204: ebfffbba bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: found name", EEXIST);
1f208: eb00773c bl 3cf00 <__errno> <== NOT EXECUTED
1f20c: e3a03011 mov r3, #17 <== NOT EXECUTED
1f210: eaffff58 b 1ef78 <rtems_rfs_rtems_eval_for_make+0x110> <== NOT EXECUTED
}
if (rc != ENOENT)
1f214: e3570002 cmp r7, #2 <== NOT EXECUTED
1f218: 0a000007 beq 1f23c <rtems_rfs_rtems_eval_for_make+0x3d4> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
1f21c: e1a01006 mov r1, r6 <== NOT EXECUTED
1f220: e1a00004 mov r0, r4 <== NOT EXECUTED
1f224: eb0061b3 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
1f228: e1a00004 mov r0, r4 <== NOT EXECUTED
1f22c: ebfffbb0 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: look up", rc);
1f230: eb007732 bl 3cf00 <__errno> <== NOT EXECUTED
1f234: e5807000 str r7, [r0] <== NOT EXECUTED
1f238: eaffff4f b 1ef7c <rtems_rfs_rtems_eval_for_make+0x114> <== NOT EXECUTED
/*
* Set the parent ino in the path location.
*/
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
1f23c: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED
1f240: e5853000 str r3, [r5] <== NOT EXECUTED
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
1f244: e59d3034 ldr r3, [sp, #52] ; 0x34 <== NOT EXECUTED
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
1f248: e1a00005 mov r0, r5 <== 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);
1f24c: e5853004 str r3, [r5, #4] <== NOT EXECUTED
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
1f250: e1a01006 mov r1, r6 <== NOT EXECUTED
1f254: eb0000da bl 1f5c4 <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);
1f258: e1a01006 mov r1, 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;
1f25c: 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);
1f260: e1a00004 mov r0, r4 <== 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;
1f264: 03a05005 moveq r5, #5 <== NOT EXECUTED
1f268: 13a05000 movne r5, #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);
1f26c: eb0061a1 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
1f270: e1a00004 mov r0, r4 <== NOT EXECUTED
1f274: ebfffb9e bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rc;
}
1f278: e1a00005 mov r0, r5 <== NOT EXECUTED
1f27c: e28dd040 add sp, sp, #64 ; 0x40 <== NOT EXECUTED
1f280: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0001f288 <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)
{
1f288: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
1f28c: e1a05003 mov r5, r3 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
1f290: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED
1f294: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
1f298: e5953000 ldr r3, [r5] <== NOT EXECUTED
int
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
1f29c: 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);
1f2a0: e58d3040 str r3, [sp, #64] ; 0x40 <== NOT EXECUTED
uint32_t doff = 0;
1f2a4: e3a03000 mov r3, #0 <== NOT EXECUTED
int
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
1f2a8: e1a08001 mov r8, r1 <== NOT EXECUTED
1f2ac: e1a06000 mov r6, 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);
uint32_t doff = 0;
1f2b0: e58d303c str r3, [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)
{
1f2b4: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
path, pathlen, ino);
/*
* Eat any separators at the start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
1f2b8: ebffa088 bl 74e0 <rtems_filesystem_prefix_separators> <== NOT EXECUTED
1f2bc: e1a07000 mov r7, r0 <== NOT EXECUTED
path += stripped;
pathlen -= stripped;
rtems_rfs_rtems_lock (fs);
1f2c0: e1a00004 mov r0, r4 <== NOT EXECUTED
/*
* Eat any separators at the start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
pathlen -= stripped;
1f2c4: e0678008 rsb r8, r7, r8 <== NOT EXECUTED
rtems_rfs_rtems_lock (fs);
1f2c8: ebfffb84 bl 1e0e0 <rtems_rfs_rtems_lock> <== NOT EXECUTED
/*
* Eat any separators at the start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
1f2cc: e0867007 add r7, r6, r7 <== 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,
1f2d0: e28d9040 add r9, sp, #64 ; 0x40 <== NOT EXECUTED
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1f2d4: e28d6014 add r6, sp, #20 <== NOT EXECUTED
1f2d8: ea000000 b 1f2e0 <rtems_rfs_rtems_eval_path+0x58> <== NOT EXECUTED
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
pathlen -= stripped;
rtems_rfs_rtems_lock (fs);
1f2dc: e59d700c ldr r7, [sp, #12] <== NOT EXECUTED
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1f2e0: e1a00004 mov r0, r4 <== NOT EXECUTED
1f2e4: e59d1040 ldr r1, [sp, #64] ; 0x40 <== NOT EXECUTED
1f2e8: e1a02006 mov r2, r6 <== NOT EXECUTED
1f2ec: e3a03001 mov r3, #1 <== NOT EXECUTED
1f2f0: eb0061a3 bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
1f2f4: e250a000 subs sl, r0, #0 <== NOT EXECUTED
1f2f8: da000004 ble 1f310 <rtems_rfs_rtems_eval_path+0x88> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1f2fc: e1a00004 mov r0, r4 <== NOT EXECUTED
1f300: ebfffb7b bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_path: opening inode", rc);
1f304: eb0076fd bl 3cf00 <__errno> <== NOT EXECUTED
1f308: e580a000 str sl, [r0] <== NOT EXECUTED
1f30c: ea000018 b 1f374 <rtems_rfs_rtems_eval_path+0xec> <== NOT EXECUTED
}
/*
* Is this the end of the pathname we where given ?
*/
if ((*path == '\0') || (pathlen == 0))
1f310: e5d73000 ldrb r3, [r7] <== NOT EXECUTED
1f314: e3580000 cmp r8, #0 <== NOT EXECUTED
1f318: 13530000 cmpne r3, #0 <== NOT EXECUTED
1f31c: 0a000083 beq 1f530 <rtems_rfs_rtems_eval_path+0x2a8> <== NOT EXECUTED
1f320: 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)) &&
1f324: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED
1f328: e1a03403 lsl r3, r3, #8 <== NOT EXECUTED
1f32c: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
1f330: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED
1f334: 0a000001 beq 1f340 <rtems_rfs_rtems_eval_path+0xb8> <== NOT EXECUTED
1f338: e3a0a000 mov sl, #0 <== NOT EXECUTED
1f33c: ea000010 b 1f384 <rtems_rfs_rtems_eval_path+0xfc> <== NOT EXECUTED
1f340: e1a00006 mov r0, r6 <== NOT EXECUTED
1f344: e3a01001 mov r1, #1 <== NOT EXECUTED
1f348: eb00008c bl 1f580 <rtems_rfs_rtems_eval_perms> <== NOT EXECUTED
1f34c: e3500000 cmp r0, #0 <== NOT EXECUTED
1f350: 1afffff8 bne 1f338 <rtems_rfs_rtems_eval_path+0xb0> <== NOT EXECUTED
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
{
rtems_rfs_inode_close (fs, &inode);
1f354: e1a01006 mov r1, r6 <== NOT EXECUTED
1f358: e1a00004 mov r0, r4 <== NOT EXECUTED
1f35c: eb006165 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
1f360: e1a00004 mov r0, r4 <== NOT EXECUTED
1f364: ebfffb62 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_path: eval perms", EACCES);
1f368: eb0076e4 bl 3cf00 <__errno> <== NOT EXECUTED
1f36c: e3a0300d mov r3, #13 <== NOT EXECUTED
1f370: e5803000 str r3, [r0] <== NOT EXECUTED
1f374: e3e05000 mvn r5, #0 <== NOT EXECUTED
1f378: ea00007c b 1f570 <rtems_rfs_rtems_eval_path+0x2e8> <== NOT EXECUTED
while (!rtems_filesystem_is_separator (*path) &&
(*path != '\0') && pathlen &&
((node_len + 1) < rtems_rfs_fs_max_name (fs)))
{
path++;
pathlen--;
1f37c: e2488001 sub r8, r8, #1 <== NOT EXECUTED
1f380: 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) &&
1f384: e7d7000a ldrb r0, [r7, sl] <== NOT EXECUTED
1f388: ebffa6fe bl 8f88 <rtems_filesystem_is_separator> <== NOT EXECUTED
1f38c: e3500000 cmp r0, #0 <== NOT EXECUTED
(*path != '\0') && pathlen &&
((node_len + 1) < rtems_rfs_fs_max_name (fs)))
1f390: e28a3001 add r3, sl, #1 <== NOT EXECUTED
* @param pathlen
* @param flags
* @param pathloc
*/
int
rtems_rfs_rtems_eval_path (const char* path,
1f394: e087b00a add fp, r7, 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) &&
1f398: 1a000006 bne 1f3b8 <rtems_rfs_rtems_eval_path+0x130> <== NOT EXECUTED
1f39c: e7d7200a ldrb r2, [r7, sl] <== NOT EXECUTED
1f3a0: e3580000 cmp r8, #0 <== NOT EXECUTED
1f3a4: 13520000 cmpne r2, #0 <== NOT EXECUTED
1f3a8: 0a000002 beq 1f3b8 <rtems_rfs_rtems_eval_path+0x130> <== NOT EXECUTED
(*path != '\0') && pathlen &&
((node_len + 1) < rtems_rfs_fs_max_name (fs)))
1f3ac: e5942018 ldr r2, [r4, #24] <== NOT EXECUTED
1f3b0: e1530002 cmp r3, r2 <== NOT EXECUTED
1f3b4: 3afffff0 bcc 1f37c <rtems_rfs_rtems_eval_path+0xf4> <== NOT EXECUTED
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
1f3b8: e1a01008 mov r1, r8 <== NOT EXECUTED
1f3bc: e1a0000b mov r0, fp <== NOT EXECUTED
1f3c0: ebffa046 bl 74e0 <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))
1f3c4: e5d72000 ldrb r2, [r7] <== NOT EXECUTED
1f3c8: e352002e cmp r2, #46 ; 0x2e <== NOT EXECUTED
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
1f3cc: e08b2000 add r2, fp, r0 <== NOT EXECUTED
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
1f3d0: e1a03000 mov r3, r0 <== NOT EXECUTED
path += stripped;
pathlen -= stripped;
1f3d4: e0608008 rsb r8, r0, r8 <== NOT EXECUTED
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
1f3d8: e58d200c str r2, [sp, #12] <== 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))
1f3dc: 1a00000e bne 1f41c <rtems_rfs_rtems_eval_path+0x194> <== NOT EXECUTED
1f3e0: e5d70001 ldrb r0, [r7, #1] <== NOT EXECUTED
1f3e4: e3500000 cmp r0, #0 <== NOT EXECUTED
1f3e8: 0a000004 beq 1f400 <rtems_rfs_rtems_eval_path+0x178> <== NOT EXECUTED
1f3ec: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
1f3f0: ebffa6e4 bl 8f88 <rtems_filesystem_is_separator> <== NOT EXECUTED
1f3f4: e3500000 cmp r0, #0 <== NOT EXECUTED
1f3f8: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
1f3fc: 0a000006 beq 1f41c <rtems_rfs_rtems_eval_path+0x194> <== NOT EXECUTED
{
if (*path)
1f400: e7db3003 ldrb r3, [fp, r3] <== NOT EXECUTED
1f404: e3530000 cmp r3, #0 <== NOT EXECUTED
1f408: 0a000048 beq 1f530 <rtems_rfs_rtems_eval_path+0x2a8> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
1f40c: e1a00004 mov r0, r4 <== NOT EXECUTED
1f410: e1a01006 mov r1, r6 <== NOT EXECUTED
1f414: eb006137 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
continue;
1f418: eaffffaf b 1f2dc <rtems_rfs_rtems_eval_path+0x54> <== 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))
1f41c: e5d72000 ldrb r2, [r7] <== NOT EXECUTED
1f420: e352002e cmp r2, #46 ; 0x2e <== NOT EXECUTED
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
pathlen -= stripped;
node_len += stripped;
1f424: e083a00a add sl, r3, sl <== 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))
1f428: 1a00002a bne 1f4d8 <rtems_rfs_rtems_eval_path+0x250> <== NOT EXECUTED
1f42c: e5d72001 ldrb r2, [r7, #1] <== NOT EXECUTED
1f430: e352002e cmp r2, #46 ; 0x2e <== NOT EXECUTED
1f434: 1a000027 bne 1f4d8 <rtems_rfs_rtems_eval_path+0x250> <== NOT EXECUTED
1f438: e5d70002 ldrb r0, [r7, #2] <== NOT EXECUTED
1f43c: e3500000 cmp r0, #0 <== NOT EXECUTED
1f440: 0a000004 beq 1f458 <rtems_rfs_rtems_eval_path+0x1d0> <== NOT EXECUTED
1f444: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
1f448: ebffa6ce bl 8f88 <rtems_filesystem_is_separator> <== NOT EXECUTED
1f44c: e3500000 cmp r0, #0 <== NOT EXECUTED
1f450: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
1f454: 0a00001f beq 1f4d8 <rtems_rfs_rtems_eval_path+0x250> <== NOT EXECUTED
{
/*
* If we are at root inode of the file system we have a crossmount path.
*/
if (ino == RTEMS_RFS_ROOT_INO)
1f458: e59d3040 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED
1f45c: e3530001 cmp r3, #1 <== NOT EXECUTED
1f460: 1a000015 bne 1f4bc <rtems_rfs_rtems_eval_path+0x234> <== NOT EXECUTED
{
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);
1f464: e1a01006 mov r1, r6 <== NOT EXECUTED
1f468: e1a00004 mov r0, r4 <== NOT EXECUTED
1f46c: eb006121 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
1f470: e1a00004 mov r0, r4 <== NOT EXECUTED
1f474: ebfffb1e bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
*pathloc = pathloc->mt_entry->mt_point_node;
1f478: e595c010 ldr ip, [r5, #16] <== NOT EXECUTED
1f47c: e28cc008 add ip, ip, #8 <== NOT EXECUTED
1f480: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
1f484: e1a0e005 mov lr, r5 <== NOT EXECUTED
1f488: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
1f48c: e59c2000 ldr r2, [ip] <== NOT EXECUTED
1f490: e58e2000 str r2, [lr] <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)(path - node_len, pathlen + node_len,
1f494: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
1f498: e1a03005 mov r3, r5 <== NOT EXECUTED
1f49c: e06a0002 rsb r0, sl, r2 <== NOT EXECUTED
1f4a0: e595c00c ldr ip, [r5, #12] <== NOT EXECUTED
1f4a4: e08a1008 add r1, sl, r8 <== NOT EXECUTED
1f4a8: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED
1f4ac: e1a0e00f mov lr, pc <== NOT EXECUTED
1f4b0: e59cf000 ldr pc, [ip] <== NOT EXECUTED
1f4b4: e1a05000 mov r5, r0 <== NOT EXECUTED
1f4b8: ea00002c b 1f570 <rtems_rfs_rtems_eval_path+0x2e8> <== NOT EXECUTED
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
1f4bc: e28dc03c add ip, sp, #60 ; 0x3c <== NOT EXECUTED
1f4c0: e1a00004 mov r0, r4 <== NOT EXECUTED
1f4c4: e1a01006 mov r1, r6 <== NOT EXECUTED
1f4c8: e59f20ac ldr r2, [pc, #172] ; 1f57c <rtems_rfs_rtems_eval_path+0x2f4><== NOT EXECUTED
1f4cc: e3a03002 mov r3, #2 <== NOT EXECUTED
1f4d0: e88d1200 stm sp, {r9, ip} <== NOT EXECUTED
1f4d4: ea000005 b 1f4f0 <rtems_rfs_rtems_eval_path+0x268> <== 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,
1f4d8: e28de03c add lr, sp, #60 ; 0x3c <== NOT EXECUTED
1f4dc: e88d4200 stm sp, {r9, lr} <== NOT EXECUTED
1f4e0: e063300a rsb r3, r3, sl <== NOT EXECUTED
1f4e4: e1a02007 mov r2, r7 <== NOT EXECUTED
1f4e8: e1a00004 mov r0, r4 <== NOT EXECUTED
1f4ec: e1a01006 mov r1, r6 <== NOT EXECUTED
1f4f0: eb005750 bl 35238 <rtems_rfs_dir_lookup_ino> <== NOT EXECUTED
node, node_len - stripped, &ino, &doff);
if (rc > 0)
1f4f4: e2507000 subs r7, r0, #0 <== NOT EXECUTED
1f4f8: ca000004 bgt 1f510 <rtems_rfs_rtems_eval_path+0x288> <== 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);
1f4fc: e1a00004 mov r0, r4 <== NOT EXECUTED
1f500: e1a01006 mov r1, r6 <== NOT EXECUTED
1f504: eb0060fb bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
1f508: e2507000 subs r7, r0, #0 <== NOT EXECUTED
1f50c: daffff72 ble 1f2dc <rtems_rfs_rtems_eval_path+0x54> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
1f510: e1a01006 mov r1, r6 <== NOT EXECUTED
1f514: e1a00004 mov r0, r4 <== NOT EXECUTED
1f518: eb0060f6 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
1f51c: e1a00004 mov r0, r4 <== NOT EXECUTED
1f520: ebfffaf3 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_path: closing node", rc);
1f524: eb007675 bl 3cf00 <__errno> <== NOT EXECUTED
1f528: e5807000 str r7, [r0] <== NOT EXECUTED
1f52c: eaffff90 b 1f374 <rtems_rfs_rtems_eval_path+0xec> <== NOT EXECUTED
}
}
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
1f530: e59d3040 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED
1f534: e5853000 str r3, [r5] <== NOT EXECUTED
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
1f538: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
1f53c: e28d6014 add r6, sp, #20 <== 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);
1f540: e5853004 str r3, [r5, #4] <== NOT EXECUTED
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
1f544: e1a00005 mov r0, r5 <== NOT EXECUTED
1f548: e1a01006 mov r1, r6 <== NOT EXECUTED
1f54c: eb00001c bl 1f5c4 <rtems_rfs_rtems_set_handlers> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
1f550: e1a01006 mov r1, 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;
1f554: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
1f558: e1a00004 mov r0, r4 <== 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;
1f55c: 03a05005 moveq r5, #5 <== NOT EXECUTED
1f560: 13a05000 movne r5, #0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
1f564: eb0060e3 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
1f568: e1a00004 mov r0, r4 <== NOT EXECUTED
1f56c: ebfffae0 bl 1e0f4 <rtems_rfs_rtems_unlock> <== 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;
}
1f570: e1a00005 mov r0, r5 <== NOT EXECUTED
1f574: e28dd044 add sp, sp, #68 ; 0x44 <== NOT EXECUTED
1f578: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0001f580 <rtems_rfs_rtems_eval_perms>:
1f580: 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;
1f584: e1a02181 lsl r2, r1, #3 <== NOT EXECUTED
1f588: e1822301 orr r2, r2, r1, lsl #6 <== NOT EXECUTED
1f58c: e1821001 orr r1, r2, r1 <== NOT EXECUTED
1f590: e5d32003 ldrb r2, [r3, #3] <== NOT EXECUTED
1f594: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED
1f598: e1a01b81 lsl r1, r1, #23 <== NOT EXECUTED
1f59c: e1823403 orr r3, r2, r3, lsl #8 <== NOT EXECUTED
1f5a0: e1a01ba1 lsr r1, r1, #23 <== NOT EXECUTED
1f5a4: 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;
}
1f5a8: 03a00000 moveq r0, #0 <== NOT EXECUTED
1f5ac: 13a00001 movne r0, #1 <== NOT EXECUTED
1f5b0: e12fff1e bx lr <== NOT EXECUTED
0001e1e4 <rtems_rfs_rtems_fchmod>:
* @return int
*/
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
1e1e4: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
1e1e8: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
1e1ec: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
1e1f0: e5907000 ldr r7, [r0] <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
1e1f4: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FCHMOD))
printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
ino, mode);
rtems_rfs_rtems_lock (fs);
1e1f8: e1a00004 mov r0, r4 <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
1e1fc: e1a06001 mov r6, r1 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FCHMOD))
printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
ino, mode);
rtems_rfs_rtems_lock (fs);
1e200: ebffffb6 bl 1e0e0 <rtems_rfs_rtems_lock> <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1e204: e1a01007 mov r1, r7 <== NOT EXECUTED
1e208: e1a00004 mov r0, r4 <== NOT EXECUTED
1e20c: e1a0200d mov r2, sp <== NOT EXECUTED
1e210: e3a03001 mov r3, #1 <== NOT EXECUTED
1e214: eb0065da bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
1e218: e2507000 subs r7, r0, #0 <== 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);
1e21c: e1a0500d mov r5, sp <== NOT EXECUTED
if (rc)
1e220: 0a000004 beq 1e238 <rtems_rfs_rtems_fchmod+0x54> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1e224: e1a00004 mov r0, r4 <== NOT EXECUTED
1e228: ebffffb1 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: opening inode", rc);
1e22c: eb007b33 bl 3cf00 <__errno> <== NOT EXECUTED
1e230: e5807000 str r7, [r0] <== NOT EXECUTED
1e234: ea000016 b 1e294 <rtems_rfs_rtems_fchmod+0xb0> <== 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);
1e238: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
1e23c: e5d32002 ldrb r2, [r3, #2] <== NOT EXECUTED
1e240: 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);
1e244: e2022a0f and r2, r2, #61440 ; 0xf000 <== NOT EXECUTED
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
1e248: e3c66a0f bic r6, r6, #61440 ; 0xf000 <== NOT EXECUTED
1e24c: e1826006 orr r6, r2, r6 <== NOT EXECUTED
1e250: 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);
1e254: e1a02c26 lsr r2, r6, #24 <== NOT EXECUTED
1e258: e5c32002 strb r2, [r3, #2] <== NOT EXECUTED
1e25c: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
1e260: e1a06826 lsr r6, r6, #16 <== NOT EXECUTED
1e264: e5c36003 strb r6, [r3, #3] <== NOT EXECUTED
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
1e268: e1a0100d mov r1, sp <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1e26c: e3a03001 mov r3, #1 <== NOT EXECUTED
1e270: e1a00004 mov r0, r4 <== NOT EXECUTED
1e274: e5cd3010 strb r3, [sp, #16] <== NOT EXECUTED
1e278: eb00659e bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
1e27c: e2505000 subs r5, r0, #0 <== NOT EXECUTED
1e280: da000005 ble 1e29c <rtems_rfs_rtems_fchmod+0xb8> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1e284: e1a00004 mov r0, r4 <== NOT EXECUTED
1e288: ebffff99 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
1e28c: eb007b1b bl 3cf00 <__errno> <== NOT EXECUTED
1e290: e5805000 str r5, [r0] <== NOT EXECUTED
1e294: e3e00000 mvn r0, #0 <== NOT EXECUTED
1e298: ea000002 b 1e2a8 <rtems_rfs_rtems_fchmod+0xc4> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
1e29c: e1a00004 mov r0, r4 <== NOT EXECUTED
1e2a0: ebffff93 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
1e2a4: e1a00007 mov r0, r7 <== NOT EXECUTED
return 0;
}
1e2a8: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
1e2ac: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
0001e0d8 <rtems_rfs_rtems_fcntl>:
int
rtems_rfs_rtems_fcntl (int cmd,
rtems_libio_t* iop)
{
return 0;
}
1e0d8: e3a00000 mov r0, #0 <== NOT EXECUTED
1e0dc: e12fff1e bx lr <== NOT EXECUTED
0001e900 <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));
1e900: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
1e904: e92d4010 push {r4, lr} <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
1e908: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED
1e90c: eb0056eb bl 344c0 <rtems_rfs_buffer_sync> <== NOT EXECUTED
if (rc)
1e910: e2504000 subs r4, r0, #0 <== NOT EXECUTED
1e914: 01a00004 moveq r0, r4 <== NOT EXECUTED
1e918: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
1e91c: eb007977 bl 3cf00 <__errno> <== NOT EXECUTED
1e920: e5804000 str r4, [r0] <== NOT EXECUTED
1e924: e3e00000 mvn r0, #0 <== NOT EXECUTED
return 0;
}
1e928: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00038a24 <rtems_rfs_rtems_file_close>:
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
38a24: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
rtems_rfs_file_handle* file = iop->file_info;
38a28: e5905038 ldr r5, [r0, #56] ; 0x38 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
38a2c: e595301c ldr r3, [r5, #28] <== NOT EXECUTED
38a30: 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);
38a34: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
38a38: e3a01000 mov r1, #0 <== NOT EXECUTED
38a3c: e1a02001 mov r2, r1 <== NOT EXECUTED
38a40: e5930000 ldr r0, [r3] <== NOT EXECUTED
38a44: ebff4b9d bl b8c0 <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);
38a48: e1a01005 mov r1, r5 <== NOT EXECUTED
38a4c: e1a00004 mov r0, r4 <== NOT EXECUTED
38a50: ebfff439 bl 35b3c <rtems_rfs_file_close> <== NOT EXECUTED
if (rc > 0)
38a54: e2505000 subs r5, r0, #0 <== NOT EXECUTED
38a58: da000002 ble 38a68 <rtems_rfs_rtems_file_close+0x44> <== NOT EXECUTED
rc = rtems_rfs_rtems_error ("file-close: file close", rc);
38a5c: eb001127 bl 3cf00 <__errno> <== NOT EXECUTED
38a60: e5805000 str r5, [r0] <== NOT EXECUTED
38a64: e3e05000 mvn r5, #0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
38a68: e1a00004 mov r0, r4 <== NOT EXECUTED
38a6c: ebffffe6 bl 38a0c <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rc;
}
38a70: e1a00005 mov r0, r5 <== NOT EXECUTED
38a74: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00038b00 <rtems_rfs_rtems_file_ftruncate>:
* @return int
*/
int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
rtems_off64_t length)
{
38b00: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_rfs_file_handle* file = iop->file_info;
38b04: e5904038 ldr r4, [r0, #56] ; 0x38 <== NOT EXECUTED
38b08: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
38b0c: e5933098 ldr r3, [r3, #152] ; 0x98 <== NOT EXECUTED
38b10: e593307c ldr r3, [r3, #124] ; 0x7c <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
rtems_off64_t length)
{
38b14: e1a06001 mov r6, r1 <== NOT EXECUTED
38b18: e3a01000 mov r1, #0 <== NOT EXECUTED
38b1c: e1a07002 mov r7, r2 <== NOT EXECUTED
38b20: e1a05000 mov r5, r0 <== NOT EXECUTED
38b24: e1a02001 mov r2, r1 <== NOT EXECUTED
38b28: e5930000 ldr r0, [r3] <== NOT EXECUTED
38b2c: ebff4b63 bl b8c0 <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);
38b30: e1a01006 mov r1, r6 <== NOT EXECUTED
38b34: e1a00004 mov r0, r4 <== NOT EXECUTED
38b38: e1a02007 mov r2, r7 <== NOT EXECUTED
38b3c: ebfff2b4 bl 35614 <rtems_rfs_file_set_size> <== NOT EXECUTED
if (rc)
38b40: e2506000 subs r6, r0, #0 <== NOT EXECUTED
38b44: 0a000002 beq 38b54 <rtems_rfs_rtems_file_ftruncate+0x54> <== NOT EXECUTED
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
38b48: eb0010ec bl 3cf00 <__errno> <== NOT EXECUTED
38b4c: e5806000 str r6, [r0] <== NOT EXECUTED
38b50: e3e06000 mvn r6, #0 <== NOT EXECUTED
iop->size = rtems_rfs_file_size (file);
38b54: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
38b58: e2831084 add r1, r3, #132 ; 0x84 <== NOT EXECUTED
38b5c: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
38b60: ebffeaa5 bl 335fc <rtems_rfs_block_get_size> <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
38b64: e594301c ldr r3, [r4, #28] <== 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);
38b68: e9850003 stmib r5, {r0, r1} <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
38b6c: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
38b70: ebffffa5 bl 38a0c <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rc;
}
38b74: e1a00006 mov r0, r6 <== NOT EXECUTED
38b78: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00038a04 <rtems_rfs_rtems_file_ioctl>:
int
rtems_rfs_rtems_file_ioctl (rtems_libio_t* iop, uint32_t command, void* buffer)
{
return 0;
}
38a04: e3a00000 mov r0, #0 <== NOT EXECUTED
38a08: e12fff1e bx lr <== NOT EXECUTED
00038b7c <rtems_rfs_rtems_file_lseek>:
*/
rtems_off64_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
38b7c: e92d4073 push {r0, r1, r4, r5, r6, lr} <== NOT EXECUTED
rtems_rfs_file_handle* file = iop->file_info;
38b80: e5905038 ldr r5, [r0, #56] ; 0x38 <== NOT EXECUTED
38b84: e595301c ldr r3, [r5, #28] <== NOT EXECUTED
38b88: e5933098 ldr r3, [r3, #152] ; 0x98 <== NOT EXECUTED
38b8c: e593307c ldr r3, [r3, #124] ; 0x7c <== NOT EXECUTED
38b90: e3a01000 mov r1, #0 <== NOT EXECUTED
*/
rtems_off64_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
38b94: e1a04000 mov r4, r0 <== NOT EXECUTED
38b98: e1a02001 mov r2, r1 <== NOT EXECUTED
38b9c: e5930000 ldr r0, [r3] <== NOT EXECUTED
38ba0: ebff4b46 bl b8c0 <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;
38ba4: e284200c add r2, r4, #12 <== NOT EXECUTED
38ba8: e8920006 ldm r2, {r1, r2} <== NOT EXECUTED
38bac: e28d3008 add r3, sp, #8 <== NOT EXECUTED
38bb0: e9230006 stmdb r3!, {r1, r2} <== NOT EXECUTED
rc = rtems_rfs_file_seek (file, pos, &pos);
38bb4: e1a00005 mov r0, r5 <== NOT EXECUTED
38bb8: e1a0300d mov r3, sp <== NOT EXECUTED
38bbc: ebfff346 bl 358dc <rtems_rfs_file_seek> <== NOT EXECUTED
if (rc)
38bc0: e2506000 subs r6, r0, #0 <== NOT EXECUTED
38bc4: e595301c ldr r3, [r5, #28] <== NOT EXECUTED
38bc8: 0a000006 beq 38be8 <rtems_rfs_rtems_file_lseek+0x6c> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
38bcc: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
38bd0: ebffff8d bl 38a0c <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("file_lseek: lseek", rc);
38bd4: eb0010c9 bl 3cf00 <__errno> <== NOT EXECUTED
38bd8: e3e04000 mvn r4, #0 <== NOT EXECUTED
38bdc: e5806000 str r6, [r0] <== NOT EXECUTED
38be0: e3e03000 mvn r3, #0 <== NOT EXECUTED
38be4: ea000003 b 38bf8 <rtems_rfs_rtems_file_lseek+0x7c> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
38be8: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
38bec: ebffff86 bl 38a0c <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return iop->offset;
38bf0: e284400c add r4, r4, #12 <== NOT EXECUTED
38bf4: e8940018 ldm r4, {r3, r4} <== NOT EXECUTED
}
38bf8: e1a01004 mov r1, r4 <== NOT EXECUTED
38bfc: e1a00003 mov r0, r3 <== NOT EXECUTED
38c00: e8bd807c pop {r2, r3, r4, r5, r6, pc} <== NOT EXECUTED
00038a78 <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);
38a78: 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)
{
38a7c: e92d4071 push {r0, r4, r5, r6, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
38a80: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
38a84: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
38a88: e3a01000 mov r1, #0 <== NOT EXECUTED
38a8c: e1a02001 mov r2, r1 <== NOT EXECUTED
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
38a90: e1a05000 mov r5, r0 <== NOT EXECUTED
38a94: e5930000 ldr r0, [r3] <== NOT EXECUTED
38a98: ebff4b88 bl b8c0 <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);
38a9c: e1a00004 mov r0, r4 <== NOT EXECUTED
38aa0: e5951038 ldr r1, [r5, #56] ; 0x38 <== NOT EXECUTED
38aa4: e3a02000 mov r2, #0 <== NOT EXECUTED
38aa8: e1a0300d mov r3, sp <== NOT EXECUTED
38aac: ebfff48f bl 35cf0 <rtems_rfs_file_open> <== NOT EXECUTED
if (rc > 0)
38ab0: e2506000 subs r6, r0, #0 <== NOT EXECUTED
38ab4: da000005 ble 38ad0 <rtems_rfs_rtems_file_open+0x58> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
38ab8: e1a00004 mov r0, r4 <== NOT EXECUTED
38abc: ebffffd2 bl 38a0c <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-open: open", rc);
38ac0: eb00110e bl 3cf00 <__errno> <== NOT EXECUTED
38ac4: e5806000 str r6, [r0] <== NOT EXECUTED
38ac8: e3e00000 mvn r0, #0 <== NOT EXECUTED
38acc: ea00000a b 38afc <rtems_rfs_rtems_file_open+0x84> <== 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);
38ad0: e59d3000 ldr r3, [sp] <== NOT EXECUTED
38ad4: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
38ad8: e2831084 add r1, r3, #132 ; 0x84 <== NOT EXECUTED
38adc: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
38ae0: ebffeac5 bl 335fc <rtems_rfs_block_get_size> <== NOT EXECUTED
iop->file_info = file;
38ae4: e59d3000 ldr r3, [sp] <== 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);
38ae8: e9850003 stmib r5, {r0, r1} <== NOT EXECUTED
iop->file_info = file;
38aec: e5853038 str r3, [r5, #56] ; 0x38 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
38af0: e1a00004 mov r0, r4 <== NOT EXECUTED
38af4: ebffffc4 bl 38a0c <rtems_rfs_rtems_unlock> <== NOT EXECUTED
38af8: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
}
38afc: e8bd8078 pop {r3, r4, r5, r6, pc} <== NOT EXECUTED
00038d78 <rtems_rfs_rtems_file_read>:
*/
ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
38d78: e92d47f1 push {r0, r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
rtems_rfs_file_handle* file = iop->file_info;
38d7c: e5904038 ldr r4, [r0, #56] ; 0x38 <== NOT EXECUTED
38d80: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
38d84: e5933098 ldr r3, [r3, #152] ; 0x98 <== NOT EXECUTED
38d88: e593307c ldr r3, [r3, #124] ; 0x7c <== NOT EXECUTED
*/
ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
38d8c: e1a08001 mov r8, r1 <== NOT EXECUTED
38d90: e3a01000 mov r1, #0 <== NOT EXECUTED
38d94: e1a05000 mov r5, r0 <== NOT EXECUTED
38d98: e1a06002 mov r6, r2 <== NOT EXECUTED
38d9c: e5930000 ldr r0, [r3] <== NOT EXECUTED
38da0: e1a02001 mov r2, r1 <== NOT EXECUTED
38da4: ebff4ac5 bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
38da8: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
38dac: e2831084 add r1, r3, #132 ; 0x84 <== NOT EXECUTED
38db0: 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;
38db4: e285500c add r5, r5, #12 <== NOT EXECUTED
38db8: e89500a0 ldm r5, {r5, r7} <== NOT EXECUTED
38dbc: ebffea0e bl 335fc <rtems_rfs_block_get_size> <== NOT EXECUTED
if (pos < rtems_rfs_file_size (file))
38dc0: e1510007 cmp r1, r7 <== NOT EXECUTED
38dc4: 8a000024 bhi 38e5c <rtems_rfs_rtems_file_read+0xe4> <== NOT EXECUTED
38dc8: 1a000001 bne 38dd4 <rtems_rfs_rtems_file_read+0x5c> <== NOT EXECUTED
38dcc: e1500005 cmp r0, r5 <== NOT EXECUTED
38dd0: 8a000021 bhi 38e5c <rtems_rfs_rtems_file_read+0xe4> <== NOT EXECUTED
38dd4: e3a05000 mov r5, #0 <== NOT EXECUTED
38dd8: ea000026 b 38e78 <rtems_rfs_rtems_file_read+0x100> <== NOT EXECUTED
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
38ddc: ebfff1b5 bl 354b8 <rtems_rfs_file_io_start> <== NOT EXECUTED
if (rc > 0)
38de0: e2507000 subs r7, r0, #0 <== NOT EXECUTED
break;
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
38de4: e1a00008 mov r0, r8 <== NOT EXECUTED
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
if (rc > 0)
38de8: da000002 ble 38df8 <rtems_rfs_rtems_file_read+0x80> <== NOT EXECUTED
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
38dec: eb001043 bl 3cf00 <__errno> <== NOT EXECUTED
38df0: e5807000 str r7, [r0] <== NOT EXECUTED
38df4: ea000016 b 38e54 <rtems_rfs_rtems_file_read+0xdc> <== NOT EXECUTED
break;
}
if (size == 0)
38df8: e59d3000 ldr r3, [sp] <== NOT EXECUTED
38dfc: e3530000 cmp r3, #0 <== NOT EXECUTED
38e00: 0a00001c beq 38e78 <rtems_rfs_rtems_file_read+0x100> <== NOT EXECUTED
break;
if (size > count)
38e04: e1530006 cmp r3, r6 <== NOT EXECUTED
size = count;
38e08: 858d6000 strhi r6, [sp] <== NOT EXECUTED
memcpy (data, rtems_rfs_file_data (file), size);
38e0c: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
38e10: e5931020 ldr r1, [r3, #32] <== NOT EXECUTED
38e14: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
38e18: e59d2000 ldr r2, [sp] <== NOT EXECUTED
38e1c: e0811003 add r1, r1, r3 <== NOT EXECUTED
38e20: eb001ce6 bl 401c0 <memcpy> <== NOT EXECUTED
data += size;
38e24: e59d7000 ldr r7, [sp] <== NOT EXECUTED
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
38e28: e1a00004 mov r0, r4 <== NOT EXECUTED
38e2c: e1a01007 mov r1, r7 <== NOT EXECUTED
38e30: e3a02001 mov r2, #1 <== NOT EXECUTED
38e34: ebfff2d8 bl 3599c <rtems_rfs_file_io_end> <== NOT EXECUTED
if (rc > 0)
38e38: e2509000 subs r9, r0, #0 <== NOT EXECUTED
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
count -= size;
read += size;
38e3c: d0855007 addle r5, r5, r7 <== NOT EXECUTED
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
38e40: d0888007 addle r8, r8, r7 <== NOT EXECUTED
count -= size;
38e44: d0676006 rsble r6, r7, r6 <== NOT EXECUTED
38e48: da000005 ble 38e64 <rtems_rfs_rtems_file_read+0xec> <== NOT EXECUTED
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
if (rc > 0)
{
read = rtems_rfs_rtems_error ("file-read: read: io-end", rc);
38e4c: eb00102b bl 3cf00 <__errno> <== NOT EXECUTED
38e50: e5809000 str r9, [r0] <== NOT EXECUTED
38e54: e3e05000 mvn r5, #0 <== NOT EXECUTED
38e58: ea000006 b 38e78 <rtems_rfs_rtems_file_read+0x100> <== NOT EXECUTED
void* buffer,
size_t count)
{
rtems_rfs_file_handle* file = iop->file_info;
rtems_rfs_pos pos;
uint8_t* data = buffer;
38e5c: e3a05000 mov r5, #0 <== NOT EXECUTED
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
38e60: e1a0a00d mov sl, sp <== NOT EXECUTED
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
38e64: e3560000 cmp r6, #0 <== NOT EXECUTED
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
38e68: e1a0100d mov r1, sp <== NOT EXECUTED
38e6c: e1a00004 mov r0, r4 <== NOT EXECUTED
38e70: e3a02001 mov r2, #1 <== NOT EXECUTED
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
38e74: 1affffd8 bne 38ddc <rtems_rfs_rtems_file_read+0x64> <== NOT EXECUTED
break;
}
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
38e78: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
38e7c: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
38e80: ebfffee1 bl 38a0c <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return read;
}
38e84: e1a00005 mov r0, r5 <== NOT EXECUTED
38e88: e8bd87f8 pop {r3, r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
00038c04 <rtems_rfs_rtems_file_write>:
*/
ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
38c04: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_rfs_file_handle* file = iop->file_info;
38c08: e5904038 ldr r4, [r0, #56] ; 0x38 <== NOT EXECUTED
38c0c: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
38c10: e5933098 ldr r3, [r3, #152] ; 0x98 <== NOT EXECUTED
38c14: 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)
{
38c18: e1a0a001 mov sl, r1 <== NOT EXECUTED
38c1c: e3a01000 mov r1, #0 <== NOT EXECUTED
38c20: e1a06000 mov r6, r0 <== NOT EXECUTED
38c24: e1a05002 mov r5, r2 <== NOT EXECUTED
38c28: e5930000 ldr r0, [r3] <== NOT EXECUTED
38c2c: e1a02001 mov r2, r1 <== NOT EXECUTED
38c30: ebff4b22 bl b8c0 <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))
38c34: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
38c38: e2831084 add r1, r3, #132 ; 0x84 <== NOT EXECUTED
38c3c: 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;
38c40: e286800c add r8, r6, #12 <== NOT EXECUTED
38c44: e8980180 ldm r8, {r7, r8} <== NOT EXECUTED
38c48: ebffea6b bl 335fc <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))
38c4c: e1510008 cmp r1, r8 <== NOT EXECUTED
38c50: 8a000011 bhi 38c9c <rtems_rfs_rtems_file_write+0x98> <== NOT EXECUTED
38c54: 1a000001 bne 38c60 <rtems_rfs_rtems_file_write+0x5c> <== NOT EXECUTED
38c58: e1500007 cmp r0, r7 <== NOT EXECUTED
38c5c: 8a00000e bhi 38c9c <rtems_rfs_rtems_file_write+0x98> <== NOT EXECUTED
{
rc = rtems_rfs_file_set_size (file, pos + 1);
38c60: e3a01001 mov r1, #1 <== NOT EXECUTED
38c64: e0911007 adds r1, r1, r7 <== NOT EXECUTED
38c68: e3a02000 mov r2, #0 <== NOT EXECUTED
38c6c: e0a22008 adc r2, r2, r8 <== NOT EXECUTED
38c70: e1a00004 mov r0, r4 <== NOT EXECUTED
38c74: ebfff266 bl 35614 <rtems_rfs_file_set_size> <== NOT EXECUTED
if (rc)
38c78: e2509000 subs r9, r0, #0 <== NOT EXECUTED
38c7c: 0a000006 beq 38c9c <rtems_rfs_rtems_file_write+0x98> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
38c80: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
38c84: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
38c88: ebffff5f bl 38a0c <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-write: write extend", rc);
38c8c: eb00109b bl 3cf00 <__errno> <== NOT EXECUTED
38c90: e3e07000 mvn r7, #0 <== NOT EXECUTED
38c94: e5809000 str r9, [r0] <== NOT EXECUTED
38c98: ea000034 b 38d70 <rtems_rfs_rtems_file_write+0x16c> <== NOT EXECUTED
}
}
rtems_rfs_file_set_bpos (file, pos);
38c9c: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
38ca0: e1a01007 mov r1, r7 <== NOT EXECUTED
38ca4: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
38ca8: e1a02008 mov r2, r8 <== NOT EXECUTED
38cac: e2843010 add r3, r4, #16 <== NOT EXECUTED
38cb0: ebffea22 bl 33540 <rtems_rfs_block_get_bpos> <== NOT EXECUTED
38cb4: e3a07000 mov r7, #0 <== NOT EXECUTED
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
38cb8: e1a0900d mov r9, sp <== NOT EXECUTED
}
}
rtems_rfs_file_set_bpos (file, pos);
while (count)
38cbc: ea00001e b 38d3c <rtems_rfs_rtems_file_write+0x138> <== NOT EXECUTED
{
size_t size = count;
38cc0: e58d5000 str r5, [sp] <== NOT EXECUTED
rc = rtems_rfs_file_io_start (file, &size, false);
38cc4: ebfff1fb bl 354b8 <rtems_rfs_file_io_start> <== NOT EXECUTED
if (rc)
38cc8: e2508000 subs r8, r0, #0 <== NOT EXECUTED
}
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
38ccc: e1a0100a mov r1, sl <== NOT EXECUTED
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
if (rc)
38cd0: 0a000002 beq 38ce0 <rtems_rfs_rtems_file_write+0xdc> <== NOT EXECUTED
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
38cd4: eb001089 bl 3cf00 <__errno> <== NOT EXECUTED
38cd8: e5808000 str r8, [r0] <== NOT EXECUTED
38cdc: ea000011 b 38d28 <rtems_rfs_rtems_file_write+0x124> <== NOT EXECUTED
break;
}
if (size > count)
38ce0: e59d3000 ldr r3, [sp] <== NOT EXECUTED
38ce4: e1530005 cmp r3, r5 <== NOT EXECUTED
size = count;
38ce8: 858d5000 strhi r5, [sp] <== NOT EXECUTED
memcpy (rtems_rfs_file_data (file), data, size);
38cec: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
38cf0: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED
38cf4: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
38cf8: e59d2000 ldr r2, [sp] <== NOT EXECUTED
38cfc: e0800003 add r0, r0, r3 <== NOT EXECUTED
38d00: eb001d2e bl 401c0 <memcpy> <== NOT EXECUTED
data += size;
38d04: e59d8000 ldr r8, [sp] <== NOT EXECUTED
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
38d08: e1a00004 mov r0, r4 <== NOT EXECUTED
38d0c: e1a01008 mov r1, r8 <== NOT EXECUTED
38d10: e3a02000 mov r2, #0 <== NOT EXECUTED
38d14: ebfff320 bl 3599c <rtems_rfs_file_io_end> <== NOT EXECUTED
if (rc)
38d18: e250b000 subs fp, r0, #0 <== NOT EXECUTED
38d1c: 0a000003 beq 38d30 <rtems_rfs_rtems_file_write+0x12c> <== NOT EXECUTED
{
write = rtems_rfs_rtems_error ("file-write: write close", rc);
38d20: eb001076 bl 3cf00 <__errno> <== NOT EXECUTED
38d24: e580b000 str fp, [r0] <== NOT EXECUTED
38d28: e3e07000 mvn r7, #0 <== NOT EXECUTED
38d2c: ea000007 b 38d50 <rtems_rfs_rtems_file_write+0x14c> <== NOT EXECUTED
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
count -= size;
write += size;
38d30: e0877008 add r7, r7, r8 <== NOT EXECUTED
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
38d34: e08aa008 add sl, sl, r8 <== NOT EXECUTED
count -= size;
38d38: e0685005 rsb r5, r8, r5 <== NOT EXECUTED
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
38d3c: e3a02000 mov r2, #0 <== NOT EXECUTED
}
}
rtems_rfs_file_set_bpos (file, pos);
while (count)
38d40: e1550002 cmp r5, r2 <== NOT EXECUTED
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
38d44: e1a0100d mov r1, sp <== NOT EXECUTED
38d48: e1a00004 mov r0, r4 <== NOT EXECUTED
}
}
rtems_rfs_file_set_bpos (file, pos);
while (count)
38d4c: 1affffdb bne 38cc0 <rtems_rfs_rtems_file_write+0xbc> <== NOT EXECUTED
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
iop->size = rtems_rfs_file_size (file);
38d50: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
38d54: e2831084 add r1, r3, #132 ; 0x84 <== NOT EXECUTED
38d58: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
38d5c: ebffea26 bl 335fc <rtems_rfs_block_get_size> <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
38d60: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
iop->size = rtems_rfs_file_size (file);
38d64: e9860003 stmib r6, {r0, r1} <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
38d68: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
38d6c: ebffff26 bl 38a0c <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return write;
}
38d70: e1a00007 mov r0, r7 <== NOT EXECUTED
38d74: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0001e0d0 <rtems_rfs_rtems_freenodinfo>:
int
rtems_rfs_rtems_freenodinfo (rtems_filesystem_location_info_t* pathloc)
{
return 0;
}
1e0d0: e3a00000 mov r0, #0 <== NOT EXECUTED
1e0d4: e12fff1e bx lr <== NOT EXECUTED
0001f5b4 <rtems_rfs_rtems_imode>:
return true;
}
uint16_t
rtems_rfs_rtems_imode (mode_t mode)
{
1f5b4: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
/*
* Mapping matches RTEMS so no need to change.
*/
return mode;
}
1f5b8: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED
1f5bc: e12fff1e bx lr <== NOT EXECUTED
0001e4ac <rtems_rfs_rtems_initialise>:
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
1e4ac: e92d45f3 push {r0, r1, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
1e4b0: e1a05000 mov r5, r0 <== NOT EXECUTED
1e4b4: e1a04001 mov r4, r1 <== NOT EXECUTED
rtems_rfs_rtems_private* rtems;
rtems_rfs_file_system* fs;
uint32_t flags = 0;
uint32_t max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
const char* options = data;
1e4b8: e3a07005 mov r7, #5 <== NOT EXECUTED
1e4bc: e3a06000 mov r6, #0 <== NOT EXECUTED
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
1e4c0: ea000024 b 1e558 <rtems_rfs_rtems_initialise+0xac> <== NOT EXECUTED
{
printf ("options=%s\n", options);
1e4c4: eb008beb bl 41478 <printf> <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
1e4c8: e59f1180 ldr r1, [pc, #384] ; 1e650 <rtems_rfs_rtems_initialise+0x1a4><== NOT EXECUTED
1e4cc: e3a0200c mov r2, #12 <== NOT EXECUTED
1e4d0: e1a00004 mov r0, r4 <== NOT EXECUTED
1e4d4: eb0095d0 bl 43c1c <strncmp> <== NOT EXECUTED
1e4d8: e3500000 cmp r0, #0 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
1e4dc: e59f1170 ldr r1, [pc, #368] ; 1e654 <rtems_rfs_rtems_initialise+0x1a8><== NOT EXECUTED
1e4e0: e3a0200e mov r2, #14 <== NOT EXECUTED
1e4e4: 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;
1e4e8: 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",
1e4ec: 0a000011 beq 1e538 <rtems_rfs_rtems_initialise+0x8c> <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
1e4f0: eb0095c9 bl 43c1c <strncmp> <== NOT EXECUTED
1e4f4: 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",
1e4f8: e59f1158 ldr r1, [pc, #344] ; 1e658 <rtems_rfs_rtems_initialise+0x1ac><== NOT EXECUTED
1e4fc: e3a0200d mov r2, #13 <== NOT EXECUTED
1e500: 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;
1e504: 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",
1e508: 0a00000a beq 1e538 <rtems_rfs_rtems_initialise+0x8c> <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
1e50c: eb0095c2 bl 43c1c <strncmp> <== NOT EXECUTED
1e510: e2501000 subs r1, r0, #0 <== NOT EXECUTED
1e514: 1a000004 bne 1e52c <rtems_rfs_rtems_initialise+0x80> <== NOT EXECUTED
sizeof ("max-held-bufs") - 1) == 0)
{
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
1e518: e284000e add r0, r4, #14 <== NOT EXECUTED
1e51c: e1a02001 mov r2, r1 <== NOT EXECUTED
1e520: eb009a8f bl 44f64 <strtoul> <== NOT EXECUTED
1e524: e1a07000 mov r7, r0 <== NOT EXECUTED
1e528: ea000002 b 1e538 <rtems_rfs_rtems_initialise+0x8c> <== NOT EXECUTED
}
else
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
1e52c: eb007a73 bl 3cf00 <__errno> <== NOT EXECUTED
1e530: e3a03016 mov r3, #22 <== NOT EXECUTED
1e534: ea000011 b 1e580 <rtems_rfs_rtems_initialise+0xd4> <== NOT EXECUTED
options = strchr (options, ',');
1e538: e1a00004 mov r0, r4 <== NOT EXECUTED
1e53c: e3a0102c mov r1, #44 ; 0x2c <== NOT EXECUTED
1e540: eb00929c bl 42fb8 <strchr> <== NOT EXECUTED
if (options)
1e544: e2504000 subs r4, r0, #0 <== NOT EXECUTED
1e548: 0a000006 beq 1e568 <rtems_rfs_rtems_initialise+0xbc> <== NOT EXECUTED
{
++options;
if (*options == '\0')
1e54c: e5f43001 ldrb r3, [r4, #1]! <== NOT EXECUTED
1e550: e3530000 cmp r3, #0 <== NOT EXECUTED
1e554: 0a000003 beq 1e568 <rtems_rfs_rtems_initialise+0xbc> <== NOT EXECUTED
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
1e558: e3540000 cmp r4, #0 <== NOT EXECUTED
{
printf ("options=%s\n", options);
1e55c: e1a01004 mov r1, r4 <== NOT EXECUTED
1e560: e59f00f4 ldr r0, [pc, #244] ; 1e65c <rtems_rfs_rtems_initialise+0x1b0><== NOT EXECUTED
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
1e564: 1affffd6 bne 1e4c4 <rtems_rfs_rtems_initialise+0x18> <== NOT EXECUTED
if (*options == '\0')
options = NULL;
}
}
rtems = malloc (sizeof (rtems_rfs_rtems_private));
1e568: e3a00004 mov r0, #4 <== NOT EXECUTED
1e56c: ebffa5f7 bl 7d50 <malloc> <== NOT EXECUTED
if (!rtems)
1e570: e2504000 subs r4, r0, #0 <== NOT EXECUTED
1e574: 1a000004 bne 1e58c <rtems_rfs_rtems_initialise+0xe0> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
1e578: eb007a60 bl 3cf00 <__errno> <== NOT EXECUTED
1e57c: e3a0300c mov r3, #12 <== NOT EXECUTED
1e580: e5803000 str r3, [r0] <== NOT EXECUTED
1e584: e3e00000 mvn r0, #0 <== NOT EXECUTED
1e588: ea000025 b 1e624 <rtems_rfs_rtems_initialise+0x178> <== NOT EXECUTED
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
1e58c: e3a08000 mov r8, #0 <== NOT EXECUTED
1e590: e5848000 str r8, [r4] <== NOT EXECUTED
rc = rtems_rfs_mutex_create (&rtems->access);
1e594: eb0067bc bl 3848c <rtems_rfs_mutex_create> <== NOT EXECUTED
if (rc > 0)
1e598: e250a000 subs sl, r0, #0 <== NOT EXECUTED
1e59c: da000004 ble 1e5b4 <rtems_rfs_rtems_initialise+0x108> <== NOT EXECUTED
{
free (rtems);
1e5a0: e1a00004 mov r0, r4 <== NOT EXECUTED
1e5a4: ebffa442 bl 76b4 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
1e5a8: eb007a54 bl 3cf00 <__errno> <== NOT EXECUTED
1e5ac: e580a000 str sl, [r0] <== NOT EXECUTED
1e5b0: eafffff3 b 1e584 <rtems_rfs_rtems_initialise+0xd8> <== 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);
1e5b4: e1a01008 mov r1, r8 <== NOT EXECUTED
1e5b8: e5940000 ldr r0, [r4] <== NOT EXECUTED
1e5bc: e1a02008 mov r2, r8 <== NOT EXECUTED
1e5c0: ebffb4be bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
1e5c4: e3500000 cmp r0, #0 <== NOT EXECUTED
1e5c8: 0a000016 beq 1e628 <rtems_rfs_rtems_initialise+0x17c> <== NOT EXECUTED
}
rc = rtems_rfs_mutex_lock (&rtems->access);
if (rc > 0)
{
rtems_rfs_mutex_destroy (&rtems->access);
1e5cc: e1a00004 mov r0, r4 <== NOT EXECUTED
1e5d0: eb0067a6 bl 38470 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
free (rtems);
1e5d4: e1a00004 mov r0, r4 <== NOT EXECUTED
1e5d8: ebffa435 bl 76b4 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
1e5dc: eb007a47 bl 3cf00 <__errno> <== NOT EXECUTED
1e5e0: e3a03005 mov r3, #5 <== NOT EXECUTED
1e5e4: eaffffe5 b 1e580 <rtems_rfs_rtems_initialise+0xd4> <== NOT EXECUTED
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
if (rc)
{
free (rtems);
1e5e8: e1a00004 mov r0, r4 <== NOT EXECUTED
1e5ec: ebffa430 bl 76b4 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", rc);
1e5f0: eb007a42 bl 3cf00 <__errno> <== NOT EXECUTED
1e5f4: e5806000 str r6, [r0] <== NOT EXECUTED
1e5f8: eaffffe1 b 1e584 <rtems_rfs_rtems_initialise+0xd8> <== 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;
1e5fc: e59f305c ldr r3, [pc, #92] ; 1e660 <rtems_rfs_rtems_initialise+0x1b4><== NOT EXECUTED
1e600: 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;
1e604: e3a03001 mov r3, #1 <== NOT EXECUTED
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
1e608: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;
1e60c: e585301c str r3, [r5, #28] <== NOT EXECUTED
mt_entry->mt_fs_root.handlers = &rtems_rfs_rtems_dir_handlers;
1e610: e59f304c ldr r3, [pc, #76] ; 1e664 <rtems_rfs_rtems_initialise+0x1b8><== NOT EXECUTED
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
1e614: 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;
1e618: e5853024 str r3, [r5, #36] ; 0x24 <== NOT EXECUTED
mt_entry->mt_fs_root.ops = &rtems_rfs_ops;
rtems_rfs_rtems_unlock (fs);
1e61c: ebfffeb4 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
1e620: e1a00006 mov r0, r6 <== NOT EXECUTED
return 0;
}
1e624: e8bd85fc pop {r2, r3, r4, r5, r6, r7, r8, sl, pc} <== 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);
1e628: e1a02006 mov r2, r6 <== NOT EXECUTED
1e62c: e5950070 ldr r0, [r5, #112] ; 0x70 <== NOT EXECUTED
1e630: e28dc004 add ip, sp, #4 <== NOT EXECUTED
1e634: e1a03007 mov r3, r7 <== NOT EXECUTED
1e638: e1a01004 mov r1, r4 <== NOT EXECUTED
1e63c: e58dc000 str ip, [sp] <== NOT EXECUTED
1e640: eb005e5b bl 35fb4 <rtems_rfs_fs_open> <== NOT EXECUTED
if (rc)
1e644: e2506000 subs r6, r0, #0 <== NOT EXECUTED
1e648: 1affffe6 bne 1e5e8 <rtems_rfs_rtems_initialise+0x13c> <== NOT EXECUTED
1e64c: eaffffea b 1e5fc <rtems_rfs_rtems_initialise+0x150> <== NOT EXECUTED
0001e700 <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)
{
1e700: e92d40f3 push {r0, r1, r4, r5, r6, r7, lr} <== NOT EXECUTED
1e704: e1a03000 mov r3, r0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (to_loc);
1e708: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
1e70c: e5904034 ldr r4, [r0, #52] ; 0x34 <== NOT EXECUTED
*/
int
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
rtems_filesystem_location_info_t* parent_loc,
const char* name)
{
1e710: e1a07002 mov r7, r2 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_LINK))
printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
parent, target);
rtems_rfs_rtems_lock (fs);
1e714: e1a00004 mov r0, r4 <== NOT EXECUTED
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
rtems_filesystem_location_info_t* parent_loc,
const char* name)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (to_loc);
rtems_rfs_ino target = rtems_rfs_rtems_get_pathloc_ino (to_loc);
1e718: e5935000 ldr r5, [r3] <== NOT EXECUTED
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
1e71c: e5916000 ldr r6, [r1] <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_LINK))
printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
parent, target);
rtems_rfs_rtems_lock (fs);
1e720: ebfffe6e bl 1e0e0 <rtems_rfs_rtems_lock> <== NOT EXECUTED
rc = rtems_rfs_link (fs, name, strlen (name), parent, target, false);
1e724: e1a00007 mov r0, r7 <== NOT EXECUTED
1e728: eb0094f1 bl 43af4 <strlen> <== NOT EXECUTED
1e72c: e3a0c000 mov ip, #0 <== NOT EXECUTED
1e730: e1a02000 mov r2, r0 <== NOT EXECUTED
1e734: e1a01007 mov r1, r7 <== NOT EXECUTED
1e738: e1a03006 mov r3, r6 <== NOT EXECUTED
1e73c: e1a00004 mov r0, r4 <== NOT EXECUTED
1e740: e88d1020 stm sp, {r5, ip} <== NOT EXECUTED
1e744: eb0066f2 bl 38314 <rtems_rfs_link> <== NOT EXECUTED
if (rc)
1e748: e2505000 subs r5, r0, #0 <== NOT EXECUTED
1e74c: 0a000005 beq 1e768 <rtems_rfs_rtems_link+0x68> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1e750: e1a00004 mov r0, r4 <== NOT EXECUTED
1e754: ebfffe66 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("link: linking", rc);
1e758: eb0079e8 bl 3cf00 <__errno> <== NOT EXECUTED
1e75c: e5805000 str r5, [r0] <== NOT EXECUTED
1e760: e3e00000 mvn r0, #0 <== NOT EXECUTED
1e764: ea000002 b 1e774 <rtems_rfs_rtems_link+0x74> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
1e768: e1a00004 mov r0, r4 <== NOT EXECUTED
1e76c: ebfffe60 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
1e770: e1a00005 mov r0, r5 <== NOT EXECUTED
return 0;
}
1e774: e8bd80fc pop {r2, r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
0001e0e0 <rtems_rfs_rtems_lock>:
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
1e0e0: e590307c ldr r3, [r0, #124] ; 0x7c <== NOT EXECUTED
1e0e4: e3a01000 mov r1, #0 <== NOT EXECUTED
1e0e8: e5930000 ldr r0, [r3] <== NOT EXECUTED
1e0ec: e1a02001 mov r2, r1 <== NOT EXECUTED
1e0f0: eaffb5f2 b b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
0001e92c <rtems_rfs_rtems_mknod>:
int
rtems_rfs_rtems_mknod (const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc)
{
1e92c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
1e930: e24dd040 sub sp, sp, #64 ; 0x40 <== NOT EXECUTED
1e934: e59dc060 ldr ip, [sp, #96] ; 0x60 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
1e938: e59ce010 ldr lr, [ip, #16] <== NOT EXECUTED
1e93c: e59e4034 ldr r4, [lr, #52] ; 0x34 <== NOT EXECUTED
int
rtems_rfs_rtems_mknod (const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc)
{
1e940: e1a07000 mov r7, r0 <== NOT EXECUTED
#else
uid = 0;
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
1e944: e1a00004 mov r0, r4 <== NOT EXECUTED
int
rtems_rfs_rtems_mknod (const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc)
{
1e948: e1a0a001 mov sl, 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);
1e94c: e59c9000 ldr r9, [ip] <== NOT EXECUTED
int
rtems_rfs_rtems_mknod (const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc)
{
1e950: e1a06002 mov r6, r2 <== NOT EXECUTED
1e954: e1a05003 mov r5, r3 <== NOT EXECUTED
#else
uid = 0;
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
1e958: ebfffde0 bl 1e0e0 <rtems_rfs_rtems_lock> <== NOT EXECUTED
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
1e95c: e1a00007 mov r0, r7 <== NOT EXECUTED
1e960: eb009463 bl 43af4 <strlen> <== NOT EXECUTED
1e964: e1a08000 mov r8, r0 <== NOT EXECUTED
rtems_rfs_rtems_imode (mode),
1e968: e1a0000a mov r0, sl <== NOT EXECUTED
1e96c: eb000310 bl 1f5b4 <rtems_rfs_rtems_imode> <== NOT EXECUTED
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
1e970: e3a0c000 mov ip, #0 <== NOT EXECUTED
1e974: e58d0000 str r0, [sp] <== NOT EXECUTED
1e978: e1a02007 mov r2, r7 <== NOT EXECUTED
1e97c: e1a03008 mov r3, r8 <== NOT EXECUTED
1e980: e28de03c add lr, sp, #60 ; 0x3c <== NOT EXECUTED
1e984: e1a01009 mov r1, r9 <== NOT EXECUTED
1e988: e3a07001 mov r7, #1 <== NOT EXECUTED
1e98c: e1a00004 mov r0, r4 <== NOT EXECUTED
1e990: e58dc00c str ip, [sp, #12] <== NOT EXECUTED
1e994: e58de010 str lr, [sp, #16] <== NOT EXECUTED
1e998: e98d1080 stmib sp, {r7, ip} <== NOT EXECUTED
1e99c: eb00645a bl 37b0c <rtems_rfs_inode_create> <== NOT EXECUTED
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
1e9a0: e2508000 subs r8, r0, #0 <== NOT EXECUTED
1e9a4: da000004 ble 1e9bc <rtems_rfs_rtems_mknod+0x90> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1e9a8: e1a00004 mov r0, r4 <== NOT EXECUTED
1e9ac: ebfffdd0 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: inode create", rc);
1e9b0: eb007952 bl 3cf00 <__errno> <== NOT EXECUTED
1e9b4: e5808000 str r8, [r0] <== NOT EXECUTED
1e9b8: ea00000b b 1e9ec <rtems_rfs_rtems_mknod+0xc0> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1e9bc: e28d8014 add r8, sp, #20 <== NOT EXECUTED
1e9c0: e1a00004 mov r0, r4 <== NOT EXECUTED
1e9c4: e59d103c ldr r1, [sp, #60] ; 0x3c <== NOT EXECUTED
1e9c8: e1a02008 mov r2, r8 <== NOT EXECUTED
1e9cc: e1a03007 mov r3, r7 <== NOT EXECUTED
1e9d0: eb0063eb bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
1e9d4: e2509000 subs r9, r0, #0 <== NOT EXECUTED
1e9d8: da000005 ble 1e9f4 <rtems_rfs_rtems_mknod+0xc8> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1e9dc: e1a00004 mov r0, r4 <== NOT EXECUTED
1e9e0: ebfffdc3 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: inode open", rc);
1e9e4: eb007945 bl 3cf00 <__errno> <== NOT EXECUTED
1e9e8: e5809000 str r9, [r0] <== NOT EXECUTED
1e9ec: e3e00000 mvn r0, #0 <== NOT EXECUTED
1e9f0: ea000034 b 1eac8 <rtems_rfs_rtems_mknod+0x19c> <== NOT EXECUTED
}
if (S_ISDIR(mode) || S_ISREG(mode))
1e9f4: e20aaa0f and sl, sl, #61440 ; 0xf000 <== NOT EXECUTED
1e9f8: e35a0901 cmp sl, #16384 ; 0x4000 <== NOT EXECUTED
1e9fc: 135a0902 cmpne sl, #32768 ; 0x8000 <== NOT EXECUTED
1ea00: 0a000023 beq 1ea94 <rtems_rfs_rtems_mknod+0x168> <== NOT EXECUTED
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
1ea04: e35a0a02 cmp sl, #8192 ; 0x2000 <== NOT EXECUTED
1ea08: 135a0a06 cmpne sl, #24576 ; 0x6000 <== NOT EXECUTED
1ea0c: 1a000017 bne 1ea70 <rtems_rfs_rtems_mknod+0x144> <== 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);
1ea10: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
1ea14: e1a02c26 lsr r2, r6, #24 <== NOT EXECUTED
1ea18: e5c3201c strb r2, [r3, #28] <== NOT EXECUTED
1ea1c: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
1ea20: e1a02826 lsr r2, r6, #16 <== NOT EXECUTED
1ea24: e5c3201d strb r2, [r3, #29] <== NOT EXECUTED
1ea28: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
1ea2c: e1a02426 lsr r2, r6, #8 <== NOT EXECUTED
1ea30: e5c3201e strb r2, [r3, #30] <== NOT EXECUTED
1ea34: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
1ea38: e5c3601f strb r6, [r3, #31] <== NOT EXECUTED
1ea3c: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
1ea40: e1a02c25 lsr r2, r5, #24 <== NOT EXECUTED
1ea44: e5c32020 strb r2, [r3, #32] <== NOT EXECUTED
1ea48: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
1ea4c: e1a02825 lsr r2, r5, #16 <== NOT EXECUTED
1ea50: e5c32021 strb r2, [r3, #33] ; 0x21 <== NOT EXECUTED
1ea54: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
1ea58: e1a02425 lsr r2, r5, #8 <== NOT EXECUTED
1ea5c: e5c32022 strb r2, [r3, #34] ; 0x22 <== NOT EXECUTED
1ea60: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
1ea64: e5c35023 strb r5, [r3, #35] ; 0x23 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1ea68: e5cd7024 strb r7, [sp, #36] ; 0x24 <== NOT EXECUTED
1ea6c: ea000008 b 1ea94 <rtems_rfs_rtems_mknod+0x168> <== 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);
1ea70: e1a01008 mov r1, r8 <== NOT EXECUTED
1ea74: e1a00004 mov r0, r4 <== NOT EXECUTED
1ea78: eb00639e bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
1ea7c: e1a00004 mov r0, r4 <== NOT EXECUTED
1ea80: ebfffd9b bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
1ea84: eb00791d bl 3cf00 <__errno> <== NOT EXECUTED
1ea88: e3a03016 mov r3, #22 <== NOT EXECUTED
1ea8c: e5803000 str r3, [r0] <== NOT EXECUTED
1ea90: eaffffd5 b 1e9ec <rtems_rfs_rtems_mknod+0xc0> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
1ea94: e1a00004 mov r0, r4 <== NOT EXECUTED
1ea98: e28d1014 add r1, sp, #20 <== NOT EXECUTED
1ea9c: eb006395 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
1eaa0: e2505000 subs r5, r0, #0 <== NOT EXECUTED
1eaa4: da000004 ble 1eabc <rtems_rfs_rtems_mknod+0x190> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1eaa8: e1a00004 mov r0, r4 <== NOT EXECUTED
1eaac: ebfffd90 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
1eab0: eb007912 bl 3cf00 <__errno> <== NOT EXECUTED
1eab4: e5805000 str r5, [r0] <== NOT EXECUTED
1eab8: eaffffcb b 1e9ec <rtems_rfs_rtems_mknod+0xc0> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
1eabc: e1a00004 mov r0, r4 <== NOT EXECUTED
1eac0: ebfffd8b bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
1eac4: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
}
1eac8: e28dd040 add sp, sp, #64 ; 0x40 <== NOT EXECUTED
1eacc: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
0001f5c0 <rtems_rfs_rtems_mode>:
{
/*
* Mapping matches RTEMS so no need to change.
*/
return imode;
}
1f5c0: e12fff1e bx lr <== NOT EXECUTED
0001e3a8 <rtems_rfs_rtems_node_type>:
* @return rtems_filesystem_node_types_t
*/
rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
{
1e3a8: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
1e3ac: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
1e3b0: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
1e3b4: e5905000 ldr r5, [r0] <== NOT EXECUTED
* @return rtems_filesystem_node_types_t
*/
rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
{
1e3b8: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED
rtems_filesystem_node_types_t type;
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
rtems_rfs_rtems_lock (fs);
1e3bc: e1a00004 mov r0, r4 <== NOT EXECUTED
1e3c0: ebffff46 bl 1e0e0 <rtems_rfs_rtems_lock> <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1e3c4: e1a01005 mov r1, r5 <== NOT EXECUTED
1e3c8: e1a00004 mov r0, r4 <== NOT EXECUTED
1e3cc: e1a0200d mov r2, sp <== NOT EXECUTED
1e3d0: e3a03001 mov r3, #1 <== NOT EXECUTED
1e3d4: eb00656a bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
1e3d8: e2505000 subs r5, r0, #0 <== NOT EXECUTED
1e3dc: da000004 ble 1e3f4 <rtems_rfs_rtems_node_type+0x4c> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1e3e0: e1a00004 mov r0, r4 <== NOT EXECUTED
1e3e4: ebffff42 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
1e3e8: eb007ac4 bl 3cf00 <__errno> <== NOT EXECUTED
1e3ec: e5805000 str r5, [r0] <== NOT EXECUTED
1e3f0: ea000016 b 1e450 <rtems_rfs_rtems_node_type+0xa8> <== 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);
1e3f4: 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))
1e3f8: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED
1e3fc: e1a03403 lsl r3, r3, #8 <== NOT EXECUTED
1e400: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
1e404: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED
1e408: 03a05001 moveq r5, #1 <== NOT EXECUTED
1e40c: 0a000006 beq 1e42c <rtems_rfs_rtems_node_type+0x84> <== NOT EXECUTED
type = RTEMS_FILESYSTEM_DIRECTORY;
else if (RTEMS_RFS_S_ISLNK (mode))
1e410: e3530a0a cmp r3, #40960 ; 0xa000 <== NOT EXECUTED
1e414: 03a05004 moveq r5, #4 <== NOT EXECUTED
1e418: 0a000003 beq 1e42c <rtems_rfs_rtems_node_type+0x84> <== NOT EXECUTED
type = RTEMS_FILESYSTEM_SYM_LINK;
else if (RTEMS_RFS_S_ISBLK (mode) || RTEMS_RFS_S_ISCHR (mode))
1e41c: e3530a06 cmp r3, #24576 ; 0x6000 <== NOT EXECUTED
1e420: 13530a02 cmpne r3, #8192 ; 0x2000 <== NOT EXECUTED
1e424: 03a05002 moveq r5, #2 <== NOT EXECUTED
1e428: 13a05005 movne r5, #5 <== NOT EXECUTED
type = RTEMS_FILESYSTEM_DEVICE;
else
type = RTEMS_FILESYSTEM_MEMORY_FILE;
rc = rtems_rfs_inode_close (fs, &inode);
1e42c: e1a00004 mov r0, r4 <== NOT EXECUTED
1e430: e1a0100d mov r1, sp <== NOT EXECUTED
1e434: eb00652f bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
1e438: e2506000 subs r6, r0, #0 <== NOT EXECUTED
1e43c: da000005 ble 1e458 <rtems_rfs_rtems_node_type+0xb0> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1e440: e1a00004 mov r0, r4 <== NOT EXECUTED
1e444: ebffff2a bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
1e448: eb007aac bl 3cf00 <__errno> <== NOT EXECUTED
1e44c: e5806000 str r6, [r0] <== NOT EXECUTED
1e450: e3e05000 mvn r5, #0 <== NOT EXECUTED
1e454: ea000001 b 1e460 <rtems_rfs_rtems_node_type+0xb8> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
1e458: e1a00004 mov r0, r4 <== NOT EXECUTED
1e45c: ebffff24 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return type;
}
1e460: e1a00005 mov r0, r5 <== NOT EXECUTED
1e464: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
1e468: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
0001ed68 <rtems_rfs_rtems_readlink>:
int
rtems_rfs_rtems_readlink (rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
1ed68: e92d40f3 push {r0, r1, r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
1ed6c: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
1ed70: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
1ed74: e5907000 ldr r7, [r0] <== NOT EXECUTED
int
rtems_rfs_rtems_readlink (rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
1ed78: e1a05002 mov r5, r2 <== NOT EXECUTED
1ed7c: e1a06001 mov r6, r1 <== NOT EXECUTED
int rc;
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);
1ed80: e1a00004 mov r0, r4 <== NOT EXECUTED
1ed84: ebfffcd5 bl 1e0e0 <rtems_rfs_rtems_lock> <== NOT EXECUTED
rc = rtems_rfs_symlink_read (fs, ino, buf, bufsize, &length);
1ed88: e1a03005 mov r3, r5 <== NOT EXECUTED
1ed8c: e28dc004 add ip, sp, #4 <== NOT EXECUTED
1ed90: e1a01007 mov r1, r7 <== NOT EXECUTED
1ed94: e1a02006 mov r2, r6 <== NOT EXECUTED
1ed98: e1a00004 mov r0, r4 <== NOT EXECUTED
1ed9c: e58dc000 str ip, [sp] <== NOT EXECUTED
1eda0: eb0063f1 bl 37d6c <rtems_rfs_symlink_read> <== NOT EXECUTED
if (rc)
1eda4: e2505000 subs r5, r0, #0 <== NOT EXECUTED
1eda8: 0a000005 beq 1edc4 <rtems_rfs_rtems_readlink+0x5c> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1edac: e1a00004 mov r0, r4 <== NOT EXECUTED
1edb0: ebfffccf bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("readlink: reading link", rc);
1edb4: eb007851 bl 3cf00 <__errno> <== NOT EXECUTED
1edb8: e5805000 str r5, [r0] <== NOT EXECUTED
1edbc: e3e00000 mvn r0, #0 <== NOT EXECUTED
1edc0: ea000002 b 1edd0 <rtems_rfs_rtems_readlink+0x68> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
1edc4: e1a00004 mov r0, r4 <== NOT EXECUTED
1edc8: ebfffcc9 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return (int) length;
1edcc: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
}
1edd0: e8bd80fc pop {r2, r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
0001e778 <rtems_rfs_rtems_rename>:
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)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
1e778: e591c010 ldr ip, [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)
{
1e77c: e92d45f3 push {r0, r1, r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
1e780: e59c4034 ldr r4, [ip, #52] ; 0x34 <== 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)
{
1e784: e1a0a003 mov sl, r3 <== 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);
1e788: e5907000 ldr r7, [r0] <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_RENAME))
printf ("rtems-rfs: rename: ino:%" PRId32 " doff:%" PRIu32 ", new parent:%" PRId32 " new name:%s\n",
ino, doff, new_parent, new_name);
rtems_rfs_rtems_lock (fs);
1e78c: e1a00004 mov r0, r4 <== 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);
1e790: e5928000 ldr r8, [r2] <== NOT EXECUTED
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
1e794: e8910060 ldm r1, {r5, r6} <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_RENAME))
printf ("rtems-rfs: rename: ino:%" PRId32 " doff:%" PRIu32 ", new parent:%" PRId32 " new name:%s\n",
ino, doff, new_parent, new_name);
rtems_rfs_rtems_lock (fs);
1e798: ebfffe50 bl 1e0e0 <rtems_rfs_rtems_lock> <== 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);
1e79c: e1a0000a mov r0, sl <== NOT EXECUTED
1e7a0: eb0094d3 bl 43af4 <strlen> <== NOT EXECUTED
1e7a4: e1a03008 mov r3, r8 <== NOT EXECUTED
1e7a8: e1a02000 mov r2, r0 <== NOT EXECUTED
1e7ac: e3a0c001 mov ip, #1 <== NOT EXECUTED
1e7b0: e1a0100a mov r1, sl <== NOT EXECUTED
1e7b4: e1a00004 mov r0, r4 <== NOT EXECUTED
1e7b8: e88d1020 stm sp, {r5, ip} <== NOT EXECUTED
1e7bc: eb0066d4 bl 38314 <rtems_rfs_link> <== NOT EXECUTED
if (rc)
1e7c0: e2508000 subs r8, r0, #0 <== NOT EXECUTED
1e7c4: 0a000004 beq 1e7dc <rtems_rfs_rtems_rename+0x64> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1e7c8: e1a00004 mov r0, r4 <== NOT EXECUTED
1e7cc: ebfffe48 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("rename: linking", rc);
1e7d0: eb0079ca bl 3cf00 <__errno> <== NOT EXECUTED
1e7d4: e5808000 str r8, [r0] <== NOT EXECUTED
1e7d8: ea00000c b 1e810 <rtems_rfs_rtems_rename+0x98> <== 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,
1e7dc: e1a02005 mov r2, r5 <== NOT EXECUTED
1e7e0: e3a0c002 mov ip, #2 <== NOT EXECUTED
1e7e4: e1a01007 mov r1, r7 <== NOT EXECUTED
1e7e8: e1a03006 mov r3, r6 <== NOT EXECUTED
1e7ec: e1a00004 mov r0, r4 <== NOT EXECUTED
1e7f0: e58dc000 str ip, [sp] <== NOT EXECUTED
1e7f4: eb006644 bl 3810c <rtems_rfs_unlink> <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
1e7f8: e2505000 subs r5, r0, #0 <== NOT EXECUTED
1e7fc: 0a000005 beq 1e818 <rtems_rfs_rtems_rename+0xa0> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1e800: e1a00004 mov r0, r4 <== NOT EXECUTED
1e804: ebfffe3a bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("rename: unlinking", rc);
1e808: eb0079bc bl 3cf00 <__errno> <== NOT EXECUTED
1e80c: e5805000 str r5, [r0] <== NOT EXECUTED
1e810: e3e00000 mvn r0, #0 <== NOT EXECUTED
1e814: ea000002 b 1e824 <rtems_rfs_rtems_rename+0xac> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
1e818: e1a00004 mov r0, r4 <== NOT EXECUTED
1e81c: ebfffe34 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
1e820: e1a00005 mov r0, r5 <== NOT EXECUTED
return 0;
}
1e824: e8bd85fc pop {r2, r3, r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
0001e828 <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);
1e828: e5913010 ldr r3, [r1, #16] <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
1e82c: e92d40f1 push {r0, r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
1e830: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
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);
1e834: 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);
1e838: e5907000 ldr r7, [r0] <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
1e83c: e5916000 ldr r6, [r1] <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_RMNOD))
printf ("rtems-rfs: rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
rtems_rfs_rtems_lock (fs);
1e840: e1a00004 mov r0, r4 <== NOT EXECUTED
1e844: ebfffe25 bl 1e0e0 <rtems_rfs_rtems_lock> <== NOT EXECUTED
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
1e848: e1a03005 mov r3, r5 <== NOT EXECUTED
1e84c: e3a0c000 mov ip, #0 <== NOT EXECUTED
1e850: e1a01007 mov r1, r7 <== NOT EXECUTED
1e854: e1a02006 mov r2, r6 <== NOT EXECUTED
1e858: e1a00004 mov r0, r4 <== NOT EXECUTED
1e85c: e58dc000 str ip, [sp] <== NOT EXECUTED
1e860: eb006629 bl 3810c <rtems_rfs_unlink> <== NOT EXECUTED
if (rc)
1e864: e2505000 subs r5, r0, #0 <== NOT EXECUTED
1e868: 0a000005 beq 1e884 <rtems_rfs_rtems_rmnod+0x5c> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1e86c: e1a00004 mov r0, r4 <== NOT EXECUTED
1e870: ebfffe1f bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("rmnod: unlinking", rc);
1e874: eb0079a1 bl 3cf00 <__errno> <== NOT EXECUTED
1e878: e5805000 str r5, [r0] <== NOT EXECUTED
1e87c: e3e00000 mvn r0, #0 <== NOT EXECUTED
1e880: ea000002 b 1e890 <rtems_rfs_rtems_rmnod+0x68> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
1e884: e1a00004 mov r0, r4 <== NOT EXECUTED
1e888: ebfffe19 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
1e88c: e1a00005 mov r0, r5 <== NOT EXECUTED
return 0;
}
1e890: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
0001f5c4 <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
1f5c4: e92d4010 push {r4, lr} <== NOT EXECUTED
1f5c8: e591300c ldr r3, [r1, #12] <== NOT EXECUTED
1f5cc: e5d32003 ldrb r2, [r3, #3] <== NOT EXECUTED
1f5d0: e5d31002 ldrb r1, [r3, #2] <== NOT EXECUTED
1f5d4: 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))
1f5d8: e2013a0f and r3, r1, #61440 ; 0xf000 <== NOT EXECUTED
1f5dc: 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;
1f5e0: e3a02000 mov r2, #0 <== NOT EXECUTED
1f5e4: e5802008 str r2, [r0, #8] <== NOT EXECUTED
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
1f5e8: 059f304c ldreq r3, [pc, #76] ; 1f63c <rtems_rfs_rtems_set_handlers+0x78><== NOT EXECUTED
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;
if (RTEMS_RFS_S_ISDIR (mode))
1f5ec: 0a00000b beq 1f620 <rtems_rfs_rtems_set_handlers+0x5c> <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
1f5f0: e3530a02 cmp r3, #8192 ; 0x2000 <== NOT EXECUTED
1f5f4: 13530a06 cmpne r3, #24576 ; 0x6000 <== NOT EXECUTED
1f5f8: 13a04000 movne r4, #0 <== NOT EXECUTED
1f5fc: 03a04001 moveq r4, #1 <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (device);
1f600: 059f3038 ldreq r3, [pc, #56] ; 1f640 <rtems_rfs_rtems_set_handlers+0x7c><== 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))
1f604: 0a000005 beq 1f620 <rtems_rfs_rtems_set_handlers+0x5c> <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
1f608: e3530a0a cmp r3, #40960 ; 0xa000 <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (link);
1f60c: 059f3030 ldreq r3, [pc, #48] ; 1f644 <rtems_rfs_rtems_set_handlers+0x80><== NOT EXECUTED
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);
else if (RTEMS_RFS_S_ISLNK (mode))
1f610: 0a000002 beq 1f620 <rtems_rfs_rtems_set_handlers+0x5c> <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
1f614: e3530902 cmp r3, #32768 ; 0x8000 <== NOT EXECUTED
1f618: 1a000003 bne 1f62c <rtems_rfs_rtems_set_handlers+0x68> <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (file);
1f61c: e59f3024 ldr r3, [pc, #36] ; 1f648 <rtems_rfs_rtems_set_handlers+0x84><== NOT EXECUTED
1f620: e5803008 str r3, [r0, #8] <== NOT EXECUTED
1f624: e3a00001 mov r0, #1 <== NOT EXECUTED
1f628: e8bd8010 pop {r4, pc} <== NOT EXECUTED
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
1f62c: e59f0018 ldr r0, [pc, #24] ; 1f64c <rtems_rfs_rtems_set_handlers+0x88><== NOT EXECUTED
1f630: eb008790 bl 41478 <printf> <== NOT EXECUTED
1f634: e1a00004 mov r0, r4 <== NOT EXECUTED
return false;
}
return true;
}
1f638: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0001e46c <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;
1e46c: 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)
{
1e470: 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);
1e474: 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);
1e478: e593507c ldr r5, [r3, #124] ; 0x7c <== NOT EXECUTED
rc = rtems_rfs_fs_close(fs);
1e47c: eb005eb1 bl 35f48 <rtems_rfs_fs_close> <== NOT EXECUTED
1e480: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_rfs_mutex_destroy (&rtems->access);
1e484: e1a00005 mov r0, r5 <== NOT EXECUTED
1e488: eb0067f8 bl 38470 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
free (rtems);
1e48c: e1a00005 mov r0, r5 <== NOT EXECUTED
1e490: ebffa487 bl 76b4 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("shutdown: close", rc);
1e494: eb007a99 bl 3cf00 <__errno> <== NOT EXECUTED
1e498: e3540000 cmp r4, #0 <== NOT EXECUTED
1e49c: e5804000 str r4, [r0] <== NOT EXECUTED
}
1e4a0: 01a00004 moveq r0, r4 <== NOT EXECUTED
1e4a4: 13e00000 mvnne r0, #0 <== NOT EXECUTED
1e4a8: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
0001ead0 <rtems_rfs_rtems_stat>:
*/
int
rtems_rfs_rtems_stat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
1ead0: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
1ead4: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
1ead8: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
1eadc: e5906000 ldr r6, [r0] <== NOT EXECUTED
*/
int
rtems_rfs_rtems_stat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
1eae0: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED
int rc;
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);
1eae4: e1a00005 mov r0, r5 <== NOT EXECUTED
*/
int
rtems_rfs_rtems_stat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
1eae8: e1a04001 mov r4, r1 <== NOT EXECUTED
int rc;
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);
1eaec: ebfffd7b bl 1e0e0 <rtems_rfs_rtems_lock> <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1eaf0: e1a00005 mov r0, r5 <== NOT EXECUTED
1eaf4: e1a01006 mov r1, r6 <== NOT EXECUTED
1eaf8: e1a0200d mov r2, sp <== NOT EXECUTED
1eafc: e3a03001 mov r3, #1 <== NOT EXECUTED
1eb00: eb00639f bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
1eb04: e2507000 subs r7, r0, #0 <== NOT EXECUTED
1eb08: 0a000004 beq 1eb20 <rtems_rfs_rtems_stat+0x50> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1eb0c: e1a00005 mov r0, r5 <== NOT EXECUTED
1eb10: ebfffd77 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("stat: opening inode", rc);
1eb14: eb0078f9 bl 3cf00 <__errno> <== NOT EXECUTED
1eb18: e5807000 str r7, [r0] <== NOT EXECUTED
1eb1c: ea000089 b 1ed48 <rtems_rfs_rtems_stat+0x278> <== 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);
1eb20: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
}
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
1eb24: e5d23003 ldrb r3, [r2, #3] <== NOT EXECUTED
1eb28: e5d20002 ldrb r0, [r2, #2] <== NOT EXECUTED
1eb2c: e1830400 orr r0, r3, r0, lsl #8 <== NOT EXECUTED
1eb30: e2003a0f and r3, r0, #61440 ; 0xf000 <== NOT EXECUTED
1eb34: e3530a02 cmp r3, #8192 ; 0x2000 <== NOT EXECUTED
1eb38: 13530a06 cmpne r3, #24576 ; 0x6000 <== NOT EXECUTED
1eb3c: 1a000011 bne 1eb88 <rtems_rfs_rtems_stat+0xb8> <== 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]);
1eb40: e282301c add r3, r2, #28 <== NOT EXECUTED
1eb44: e5d38005 ldrb r8, [r3, #5] <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
1eb48: e5d2101c ldrb r1, [r2, #28] <== NOT EXECUTED
1eb4c: e5d3c004 ldrb ip, [r3, #4] <== NOT EXECUTED
1eb50: e5d32003 ldrb r2, [r3, #3] <== NOT EXECUTED
1eb54: e5d3e001 ldrb lr, [r3, #1] <== NOT EXECUTED
1eb58: e5d37007 ldrb r7, [r3, #7] <== NOT EXECUTED
1eb5c: e1a08808 lsl r8, r8, #16 <== NOT EXECUTED
1eb60: e1888c0c orr r8, r8, ip, lsl #24 <== NOT EXECUTED
1eb64: e1822c01 orr r2, r2, r1, lsl #24 <== NOT EXECUTED
1eb68: e5d3c006 ldrb ip, [r3, #6] <== NOT EXECUTED
1eb6c: e5d31002 ldrb r1, [r3, #2] <== NOT EXECUTED
1eb70: e182280e orr r2, r2, lr, lsl #16 <== NOT EXECUTED
1eb74: e1883007 orr r3, r8, r7 <== NOT EXECUTED
1eb78: e183340c orr r3, r3, ip, lsl #8 <== NOT EXECUTED
1eb7c: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED
{
buf->st_rdev =
1eb80: e5842018 str r2, [r4, #24] <== NOT EXECUTED
1eb84: e584301c str r3, [r4, #28] <== NOT EXECUTED
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);
1eb88: e595300c ldr r3, [r5, #12] <== NOT EXECUTED
1eb8c: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
buf->st_ino = ino;
1eb90: 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);
1eb94: e884000c stm r4, {r2, r3} <== NOT EXECUTED
buf->st_ino = ino;
buf->st_mode = rtems_rfs_rtems_mode (mode);
1eb98: eb000288 bl 1f5c0 <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);
1eb9c: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
1eba0: e584000c str r0, [r4, #12] <== NOT EXECUTED
1eba4: e5d31000 ldrb r1, [r3] <== NOT EXECUTED
1eba8: e5d32001 ldrb r2, [r3, #1] <== NOT EXECUTED
1ebac: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED
if (links == 0xffff)
1ebb0: e59f11ac ldr r1, [pc, #428] ; 1ed64 <rtems_rfs_rtems_stat+0x294><== NOT EXECUTED
1ebb4: e1520001 cmp r2, r1 <== NOT EXECUTED
1ebb8: 03a02000 moveq r2, #0 <== NOT EXECUTED
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
1ebbc: e1c421b0 strh r2, [r4, #16] <== NOT EXECUTED
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
1ebc0: e5d31006 ldrb r1, [r3, #6] <== NOT EXECUTED
1ebc4: e5d32007 ldrb r2, [r3, #7] <== NOT EXECUTED
1ebc8: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED
1ebcc: e1c421b2 strh r2, [r4, #18] <== NOT EXECUTED
buf->st_gid = rtems_rfs_inode_get_gid (&inode);
1ebd0: e5d31007 ldrb r1, [r3, #7] <== NOT EXECUTED
1ebd4: e5d30004 ldrb r0, [r3, #4] <== NOT EXECUTED
1ebd8: e5d32005 ldrb r2, [r3, #5] <== NOT EXECUTED
1ebdc: e1813c00 orr r3, r1, r0, lsl #24 <== NOT EXECUTED
1ebe0: e1833802 orr r3, r3, r2, lsl #16 <== NOT EXECUTED
1ebe4: e1a03823 lsr r3, r3, #16 <== 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);
1ebe8: e1a01006 mov r1, r6 <== NOT EXECUTED
buf->st_dev = rtems_rfs_fs_device (fs);
buf->st_ino = ino;
buf->st_mode = rtems_rfs_rtems_mode (mode);
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
buf->st_gid = rtems_rfs_inode_get_gid (&inode);
1ebec: 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);
1ebf0: e1a00005 mov r0, r5 <== NOT EXECUTED
1ebf4: eb005a23 bl 35488 <rtems_rfs_file_get_shared> <== NOT EXECUTED
if (shared)
1ebf8: e2501000 subs r1, r0, #0 <== NOT EXECUTED
1ebfc: e594000c ldr r0, [r4, #12] <== NOT EXECUTED
1ec00: 0a000012 beq 1ec50 <rtems_rfs_rtems_stat+0x180> <== NOT EXECUTED
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
1ec04: e591308c ldr r3, [r1, #140] ; 0x8c <== NOT EXECUTED
1ec08: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
1ec0c: e5913090 ldr r3, [r1, #144] ; 0x90 <== NOT EXECUTED
1ec10: e5843030 str r3, [r4, #48] ; 0x30 <== NOT EXECUTED
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
1ec14: e5913094 ldr r3, [r1, #148] ; 0x94 <== NOT EXECUTED
1ec18: 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))
1ec1c: e2000a0f and r0, r0, #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);
1ec20: e5913084 ldr r3, [r1, #132] ; 0x84 <== NOT EXECUTED
if (S_ISLNK (buf->st_mode))
1ec24: e3500a0a cmp r0, #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);
1ec28: e5843044 str r3, [r4, #68] ; 0x44 <== NOT EXECUTED
if (S_ISLNK (buf->st_mode))
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
1ec2c: 01d138b8 ldrheq r3, [r1, #136] ; 0x88 <== NOT EXECUTED
1ec30: 05843020 streq r3, [r4, #32] <== NOT EXECUTED
1ec34: 03a03000 moveq r3, #0 <== NOT EXECUTED
1ec38: 05843024 streq r3, [r4, #36] ; 0x24 <== NOT EXECUTED
1ec3c: 0a000036 beq 1ed1c <rtems_rfs_rtems_stat+0x24c> <== 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);
1ec40: e1a00005 mov r0, r5 <== NOT EXECUTED
1ec44: e2811084 add r1, r1, #132 ; 0x84 <== NOT EXECUTED
1ec48: eb00526b bl 335fc <rtems_rfs_block_get_size> <== NOT EXECUTED
1ec4c: ea000030 b 1ed14 <rtems_rfs_rtems_stat+0x244> <== 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);
1ec50: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
1ec54: 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);
1ec58: e5d2c003 ldrb ip, [r2, #3] <== NOT EXECUTED
1ec5c: e5d3e010 ldrb lr, [r3, #16] <== NOT EXECUTED
1ec60: e5d26001 ldrb r6, [r2, #1] <== NOT EXECUTED
1ec64: e18cec0e orr lr, ip, lr, lsl #24 <== NOT EXECUTED
1ec68: e5d2c002 ldrb ip, [r2, #2] <== NOT EXECUTED
1ec6c: e18e2806 orr r2, lr, r6, lsl #16 <== NOT EXECUTED
1ec70: e182240c orr r2, r2, ip, lsl #8 <== NOT EXECUTED
1ec74: 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);
1ec78: e2832014 add r2, r3, #20 <== NOT EXECUTED
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
1ec7c: e5d2c003 ldrb ip, [r2, #3] <== NOT EXECUTED
1ec80: e5d3e014 ldrb lr, [r3, #20] <== NOT EXECUTED
1ec84: e5d26001 ldrb r6, [r2, #1] <== NOT EXECUTED
1ec88: e18cec0e orr lr, ip, lr, lsl #24 <== NOT EXECUTED
1ec8c: e5d2c002 ldrb ip, [r2, #2] <== NOT EXECUTED
1ec90: e18e2806 orr r2, lr, r6, lsl #16 <== NOT EXECUTED
1ec94: e182240c orr r2, r2, ip, lsl #8 <== NOT EXECUTED
1ec98: 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);
1ec9c: e2832018 add r2, r3, #24 <== NOT EXECUTED
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
1eca0: e5d2c003 ldrb ip, [r2, #3] <== NOT EXECUTED
1eca4: e5d3e018 ldrb lr, [r3, #24] <== NOT EXECUTED
1eca8: e5d26001 ldrb r6, [r2, #1] <== NOT EXECUTED
1ecac: e18cec0e orr lr, ip, lr, lsl #24 <== NOT EXECUTED
1ecb0: e5d2c002 ldrb ip, [r2, #2] <== NOT EXECUTED
1ecb4: e18e2806 orr r2, lr, r6, lsl #16 <== NOT EXECUTED
1ecb8: e182240c orr r2, r2, ip, lsl #8 <== NOT EXECUTED
1ecbc: 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);
1ecc0: e283200c add r2, r3, #12 <== NOT EXECUTED
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
1ecc4: e5d2c003 ldrb ip, [r2, #3] <== NOT EXECUTED
1ecc8: e5d3e00c ldrb lr, [r3, #12] <== NOT EXECUTED
1eccc: e5d26001 ldrb r6, [r2, #1] <== NOT EXECUTED
1ecd0: e18cec0e orr lr, ip, lr, lsl #24 <== NOT EXECUTED
1ecd4: e5d2c002 ldrb ip, [r2, #2] <== NOT EXECUTED
if (S_ISLNK (buf->st_mode))
1ecd8: e2000a0f and r0, r0, #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);
1ecdc: e18e2806 orr r2, lr, r6, lsl #16 <== NOT EXECUTED
1ece0: e182240c orr r2, r2, ip, lsl #8 <== NOT EXECUTED
if (S_ISLNK (buf->st_mode))
1ece4: e3500a0a cmp r0, #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);
1ece8: e5842044 str r2, [r4, #68] ; 0x44 <== NOT EXECUTED
if (S_ISLNK (buf->st_mode))
1ecec: 1a000005 bne 1ed08 <rtems_rfs_rtems_stat+0x238> <== NOT EXECUTED
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
1ecf0: e5d3200b ldrb r2, [r3, #11] <== NOT EXECUTED
1ecf4: e5d3300a ldrb r3, [r3, #10] <== NOT EXECUTED
1ecf8: e1823403 orr r3, r2, r3, lsl #8 <== NOT EXECUTED
1ecfc: e5843020 str r3, [r4, #32] <== NOT EXECUTED
1ed00: e5841024 str r1, [r4, #36] ; 0x24 <== NOT EXECUTED
1ed04: ea000004 b 1ed1c <rtems_rfs_rtems_stat+0x24c> <== NOT EXECUTED
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
1ed08: e1a00005 mov r0, r5 <== NOT EXECUTED
1ed0c: e1a0100d mov r1, sp <== NOT EXECUTED
1ed10: eb006235 bl 375ec <rtems_rfs_inode_get_size> <== NOT EXECUTED
1ed14: e5840020 str r0, [r4, #32] <== NOT EXECUTED
1ed18: e5841024 str r1, [r4, #36] ; 0x24 <== NOT EXECUTED
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
1ed1c: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
1ed20: e1a00005 mov r0, r5 <== 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);
1ed24: e5843040 str r3, [r4, #64] ; 0x40 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
1ed28: e1a0100d mov r1, sp <== NOT EXECUTED
1ed2c: eb0062f1 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
1ed30: e2504000 subs r4, r0, #0 <== NOT EXECUTED
1ed34: da000005 ble 1ed50 <rtems_rfs_rtems_stat+0x280> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1ed38: e1a00005 mov r0, r5 <== NOT EXECUTED
1ed3c: ebfffcec bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("stat: closing inode", rc);
1ed40: eb00786e bl 3cf00 <__errno> <== NOT EXECUTED
1ed44: e5804000 str r4, [r0] <== NOT EXECUTED
1ed48: e3e00000 mvn r0, #0 <== NOT EXECUTED
1ed4c: ea000002 b 1ed5c <rtems_rfs_rtems_stat+0x28c> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
1ed50: e1a00005 mov r0, r5 <== NOT EXECUTED
1ed54: ebfffce6 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
1ed58: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
}
1ed5c: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
1ed60: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
0001e668 <rtems_rfs_rtems_statvfs>:
* @return int
*/
int
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
1e668: e92d4033 push {r0, r1, r4, r5, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
1e66c: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
1e670: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
1e674: 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);
1e678: e1a0200d mov r2, sp <== NOT EXECUTED
1e67c: e28d1004 add r1, sp, #4 <== NOT EXECUTED
1e680: e1a00005 mov r0, r5 <== NOT EXECUTED
1e684: eb0062a8 bl 3712c <rtems_rfs_group_usage> <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
1e688: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
1e68c: e5843000 str r3, [r4] <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
1e690: e595300c ldr r3, [r5, #12] <== NOT EXECUTED
1e694: e5932024 ldr r2, [r3, #36] ; 0x24 <== NOT EXECUTED
1e698: e5842004 str r2, [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;
1e69c: 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);
1e6a0: e5951010 ldr r1, [r5, #16] <== 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);
1e6a4: e593c01c ldr ip, [r3, #28] <== NOT EXECUTED
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;
sb->f_favail = sb->f_ffree;
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
1e6a8: e59f304c ldr r3, [pc, #76] ; 1e6fc <rtems_rfs_rtems_statvfs+0x94><== 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;
1e6ac: e0622001 rsb r2, r2, r1 <== 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;
1e6b0: 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;
1e6b4: e5842028 str r2, [r4, #40] ; 0x28 <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
1e6b8: 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);
1e6bc: e5841020 str r1, [r4, #32] <== NOT EXECUTED
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
1e6c0: 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);
1e6c4: e5953000 ldr r3, [r5] <== NOT EXECUTED
1e6c8: 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;
1e6cc: 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);
1e6d0: 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;
1e6d4: 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);
1e6d8: 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);
1e6dc: 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);
1e6e0: e584c008 str ip, [r4, #8] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
sb->f_bavail = sb->f_bfree;
1e6e4: 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);
1e6e8: e584000c str r0, [r4, #12] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
1e6ec: e5843010 str r3, [r4, #16] <== NOT EXECUTED
1e6f0: e5840014 str r0, [r4, #20] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
1e6f4: 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;
}
1e6f8: e8bd803c pop {r2, r3, r4, r5, pc} <== NOT EXECUTED
0001edd4 <rtems_rfs_rtems_symlink>:
int
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
const char* link_name,
const char* node_name)
{
1edd4: e92d41ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
1edd8: e1a03000 mov r3, r0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
1eddc: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
1ede0: e5904034 ldr r4, [r0, #52] ; 0x34 <== NOT EXECUTED
int
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
const char* link_name,
const char* node_name)
{
1ede4: e1a07002 mov r7, r2 <== NOT EXECUTED
#else
uid = 0;
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
1ede8: e1a00004 mov r0, r4 <== NOT EXECUTED
int
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
const char* link_name,
const char* node_name)
{
1edec: e1a06001 mov r6, 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);
1edf0: e5935000 ldr r5, [r3] <== NOT EXECUTED
#else
uid = 0;
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
1edf4: ebfffcb9 bl 1e0e0 <rtems_rfs_rtems_lock> <== NOT EXECUTED
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
1edf8: e1a00007 mov r0, r7 <== NOT EXECUTED
1edfc: eb00933c bl 43af4 <strlen> <== NOT EXECUTED
1ee00: e1a08000 mov r8, r0 <== NOT EXECUTED
link_name, strlen (link_name),
1ee04: e1a00006 mov r0, r6 <== NOT EXECUTED
1ee08: eb009339 bl 43af4 <strlen> <== NOT EXECUTED
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
1ee0c: e3a0c000 mov ip, #0 <== NOT EXECUTED
1ee10: e58d0000 str r0, [sp] <== NOT EXECUTED
1ee14: e1a01007 mov r1, r7 <== NOT EXECUTED
1ee18: e1a02008 mov r2, r8 <== NOT EXECUTED
1ee1c: e1a03006 mov r3, r6 <== NOT EXECUTED
1ee20: e1a00004 mov r0, r4 <== NOT EXECUTED
1ee24: e58d500c str r5, [sp, #12] <== NOT EXECUTED
1ee28: e58dc008 str ip, [sp, #8] <== NOT EXECUTED
1ee2c: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
1ee30: eb006435 bl 37f0c <rtems_rfs_symlink> <== NOT EXECUTED
link_name, strlen (link_name),
uid, gid, parent);
if (rc)
1ee34: e2505000 subs r5, r0, #0 <== NOT EXECUTED
1ee38: 0a000005 beq 1ee54 <rtems_rfs_rtems_symlink+0x80> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1ee3c: e1a00004 mov r0, r4 <== NOT EXECUTED
1ee40: ebfffcab bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("symlink: linking", rc);
1ee44: eb00782d bl 3cf00 <__errno> <== NOT EXECUTED
1ee48: e5805000 str r5, [r0] <== NOT EXECUTED
1ee4c: e3e00000 mvn r0, #0 <== NOT EXECUTED
1ee50: ea000002 b 1ee60 <rtems_rfs_rtems_symlink+0x8c> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
1ee54: e1a00004 mov r0, r4 <== NOT EXECUTED
1ee58: ebfffca5 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
1ee5c: e1a00005 mov r0, r5 <== NOT EXECUTED
return 0;
}
1ee60: e28dd010 add sp, sp, #16 <== NOT EXECUTED
1ee64: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
0001e894 <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);
1e894: 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)
{
1e898: e92d40f1 push {r0, r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
1e89c: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
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);
1e8a0: 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);
1e8a4: e5907000 ldr r7, [r0] <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (loc);
1e8a8: e5916000 ldr r6, [r1] <== NOT EXECUTED
uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (loc);
int rc;
rtems_rfs_rtems_lock (fs);
1e8ac: e1a00004 mov r0, r4 <== NOT EXECUTED
1e8b0: ebfffe0a bl 1e0e0 <rtems_rfs_rtems_lock> <== 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);
1e8b4: e1a03005 mov r3, r5 <== NOT EXECUTED
1e8b8: e3a0c000 mov ip, #0 <== NOT EXECUTED
1e8bc: e1a01007 mov r1, r7 <== NOT EXECUTED
1e8c0: e1a02006 mov r2, r6 <== NOT EXECUTED
1e8c4: e1a00004 mov r0, r4 <== NOT EXECUTED
1e8c8: e58dc000 str ip, [sp] <== NOT EXECUTED
1e8cc: eb00660e bl 3810c <rtems_rfs_unlink> <== NOT EXECUTED
if (rc)
1e8d0: e2505000 subs r5, r0, #0 <== NOT EXECUTED
1e8d4: 0a000005 beq 1e8f0 <rtems_rfs_rtems_unlink+0x5c> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1e8d8: e1a00004 mov r0, r4 <== NOT EXECUTED
1e8dc: ebfffe04 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("unlink: unlink inode", rc);
1e8e0: eb007986 bl 3cf00 <__errno> <== NOT EXECUTED
1e8e4: e5805000 str r5, [r0] <== NOT EXECUTED
1e8e8: e3e00000 mvn r0, #0 <== NOT EXECUTED
1e8ec: ea000002 b 1e8fc <rtems_rfs_rtems_unlink+0x68> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
1e8f0: e1a00004 mov r0, r4 <== NOT EXECUTED
1e8f4: ebfffdfe bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
1e8f8: e1a00005 mov r0, r5 <== NOT EXECUTED
return 0;
}
1e8fc: e8bd80f8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
0001e0f4 <rtems_rfs_rtems_unlock>:
/**
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
1e0f4: e92d4010 push {r4, lr} <== NOT EXECUTED
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1e0f8: e590407c ldr r4, [r0, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
1e0fc: eb0058dd bl 34478 <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);
1e100: e5940000 ldr r0, [r4] <== NOT EXECUTED
rtems_rfs_mutex_unlock (&rtems->access);
}
1e104: e8bd4010 pop {r4, lr} <== NOT EXECUTED
1e108: eaffb632 b b9d8 <rtems_semaphore_release> <== NOT EXECUTED
0001e2b0 <rtems_rfs_rtems_utime>:
int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
1e2b0: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
1e2b4: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
1e2b8: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
1e2bc: e5908000 ldr r8, [r0] <== NOT EXECUTED
int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
1e2c0: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
1e2c4: e1a00004 mov r0, r4 <== NOT EXECUTED
int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
1e2c8: e1a06001 mov r6, r1 <== NOT EXECUTED
1e2cc: e1a05002 mov r5, r2 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
1e2d0: ebffff82 bl 1e0e0 <rtems_rfs_rtems_lock> <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1e2d4: e1a01008 mov r1, r8 <== NOT EXECUTED
1e2d8: e1a00004 mov r0, r4 <== NOT EXECUTED
1e2dc: e1a0200d mov r2, sp <== NOT EXECUTED
1e2e0: e3a03001 mov r3, #1 <== NOT EXECUTED
1e2e4: eb0065a6 bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
1e2e8: 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);
1e2ec: e1a0700d mov r7, sp <== NOT EXECUTED
if (rc)
1e2f0: 0a000004 beq 1e308 <rtems_rfs_rtems_utime+0x58> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1e2f4: e1a00004 mov r0, r4 <== NOT EXECUTED
1e2f8: ebffff7d bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("utime: read inode", rc);
1e2fc: eb007aff bl 3cf00 <__errno> <== NOT EXECUTED
1e300: e5808000 str r8, [r0] <== NOT EXECUTED
1e304: ea000020 b 1e38c <rtems_rfs_rtems_utime+0xdc> <== 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);
1e308: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
1e30c: e1a02c26 lsr r2, r6, #24 <== NOT EXECUTED
1e310: e5c32010 strb r2, [r3, #16] <== NOT EXECUTED
1e314: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
1e318: e1a02826 lsr r2, r6, #16 <== NOT EXECUTED
1e31c: e5c32011 strb r2, [r3, #17] <== NOT EXECUTED
1e320: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
1e324: e1a02426 lsr r2, r6, #8 <== NOT EXECUTED
1e328: e5c32012 strb r2, [r3, #18] <== NOT EXECUTED
1e32c: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
1e330: 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);
1e334: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
1e338: e1a02c25 lsr r2, r5, #24 <== NOT EXECUTED
1e33c: e5c32014 strb r2, [r3, #20] <== NOT EXECUTED
1e340: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
1e344: e1a02825 lsr r2, r5, #16 <== NOT EXECUTED
1e348: e5c32015 strb r2, [r3, #21] <== NOT EXECUTED
1e34c: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
1e350: e1a02425 lsr r2, r5, #8 <== NOT EXECUTED
1e354: e5c32016 strb r2, [r3, #22] <== NOT EXECUTED
1e358: 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);
1e35c: e1a0100d mov r1, sp <== NOT EXECUTED
1e360: e5c35017 strb r5, [r3, #23] <== NOT EXECUTED
1e364: e1a00004 mov r0, r4 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1e368: e3a03001 mov r3, #1 <== NOT EXECUTED
1e36c: e5cd3010 strb r3, [sp, #16] <== NOT EXECUTED
1e370: eb006560 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc)
1e374: e2505000 subs r5, r0, #0 <== NOT EXECUTED
1e378: 0a000005 beq 1e394 <rtems_rfs_rtems_utime+0xe4> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1e37c: e1a00004 mov r0, r4 <== NOT EXECUTED
1e380: ebffff5b bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("utime: closing inode", rc);
1e384: eb007add bl 3cf00 <__errno> <== NOT EXECUTED
1e388: e5805000 str r5, [r0] <== NOT EXECUTED
1e38c: e3e00000 mvn r0, #0 <== NOT EXECUTED
1e390: ea000002 b 1e3a0 <rtems_rfs_rtems_utime+0xf0> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
1e394: e1a00004 mov r0, r4 <== NOT EXECUTED
1e398: ebffff55 bl 1e0f4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
1e39c: e1a00005 mov r0, r5 <== NOT EXECUTED
return 0;
}
1e3a0: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
1e3a4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00036460 <rtems_rfs_rup_quotient>:
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
36460: 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)
{
36464: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if (dividend == 0)
36468: 03a00001 moveq r0, #1 <== NOT EXECUTED
3646c: 049df004 popeq {pc} ; (ldreq pc, [sp], #4) <== NOT EXECUTED
return 1;
return ((dividend - 1) / divisor) + 1;
36470: e2400001 sub r0, r0, #1 <== NOT EXECUTED
36474: eb007a5f bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
36478: e2800001 add r0, r0, #1 <== NOT EXECUTED
}
3647c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
000200f4 <rtems_rfs_shell_block>:
uint8_t* data;
bool state;
int b;
int rc;
if (argc <= 1)
200f4: e3510001 cmp r1, #1 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_block (rtems_rfs_file_system* fs, int argc, char *argv[])
{
200f8: e92d41ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
200fc: e1a04000 mov r4, r0 <== NOT EXECUTED
uint8_t* data;
bool state;
int b;
int rc;
if (argc <= 1)
20100: ca000002 bgt 20110 <rtems_rfs_shell_block+0x1c> <== NOT EXECUTED
{
printf ("error: no block number provided\n");
20104: e59f018c ldr r0, [pc, #396] ; 20298 <rtems_rfs_shell_block+0x1a4><== NOT EXECUTED
20108: eb00857f bl 4170c <puts> <== NOT EXECUTED
2010c: ea00003e b 2020c <rtems_rfs_shell_block+0x118> <== NOT EXECUTED
return 1;
}
block = strtoul (argv[1], 0, 0);
20110: e3a01000 mov r1, #0 <== NOT EXECUTED
20114: e5920004 ldr r0, [r2, #4] <== NOT EXECUTED
20118: e1a02001 mov r2, r1 <== NOT EXECUTED
2011c: eb009390 bl 44f64 <strtoul> <== NOT EXECUTED
20120: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
20124: e3a01000 mov r1, #0 <== NOT EXECUTED
20128: e1a02001 mov r2, r1 <== NOT EXECUTED
2012c: e1a06000 mov r6, r0 <== NOT EXECUTED
20130: e5930000 ldr r0, [r3] <== NOT EXECUTED
20134: ebffade1 bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
rtems_rfs_shell_lock_rfs (fs);
rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);
20138: e1a00004 mov r0, r4 <== NOT EXECUTED
2013c: e3a01000 mov r1, #0 <== NOT EXECUTED
20140: e1a02006 mov r2, r6 <== NOT EXECUTED
20144: e28d300f add r3, sp, #15 <== NOT EXECUTED
20148: eb005c1c bl 371c0 <rtems_rfs_group_bitmap_test> <== NOT EXECUTED
if (rc > 0)
2014c: e2505000 subs r5, r0, #0 <== NOT EXECUTED
20150: da000008 ble 20178 <rtems_rfs_shell_block+0x84> <== NOT EXECUTED
{
rtems_rfs_shell_unlock_rfs (fs);
20154: e1a00004 mov r0, r4 <== NOT EXECUTED
20158: ebfffdcb bl 1f88c <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
printf ("error: testing block state: block=%" PRIu32 ": (%d) %s\n",
2015c: e1a00005 mov r0, r5 <== NOT EXECUTED
20160: eb008cd7 bl 434c4 <strerror> <== NOT EXECUTED
20164: e1a01006 mov r1, r6 <== NOT EXECUTED
20168: e1a03000 mov r3, r0 <== NOT EXECUTED
2016c: e1a02005 mov r2, r5 <== NOT EXECUTED
20170: e59f0124 ldr r0, [pc, #292] ; 2029c <rtems_rfs_shell_block+0x1a8><== NOT EXECUTED
20174: ea000023 b 20208 <rtems_rfs_shell_block+0x114> <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
}
printf (" %5" PRIu32 ": block %s\n", block, state ? "allocated" : "free");
20178: e5dd100f ldrb r1, [sp, #15] <== NOT EXECUTED
2017c: e59f311c ldr r3, [pc, #284] ; 202a0 <rtems_rfs_shell_block+0x1ac><== NOT EXECUTED
20180: e3510000 cmp r1, #0 <== NOT EXECUTED
20184: e59f2118 ldr r2, [pc, #280] ; 202a4 <rtems_rfs_shell_block+0x1b0><== NOT EXECUTED
20188: e1a01006 mov r1, r6 <== NOT EXECUTED
2018c: 01a02003 moveq r2, r3 <== NOT EXECUTED
20190: e59f0110 ldr r0, [pc, #272] ; 202a8 <rtems_rfs_shell_block+0x1b4><== NOT EXECUTED
20194: eb0084b7 bl 41478 <printf> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
20198: e3a05000 mov r5, #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);
2019c: e3a03001 mov r3, #1 <== NOT EXECUTED
201a0: e1a02006 mov r2, r6 <== NOT EXECUTED
201a4: e1a00004 mov r0, r4 <== NOT EXECUTED
201a8: e1a0100d mov r1, sp <== NOT EXECUTED
201ac: e5cd5000 strb r5, [sp] <== NOT EXECUTED
handle->bnum = 0;
201b0: e58d5004 str r5, [sp, #4] <== NOT EXECUTED
handle->buffer = NULL;
201b4: e58d5008 str r5, [sp, #8] <== NOT EXECUTED
201b8: eb005148 bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
201bc: e2508000 subs r8, r0, #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);
201c0: d59d3008 ldrle r3, [sp, #8] <== 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);
201c4: e1a0700d mov r7, sp <== 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);
201c8: d5936020 ldrle r6, [r3, #32] <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
201cc: da000020 ble 20254 <rtems_rfs_shell_block+0x160> <== 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);
201d0: e1a0100d mov r1, sp <== NOT EXECUTED
201d4: e1a00004 mov r0, r4 <== NOT EXECUTED
201d8: eb0050f7 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_shell_unlock_rfs (fs);
201dc: e1a00004 mov r0, r4 <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
handle->buffer = NULL;
201e0: e58d5008 str r5, [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;
201e4: e5cd5000 strb r5, [sp] <== NOT EXECUTED
handle->bnum = 0;
201e8: e58d5004 str r5, [sp, #4] <== NOT EXECUTED
201ec: ebfffda6 bl 1f88c <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
201f0: e1a00008 mov r0, r8 <== NOT EXECUTED
201f4: eb008cb2 bl 434c4 <strerror> <== NOT EXECUTED
201f8: e1a03000 mov r3, r0 <== NOT EXECUTED
201fc: e59f00a8 ldr r0, [pc, #168] ; 202ac <rtems_rfs_shell_block+0x1b8><== NOT EXECUTED
20200: e1a01006 mov r1, r6 <== NOT EXECUTED
20204: e1a02008 mov r2, r8 <== NOT EXECUTED
20208: eb00849a bl 41478 <printf> <== NOT EXECUTED
2020c: e3a00001 mov r0, #1 <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
20210: ea00001e b 20290 <rtems_rfs_shell_block+0x19c> <== NOT EXECUTED
for (b = 0, data = rtems_rfs_buffer_data (&buffer);
b < rtems_rfs_fs_block_size (fs);
b++, data++)
{
int mod = b % 16;
if (mod == 0)
20214: e215300f ands r3, r5, #15 <== NOT EXECUTED
20218: 1a000006 bne 20238 <rtems_rfs_shell_block+0x144> <== NOT EXECUTED
{
if (b)
2021c: e3550000 cmp r5, #0 <== NOT EXECUTED
printf ("\n");
20220: 13a0000a movne r0, #10 <== NOT EXECUTED
20224: 1b008508 blne 4164c <putchar> <== NOT EXECUTED
printf ("%04x ", b);
20228: e1a01005 mov r1, r5 <== NOT EXECUTED
2022c: e59f007c ldr r0, [pc, #124] ; 202b0 <rtems_rfs_shell_block+0x1bc><== NOT EXECUTED
20230: eb008490 bl 41478 <printf> <== NOT EXECUTED
20234: ea000002 b 20244 <rtems_rfs_shell_block+0x150> <== NOT EXECUTED
}
if (mod == 8)
20238: e3530008 cmp r3, #8 <== NOT EXECUTED
printf (" ");
2023c: 03a00020 moveq r0, #32 <== NOT EXECUTED
20240: 0b008501 bleq 4164c <putchar> <== NOT EXECUTED
printf ("%02x ", *data);
20244: e7d61005 ldrb r1, [r6, r5] <== NOT EXECUTED
20248: e59f0064 ldr r0, [pc, #100] ; 202b4 <rtems_rfs_shell_block+0x1c0><== NOT EXECUTED
2024c: eb008489 bl 41478 <printf> <== NOT EXECUTED
return 1;
}
for (b = 0, data = rtems_rfs_buffer_data (&buffer);
b < rtems_rfs_fs_block_size (fs);
b++, data++)
20250: e2855001 add r5, r5, #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);
20254: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
20258: e1550003 cmp r5, r3 <== NOT EXECUTED
2025c: 3affffec bcc 20214 <rtems_rfs_shell_block+0x120> <== NOT EXECUTED
if (mod == 8)
printf (" ");
printf ("%02x ", *data);
}
printf ("\n");
20260: e3a0000a mov r0, #10 <== NOT EXECUTED
20264: eb0084f8 bl 4164c <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);
20268: e1a00004 mov r0, r4 <== NOT EXECUTED
2026c: e1a0100d mov r1, sp <== NOT EXECUTED
20270: eb0050d1 bl 345bc <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);
20274: e1a00004 mov r0, r4 <== NOT EXECUTED
handle->dirty = false;
20278: e3a04000 mov r4, #0 <== NOT EXECUTED
2027c: e5cd4000 strb r4, [sp] <== NOT EXECUTED
handle->bnum = 0;
20280: e58d4004 str r4, [sp, #4] <== NOT EXECUTED
handle->buffer = NULL;
20284: e58d4008 str r4, [sp, #8] <== NOT EXECUTED
20288: ebfffd7f bl 1f88c <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
2028c: e1a00004 mov r0, r4 <== NOT EXECUTED
return 0;
}
20290: e28dd010 add sp, sp, #16 <== NOT EXECUTED
20294: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
000202b8 <rtems_rfs_shell_data>:
return rc;
}
static int
rtems_rfs_shell_data (rtems_rfs_file_system* fs, int argc, char *argv[])
{
202b8: e92d40f3 push {r0, r1, r4, r5, r6, r7, lr} <== NOT EXECUTED
202bc: e1a04000 mov r4, r0 <== NOT EXECUTED
size_t blocks;
size_t inodes;
int bpcent;
int ipcent;
printf ("RFS Filesystem Data\n");
202c0: e59f01a8 ldr r0, [pc, #424] ; 20470 <rtems_rfs_shell_data+0x1b8><== NOT EXECUTED
202c4: eb008510 bl 4170c <puts> <== NOT EXECUTED
printf (" flags: %08" PRIx32 "\n", fs->flags);
202c8: e5941000 ldr r1, [r4] <== NOT EXECUTED
202cc: e59f01a0 ldr r0, [pc, #416] ; 20474 <rtems_rfs_shell_data+0x1bc><== NOT EXECUTED
202d0: eb008468 bl 41478 <printf> <== NOT EXECUTED
#if 0
printf (" device: %08lx\n", rtems_rfs_fs_device (fs));
#endif
printf (" blocks: %zu\n", rtems_rfs_fs_blocks (fs));
202d4: e5941004 ldr r1, [r4, #4] <== NOT EXECUTED
202d8: e59f0198 ldr r0, [pc, #408] ; 20478 <rtems_rfs_shell_data+0x1c0><== NOT EXECUTED
202dc: eb008465 bl 41478 <printf> <== NOT EXECUTED
printf (" block size: %zu\n", rtems_rfs_fs_block_size (fs));
202e0: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED
202e4: e59f0190 ldr r0, [pc, #400] ; 2047c <rtems_rfs_shell_data+0x1c4><== NOT EXECUTED
202e8: eb008462 bl 41478 <printf> <== NOT EXECUTED
printf (" size: %" PRIu64 "\n", rtems_rfs_fs_size (fs));
202ec: e1a00004 mov r0, r4 <== NOT EXECUTED
202f0: eb005705 bl 35f0c <rtems_rfs_fs_size> <== NOT EXECUTED
202f4: e1a02001 mov r2, r1 <== NOT EXECUTED
202f8: e1a01000 mov r1, r0 <== NOT EXECUTED
202fc: e59f017c ldr r0, [pc, #380] ; 20480 <rtems_rfs_shell_data+0x1c8><== NOT EXECUTED
20300: eb00845c bl 41478 <printf> <== NOT EXECUTED
printf (" media block size: %" PRIu32 "\n", rtems_rfs_fs_media_block_size (fs));
20304: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
20308: e59f0174 ldr r0, [pc, #372] ; 20484 <rtems_rfs_shell_data+0x1cc><== NOT EXECUTED
2030c: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED
20310: eb008458 bl 41478 <printf> <== NOT EXECUTED
printf (" media size: %" PRIu64 "\n", rtems_rfs_fs_media_size (fs));
20314: e1a00004 mov r0, r4 <== NOT EXECUTED
20318: eb005702 bl 35f28 <rtems_rfs_fs_media_size> <== NOT EXECUTED
2031c: e1a02001 mov r2, r1 <== NOT EXECUTED
20320: e1a01000 mov r1, r0 <== NOT EXECUTED
20324: e59f015c ldr r0, [pc, #348] ; 20488 <rtems_rfs_shell_data+0x1d0><== NOT EXECUTED
20328: eb008452 bl 41478 <printf> <== NOT EXECUTED
printf (" inodes: %" PRIu32 "\n", rtems_rfs_fs_inodes (fs));
2032c: e5941010 ldr r1, [r4, #16] <== NOT EXECUTED
20330: e59f0154 ldr r0, [pc, #340] ; 2048c <rtems_rfs_shell_data+0x1d4><== NOT EXECUTED
20334: eb00844f bl 41478 <printf> <== NOT EXECUTED
printf (" bad blocks: %" PRIu32 "\n", fs->bad_blocks);
20338: e5941014 ldr r1, [r4, #20] <== NOT EXECUTED
2033c: e59f014c ldr r0, [pc, #332] ; 20490 <rtems_rfs_shell_data+0x1d8><== NOT EXECUTED
20340: eb00844c bl 41478 <printf> <== NOT EXECUTED
printf (" max. name length: %" PRIu32 "\n", rtems_rfs_fs_max_name (fs));
20344: e5941018 ldr r1, [r4, #24] <== NOT EXECUTED
20348: e59f0144 ldr r0, [pc, #324] ; 20494 <rtems_rfs_shell_data+0x1dc><== NOT EXECUTED
2034c: eb008449 bl 41478 <printf> <== NOT EXECUTED
printf (" groups: %d\n", fs->group_count);
20350: e5941020 ldr r1, [r4, #32] <== NOT EXECUTED
20354: e59f013c ldr r0, [pc, #316] ; 20498 <rtems_rfs_shell_data+0x1e0><== NOT EXECUTED
20358: eb008446 bl 41478 <printf> <== NOT EXECUTED
printf (" group blocks: %zd\n", fs->group_blocks);
2035c: e5941024 ldr r1, [r4, #36] ; 0x24 <== NOT EXECUTED
20360: e59f0134 ldr r0, [pc, #308] ; 2049c <rtems_rfs_shell_data+0x1e4><== NOT EXECUTED
20364: eb008443 bl 41478 <printf> <== NOT EXECUTED
printf (" group inodes: %zd\n", fs->group_inodes);
20368: e5941028 ldr r1, [r4, #40] ; 0x28 <== NOT EXECUTED
2036c: e59f012c ldr r0, [pc, #300] ; 204a0 <rtems_rfs_shell_data+0x1e8><== NOT EXECUTED
20370: eb008440 bl 41478 <printf> <== NOT EXECUTED
printf (" inodes per block: %zd\n", fs->inodes_per_block);
20374: e594102c ldr r1, [r4, #44] ; 0x2c <== NOT EXECUTED
20378: e59f0124 ldr r0, [pc, #292] ; 204a4 <rtems_rfs_shell_data+0x1ec><== NOT EXECUTED
2037c: eb00843d bl 41478 <printf> <== NOT EXECUTED
printf (" blocks per block: %zd\n", fs->blocks_per_block);
20380: e5941030 ldr r1, [r4, #48] ; 0x30 <== NOT EXECUTED
20384: e59f011c ldr r0, [pc, #284] ; 204a8 <rtems_rfs_shell_data+0x1f0><== NOT EXECUTED
20388: eb00843a bl 41478 <printf> <== NOT EXECUTED
printf (" singly blocks: %zd\n", fs->block_map_singly_blocks);
2038c: e5941034 ldr r1, [r4, #52] ; 0x34 <== NOT EXECUTED
20390: e59f0114 ldr r0, [pc, #276] ; 204ac <rtems_rfs_shell_data+0x1f4><== NOT EXECUTED
20394: eb008437 bl 41478 <printf> <== NOT EXECUTED
printf (" doublly blocks: %zd\n", fs->block_map_doubly_blocks);
20398: e5941038 ldr r1, [r4, #56] ; 0x38 <== NOT EXECUTED
2039c: e59f010c ldr r0, [pc, #268] ; 204b0 <rtems_rfs_shell_data+0x1f8><== NOT EXECUTED
203a0: eb008434 bl 41478 <printf> <== NOT EXECUTED
printf (" max. held buffers: %" PRId32 "\n", fs->max_held_buffers);
203a4: e594103c ldr r1, [r4, #60] ; 0x3c <== NOT EXECUTED
203a8: e59f0104 ldr r0, [pc, #260] ; 204b4 <rtems_rfs_shell_data+0x1fc><== NOT EXECUTED
203ac: eb008431 bl 41478 <printf> <== NOT EXECUTED
203b0: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
203b4: e3a01000 mov r1, #0 <== NOT EXECUTED
203b8: e5930000 ldr r0, [r3] <== NOT EXECUTED
203bc: e1a02001 mov r2, r1 <== NOT EXECUTED
203c0: ebffad3e bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
rtems_rfs_shell_lock_rfs (fs);
rtems_rfs_group_usage (fs, &blocks, &inodes);
203c4: e1a0200d mov r2, sp <== NOT EXECUTED
203c8: e28d1004 add r1, sp, #4 <== NOT EXECUTED
203cc: e1a00004 mov r0, r4 <== NOT EXECUTED
203d0: eb005b55 bl 3712c <rtems_rfs_group_usage> <== NOT EXECUTED
rtems_rfs_shell_unlock_rfs (fs);
203d4: e1a00004 mov r0, r4 <== NOT EXECUTED
203d8: ebfffd2b bl 1f88c <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
bpcent = (blocks * 1000) / rtems_rfs_fs_blocks (fs);
203dc: e59d5004 ldr r5, [sp, #4] <== NOT EXECUTED
203e0: e3a07ffa mov r7, #1000 ; 0x3e8 <== NOT EXECUTED
203e4: e5941004 ldr r1, [r4, #4] <== NOT EXECUTED
203e8: e0000597 mul r0, r7, r5 <== NOT EXECUTED
203ec: eb00d281 bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
203f0: e1a06000 mov r6, r0 <== NOT EXECUTED
ipcent = (inodes * 1000) / rtems_rfs_fs_inodes (fs);
203f4: e59d0000 ldr r0, [sp] <== NOT EXECUTED
203f8: e5941010 ldr r1, [r4, #16] <== NOT EXECUTED
203fc: e0000097 mul r0, r7, r0 <== NOT EXECUTED
20400: eb00d27c bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
printf (" blocks used: %zd (%d.%d%%)\n",
20404: e3a0100a mov r1, #10 <== 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);
20408: e1a04000 mov r4, r0 <== NOT EXECUTED
printf (" blocks used: %zd (%d.%d%%)\n",
2040c: e1a00006 mov r0, r6 <== NOT EXECUTED
20410: eb00d2bc bl 54f08 <__aeabi_idiv> <== NOT EXECUTED
20414: e3a0100a mov r1, #10 <== NOT EXECUTED
20418: e1a07000 mov r7, r0 <== NOT EXECUTED
2041c: e1a00006 mov r0, r6 <== NOT EXECUTED
20420: eb00d33b bl 55114 <__modsi3> <== NOT EXECUTED
20424: e1a02007 mov r2, r7 <== NOT EXECUTED
20428: e1a03000 mov r3, r0 <== NOT EXECUTED
2042c: e1a01005 mov r1, r5 <== NOT EXECUTED
20430: e59f0080 ldr r0, [pc, #128] ; 204b8 <rtems_rfs_shell_data+0x200><== NOT EXECUTED
20434: eb00840f bl 41478 <printf> <== NOT EXECUTED
blocks, bpcent / 10, bpcent % 10);
printf (" inodes used: %zd (%d.%d%%)\n",
20438: e1a00004 mov r0, r4 <== NOT EXECUTED
2043c: e3a0100a mov r1, #10 <== NOT EXECUTED
20440: eb00d2b0 bl 54f08 <__aeabi_idiv> <== NOT EXECUTED
20444: e3a0100a mov r1, #10 <== NOT EXECUTED
20448: e1a05000 mov r5, r0 <== NOT EXECUTED
2044c: e1a00004 mov r0, r4 <== NOT EXECUTED
20450: eb00d32f bl 55114 <__modsi3> <== NOT EXECUTED
20454: e1a02005 mov r2, r5 <== NOT EXECUTED
20458: e1a03000 mov r3, r0 <== NOT EXECUTED
2045c: e59d1000 ldr r1, [sp] <== NOT EXECUTED
20460: e59f0054 ldr r0, [pc, #84] ; 204bc <rtems_rfs_shell_data+0x204><== NOT EXECUTED
20464: eb008403 bl 41478 <printf> <== NOT EXECUTED
inodes, ipcent / 10, ipcent % 10);
return 0;
}
20468: e3a00000 mov r0, #0 <== NOT EXECUTED
2046c: e8bd80fc pop {r2, r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
0001fe44 <rtems_rfs_shell_dir>:
return 0;
}
static int
rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[])
{
1fe44: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
bool state;
int entry;
int b;
int rc;
if (argc <= 1)
1fe48: e3510001 cmp r1, #1 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[])
{
1fe4c: e24dd020 sub sp, sp, #32 <== NOT EXECUTED
1fe50: e1a05000 mov r5, r0 <== NOT EXECUTED
bool state;
int entry;
int b;
int rc;
if (argc <= 1)
1fe54: ca000002 bgt 1fe64 <rtems_rfs_shell_dir+0x20> <== NOT EXECUTED
{
printf ("error: no block number provided\n");
1fe58: e59f0268 ldr r0, [pc, #616] ; 200c8 <rtems_rfs_shell_dir+0x284><== NOT EXECUTED
1fe5c: eb00862a bl 4170c <puts> <== NOT EXECUTED
1fe60: ea00003c b 1ff58 <rtems_rfs_shell_dir+0x114> <== NOT EXECUTED
return 1;
}
block = strtoul (argv[1], 0, 0);
1fe64: e3a01000 mov r1, #0 <== NOT EXECUTED
1fe68: e5920004 ldr r0, [r2, #4] <== NOT EXECUTED
1fe6c: e1a02001 mov r2, r1 <== NOT EXECUTED
1fe70: eb00943b bl 44f64 <strtoul> <== NOT EXECUTED
1fe74: e595307c ldr r3, [r5, #124] ; 0x7c <== NOT EXECUTED
1fe78: e3a01000 mov r1, #0 <== NOT EXECUTED
1fe7c: e1a02001 mov r2, r1 <== NOT EXECUTED
1fe80: e1a04000 mov r4, r0 <== NOT EXECUTED
1fe84: e5930000 ldr r0, [r3] <== NOT EXECUTED
1fe88: ebffae8c bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
rtems_rfs_shell_lock_rfs (fs);
rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);
1fe8c: e1a00005 mov r0, r5 <== NOT EXECUTED
1fe90: e3a01000 mov r1, #0 <== NOT EXECUTED
1fe94: e1a02004 mov r2, r4 <== NOT EXECUTED
1fe98: e28d301f add r3, sp, #31 <== NOT EXECUTED
1fe9c: eb005cc7 bl 371c0 <rtems_rfs_group_bitmap_test> <== NOT EXECUTED
if (rc > 0)
1fea0: e2506000 subs r6, r0, #0 <== NOT EXECUTED
1fea4: da000008 ble 1fecc <rtems_rfs_shell_dir+0x88> <== NOT EXECUTED
{
rtems_rfs_shell_unlock_rfs (fs);
1fea8: e1a00005 mov r0, r5 <== NOT EXECUTED
1feac: ebfffe76 bl 1f88c <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
printf ("error: testing block state: block=%" PRIu32 ": (%d) %s\n",
1feb0: e1a00006 mov r0, r6 <== NOT EXECUTED
1feb4: eb008d82 bl 434c4 <strerror> <== NOT EXECUTED
1feb8: e1a01004 mov r1, r4 <== NOT EXECUTED
1febc: e1a03000 mov r3, r0 <== NOT EXECUTED
1fec0: e1a02006 mov r2, r6 <== NOT EXECUTED
1fec4: e59f0200 ldr r0, [pc, #512] ; 200cc <rtems_rfs_shell_dir+0x288><== NOT EXECUTED
1fec8: ea000021 b 1ff54 <rtems_rfs_shell_dir+0x110> <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
}
printf (" %5" PRIu32 ": block %s\n", block, state ? "allocated" : "free");
1fecc: e5dd101f ldrb r1, [sp, #31] <== NOT EXECUTED
1fed0: e59f31f8 ldr r3, [pc, #504] ; 200d0 <rtems_rfs_shell_dir+0x28c><== NOT EXECUTED
1fed4: e3510000 cmp r1, #0 <== NOT EXECUTED
1fed8: e59f21f4 ldr r2, [pc, #500] ; 200d4 <rtems_rfs_shell_dir+0x290><== NOT EXECUTED
1fedc: e1a01004 mov r1, r4 <== NOT EXECUTED
1fee0: 01a02003 moveq r2, r3 <== NOT EXECUTED
1fee4: e59f01ec ldr r0, [pc, #492] ; 200d8 <rtems_rfs_shell_dir+0x294><== 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);
1fee8: e28d6010 add r6, sp, #16 <== 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");
1feec: eb008561 bl 41478 <printf> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
1fef0: 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);
1fef4: e1a00005 mov r0, r5 <== NOT EXECUTED
1fef8: e1a01006 mov r1, r6 <== NOT EXECUTED
1fefc: e1a02004 mov r2, r4 <== NOT EXECUTED
1ff00: e3a03001 mov r3, #1 <== NOT EXECUTED
1ff04: e5cd8010 strb r8, [sp, #16] <== NOT EXECUTED
handle->bnum = 0;
1ff08: e58d8014 str r8, [sp, #20] <== NOT EXECUTED
handle->buffer = NULL;
1ff0c: e58d8018 str r8, [sp, #24] <== NOT EXECUTED
1ff10: eb0051f2 bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
1ff14: e2507000 subs r7, r0, #0 <== NOT EXECUTED
1ff18: da000010 ble 1ff60 <rtems_rfs_shell_dir+0x11c> <== 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);
1ff1c: e1a01006 mov r1, r6 <== NOT EXECUTED
1ff20: e1a00005 mov r0, r5 <== NOT EXECUTED
1ff24: eb0051a4 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_shell_unlock_rfs (fs);
1ff28: e1a00005 mov r0, r5 <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
handle->buffer = NULL;
1ff2c: 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;
1ff30: e5cd8010 strb r8, [sp, #16] <== NOT EXECUTED
handle->bnum = 0;
1ff34: e58d8014 str r8, [sp, #20] <== NOT EXECUTED
1ff38: ebfffe53 bl 1f88c <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
1ff3c: e1a00007 mov r0, r7 <== NOT EXECUTED
1ff40: eb008d5f bl 434c4 <strerror> <== NOT EXECUTED
1ff44: e1a03000 mov r3, r0 <== NOT EXECUTED
1ff48: e59f018c ldr r0, [pc, #396] ; 200dc <rtems_rfs_shell_dir+0x298><== NOT EXECUTED
1ff4c: e1a01004 mov r1, r4 <== NOT EXECUTED
1ff50: e1a02007 mov r2, r7 <== NOT EXECUTED
1ff54: eb008547 bl 41478 <printf> <== NOT EXECUTED
1ff58: e3a00001 mov r0, #1 <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
1ff5c: ea000057 b 200c0 <rtems_rfs_shell_dir+0x27c> <== NOT EXECUTED
}
b = 0;
entry = 1;
data = rtems_rfs_buffer_data (&buffer);
1ff60: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
1ff64: e3a07001 mov r7, #1 <== NOT EXECUTED
1ff68: e5934020 ldr r4, [r3, #32] <== NOT EXECUTED
int c;
eino = rtems_rfs_dir_entry_ino (data);
elength = rtems_rfs_dir_entry_length (data);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1ff6c: e59f916c ldr r9, [pc, #364] ; 200e0 <rtems_rfs_shell_dir+0x29c><== 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))
1ff70: ea000044 b 20088 <rtems_rfs_shell_dir+0x244> <== NOT EXECUTED
int elength;
int length;
int c;
eino = rtems_rfs_dir_entry_ino (data);
elength = rtems_rfs_dir_entry_length (data);
1ff74: e5d43009 ldrb r3, [r4, #9] <== NOT EXECUTED
1ff78: e5d46008 ldrb r6, [r4, #8] <== NOT EXECUTED
1ff7c: e1836406 orr r6, r3, r6, lsl #8 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1ff80: e1560009 cmp r6, r9 <== NOT EXECUTED
rtems_rfs_ino eino;
int elength;
int length;
int c;
eino = rtems_rfs_dir_entry_ino (data);
1ff84: e5d40000 ldrb r0, [r4] <== NOT EXECUTED
1ff88: e5d41001 ldrb r1, [r4, #1] <== NOT EXECUTED
1ff8c: e5d42002 ldrb r2, [r4, #2] <== NOT EXECUTED
1ff90: e5d43003 ldrb r3, [r4, #3] <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (data);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1ff94: 0a00003f beq 20098 <rtems_rfs_shell_dir+0x254> <== NOT EXECUTED
break;
if ((elength < RTEMS_RFS_DIR_ENTRY_SIZE) ||
1ff98: e3560009 cmp r6, #9 <== NOT EXECUTED
1ff9c: da000002 ble 1ffac <rtems_rfs_shell_dir+0x168> <== NOT EXECUTED
(elength >= rtems_rfs_fs_max_name (fs)))
1ffa0: e595c018 ldr ip, [r5, #24] <== NOT EXECUTED
1ffa4: e156000c cmp r6, ip <== NOT EXECUTED
1ffa8: 3a000003 bcc 1ffbc <rtems_rfs_shell_dir+0x178> <== NOT EXECUTED
{
printf (" %5d: entry length appears corrupt: %d\n", entry, elength);
1ffac: e1a01007 mov r1, r7 <== NOT EXECUTED
1ffb0: e1a02006 mov r2, r6 <== NOT EXECUTED
1ffb4: e59f0128 ldr r0, [pc, #296] ; 200e4 <rtems_rfs_shell_dir+0x2a0><== NOT EXECUTED
1ffb8: ea000009 b 1ffe4 <rtems_rfs_shell_dir+0x1a0> <== NOT EXECUTED
rtems_rfs_ino eino;
int elength;
int length;
int c;
eino = rtems_rfs_dir_entry_ino (data);
1ffbc: e1833c00 orr r3, r3, r0, lsl #24 <== NOT EXECUTED
1ffc0: e1833801 orr r3, r3, r1, lsl #16 <== 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)))
1ffc4: e1933402 orrs r3, r3, r2, lsl #8 <== NOT EXECUTED
1ffc8: 0a000002 beq 1ffd8 <rtems_rfs_shell_dir+0x194> <== NOT EXECUTED
1ffcc: e5952010 ldr r2, [r5, #16] <== NOT EXECUTED
1ffd0: e1530002 cmp r3, r2 <== NOT EXECUTED
1ffd4: 3a000004 bcc 1ffec <rtems_rfs_shell_dir+0x1a8> <== NOT EXECUTED
{
printf (" %5d: entry ino appears corrupt: ino=%" PRId32 "\n", entry, eino);
1ffd8: e59f0108 ldr r0, [pc, #264] ; 200e8 <rtems_rfs_shell_dir+0x2a4><== NOT EXECUTED
1ffdc: e1a01007 mov r1, r7 <== NOT EXECUTED
1ffe0: e1a02003 mov r2, r3 <== NOT EXECUTED
1ffe4: eb008523 bl 41478 <printf> <== NOT EXECUTED
break;
1ffe8: ea00002a b 20098 <rtems_rfs_shell_dir+0x254> <== NOT EXECUTED
}
length = elength - RTEMS_RFS_DIR_ENTRY_SIZE;
printf (" %5d: %04x inode=%-6" PRIu32 " hash=%08" PRIx32 " name[%03u]=",
1ffec: e5d4c005 ldrb ip, [r4, #5] <== NOT EXECUTED
1fff0: e5d42004 ldrb r2, [r4, #4] <== NOT EXECUTED
1fff4: e5d41007 ldrb r1, [r4, #7] <== NOT EXECUTED
1fff8: e1a0c80c lsl ip, ip, #16 <== NOT EXECUTED
1fffc: e18ccc02 orr ip, ip, r2, lsl #24 <== NOT EXECUTED
20000: e5d42006 ldrb r2, [r4, #6] <== NOT EXECUTED
20004: e18cc001 orr ip, ip, r1 <== NOT EXECUTED
20008: e18cc402 orr ip, ip, r2, lsl #8 <== NOT EXECUTED
{
printf (" %5d: entry ino appears corrupt: ino=%" PRId32 "\n", entry, eino);
break;
}
length = elength - RTEMS_RFS_DIR_ENTRY_SIZE;
2000c: e246a00a sub sl, r6, #10 <== NOT EXECUTED
printf (" %5d: %04x inode=%-6" PRIu32 " hash=%08" PRIx32 " name[%03u]=",
20010: e1a02008 mov r2, r8 <== NOT EXECUTED
20014: e59f00d0 ldr r0, [pc, #208] ; 200ec <rtems_rfs_shell_dir+0x2a8><== NOT EXECUTED
20018: e1a01007 mov r1, r7 <== NOT EXECUTED
2001c: e58dc000 str ip, [sp] <== NOT EXECUTED
20020: e58da004 str sl, [sp, #4] <== NOT EXECUTED
20024: e3a0b000 mov fp, #0 <== NOT EXECUTED
20028: eb008512 bl 41478 <printf> <== NOT EXECUTED
2002c: e35a0032 cmp sl, #50 ; 0x32 <== NOT EXECUTED
20030: b1a0200a movlt r2, sl <== NOT EXECUTED
20034: a3a02032 movge r2, #50 ; 0x32 <== NOT EXECUTED
20038: e1a03004 mov r3, r4 <== NOT EXECUTED
length);
if (length > 50)
length = 50;
for (c = 0; c < length; c++)
2003c: ea000006 b 2005c <rtems_rfs_shell_dir+0x218> <== NOT EXECUTED
printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);
20040: e5d30009 ldrb r0, [r3, #9] <== NOT EXECUTED
20044: e58d200c str r2, [sp, #12] <== NOT EXECUTED
20048: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
2004c: eb00857e bl 4164c <putchar> <== NOT EXECUTED
length);
if (length > 50)
length = 50;
for (c = 0; c < length; c++)
20050: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
20054: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
20058: e28bb001 add fp, fp, #1 <== NOT EXECUTED
2005c: e15b0002 cmp fp, r2 <== NOT EXECUTED
20060: e2833001 add r3, r3, #1 <== NOT EXECUTED
20064: bafffff5 blt 20040 <rtems_rfs_shell_dir+0x1fc> <== NOT EXECUTED
printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);
if (length < elength - RTEMS_RFS_DIR_ENTRY_SIZE)
20068: e152000a cmp r2, sl <== NOT EXECUTED
printf ("...");
2006c: b59f007c ldrlt r0, [pc, #124] ; 200f0 <rtems_rfs_shell_dir+0x2ac><== NOT EXECUTED
20070: bb008500 bllt 41478 <printf> <== NOT EXECUTED
printf ("\n");
20074: e3a0000a mov r0, #10 <== NOT EXECUTED
20078: eb008573 bl 4164c <putchar> <== NOT EXECUTED
b += elength;
data += elength;
2007c: e0844006 add r4, r4, r6 <== NOT EXECUTED
printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);
if (length < elength - RTEMS_RFS_DIR_ENTRY_SIZE)
printf ("...");
printf ("\n");
b += elength;
20080: e0888006 add r8, r8, r6 <== NOT EXECUTED
data += elength;
entry++;
20084: e2877001 add r7, r7, #1 <== 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))
20088: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
2008c: e243300b sub r3, r3, #11 <== NOT EXECUTED
20090: e1580003 cmp r8, r3 <== NOT EXECUTED
20094: 3affffb6 bcc 1ff74 <rtems_rfs_shell_dir+0x130> <== 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);
20098: e28d1010 add r1, sp, #16 <== NOT EXECUTED
2009c: e1a00005 mov r0, r5 <== NOT EXECUTED
200a0: eb005145 bl 345bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
200a4: 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);
200a8: e1a00005 mov r0, r5 <== NOT EXECUTED
200ac: e5cd4010 strb r4, [sp, #16] <== NOT EXECUTED
handle->bnum = 0;
200b0: e58d4014 str r4, [sp, #20] <== NOT EXECUTED
handle->buffer = NULL;
200b4: e58d4018 str r4, [sp, #24] <== NOT EXECUTED
200b8: ebfffdf3 bl 1f88c <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
200bc: e1a00004 mov r0, r4 <== NOT EXECUTED
return 0;
}
200c0: e28dd020 add sp, sp, #32 <== NOT EXECUTED
200c4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0001fcd8 <rtems_rfs_shell_group>:
int g;
start = 0;
end = fs->group_count - 1;
switch (argc)
1fcd8: e3510002 cmp r1, #2 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
{
1fcdc: e92d4fff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, lr}<== NOT EXECUTED
1fce0: e1a04000 mov r4, r0 <== NOT EXECUTED
1fce4: e1a07002 mov r7, r2 <== NOT EXECUTED
int start;
int end;
int g;
start = 0;
end = fs->group_count - 1;
1fce8: e5905020 ldr r5, [r0, #32] <== NOT EXECUTED
switch (argc)
1fcec: 0a000004 beq 1fd04 <rtems_rfs_shell_group+0x2c> <== NOT EXECUTED
1fcf0: e3510003 cmp r1, #3 <== NOT EXECUTED
1fcf4: 0a000009 beq 1fd20 <rtems_rfs_shell_group+0x48> <== NOT EXECUTED
1fcf8: e3510001 cmp r1, #1 <== NOT EXECUTED
1fcfc: 1a000012 bne 1fd4c <rtems_rfs_shell_group+0x74> <== NOT EXECUTED
1fd00: ea000014 b 1fd58 <rtems_rfs_shell_group+0x80> <== NOT EXECUTED
{
case 1:
break;
case 2:
start = end = strtoul (argv[1], 0, 0);
1fd04: e3a01000 mov r1, #0 <== NOT EXECUTED
1fd08: e5920004 ldr r0, [r2, #4] <== NOT EXECUTED
1fd0c: e1a02001 mov r2, r1 <== NOT EXECUTED
1fd10: eb009493 bl 44f64 <strtoul> <== NOT EXECUTED
1fd14: e1a05000 mov r5, r0 <== NOT EXECUTED
1fd18: e1a06000 mov r6, r0 <== NOT EXECUTED
break;
1fd1c: ea00000f b 1fd60 <rtems_rfs_shell_group+0x88> <== NOT EXECUTED
case 3:
start = strtoul (argv[1], 0, 0);
1fd20: e3a01000 mov r1, #0 <== NOT EXECUTED
1fd24: e1a02001 mov r2, r1 <== NOT EXECUTED
1fd28: e5970004 ldr r0, [r7, #4] <== NOT EXECUTED
1fd2c: eb00948c bl 44f64 <strtoul> <== NOT EXECUTED
end = strtoul (argv[2], 0, 0);
1fd30: e3a01000 mov r1, #0 <== NOT EXECUTED
break;
case 2:
start = end = strtoul (argv[1], 0, 0);
break;
case 3:
start = strtoul (argv[1], 0, 0);
1fd34: e1a06000 mov r6, r0 <== NOT EXECUTED
end = strtoul (argv[2], 0, 0);
1fd38: e1a02001 mov r2, r1 <== NOT EXECUTED
1fd3c: e5970008 ldr r0, [r7, #8] <== NOT EXECUTED
1fd40: eb009487 bl 44f64 <strtoul> <== NOT EXECUTED
1fd44: e1a05000 mov r5, r0 <== NOT EXECUTED
break;
1fd48: ea000004 b 1fd60 <rtems_rfs_shell_group+0x88> <== NOT EXECUTED
default:
printf ("error: too many arguments.\n");
1fd4c: e59f00e4 ldr r0, [pc, #228] ; 1fe38 <rtems_rfs_shell_group+0x160><== NOT EXECUTED
1fd50: eb00866d bl 4170c <puts> <== NOT EXECUTED
1fd54: ea00000c b 1fd8c <rtems_rfs_shell_group+0xb4> <== NOT EXECUTED
int start;
int end;
int g;
start = 0;
end = fs->group_count - 1;
1fd58: e2455001 sub r5, r5, #1 <== NOT EXECUTED
1fd5c: e3a06000 mov r6, #0 <== NOT EXECUTED
default:
printf ("error: too many arguments.\n");
return 1;
}
if ((start < 0) || (end < 0) ||
1fd60: e1a01fa6 lsr r1, r6, #31 <== NOT EXECUTED
1fd64: e1911fa5 orrs r1, r1, r5, lsr #31 <== NOT EXECUTED
1fd68: 1a000004 bne 1fd80 <rtems_rfs_shell_group+0xa8> <== NOT EXECUTED
(start >= fs->group_count) || (end >= fs->group_count))
1fd6c: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED
default:
printf ("error: too many arguments.\n");
return 1;
}
if ((start < 0) || (end < 0) ||
1fd70: e1560003 cmp r6, r3 <== NOT EXECUTED
1fd74: aa000001 bge 1fd80 <rtems_rfs_shell_group+0xa8> <== NOT EXECUTED
1fd78: e1550003 cmp r5, r3 <== NOT EXECUTED
1fd7c: ba000004 blt 1fd94 <rtems_rfs_shell_group+0xbc> <== NOT EXECUTED
(start >= fs->group_count) || (end >= fs->group_count))
{
printf ("error: group out of range (0->%d).\n", fs->group_count);
1fd80: e5941020 ldr r1, [r4, #32] <== NOT EXECUTED
1fd84: e59f00b0 ldr r0, [pc, #176] ; 1fe3c <rtems_rfs_shell_group+0x164><== NOT EXECUTED
1fd88: eb0085ba bl 41478 <printf> <== NOT EXECUTED
1fd8c: e3a00001 mov r0, #1 <== NOT EXECUTED
return 1;
1fd90: ea000026 b 1fe30 <rtems_rfs_shell_group+0x158> <== NOT EXECUTED
1fd94: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
1fd98: e1a02001 mov r2, r1 <== NOT EXECUTED
1fd9c: e5930000 ldr r0, [r3] <== NOT EXECUTED
1fda0: ebffaec6 bl b8c0 <rtems_semaphore_obtain> <== NOT EXECUTED
1fda4: e3a03050 mov r3, #80 ; 0x50 <== NOT EXECUTED
1fda8: e0070693 mul r7, r3, r6 <== NOT EXECUTED
}
rtems_rfs_shell_lock_rfs (fs);
for (g = start; g <= end; g++)
1fdac: ea00001a b 1fe1c <rtems_rfs_shell_group+0x144> <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
1fdb0: e594801c ldr r8, [r4, #28] <== NOT EXECUTED
1fdb4: e0882007 add r2, r8, r7 <== NOT EXECUTED
size_t blocks;
size_t inodes;
blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
1fdb8: e592a004 ldr sl, [r2, #4] <== NOT EXECUTED
1fdbc: e5923018 ldr r3, [r2, #24] <== 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",
1fdc0: e3a00064 mov r0, #100 ; 0x64 <== NOT EXECUTED
for (g = start; g <= end; g++)
{
rtems_rfs_group* group = &fs->groups[g];
size_t blocks;
size_t inodes;
blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
1fdc4: e063300a rsb r3, r3, sl <== 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",
1fdc8: e0000093 mul r0, r3, r0 <== NOT EXECUTED
1fdcc: e1a0100a mov r1, sl <== 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);
1fdd0: e592903c ldr r9, [r2, #60] ; 0x3c <== NOT EXECUTED
1fdd4: e594b028 ldr fp, [r4, #40] ; 0x28 <== NOT EXECUTED
printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
1fdd8: e58d3000 str r3, [sp] <== NOT EXECUTED
1fddc: eb00d405 bl 54df8 <__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);
1fde0: e069900b rsb r9, r9, fp <== NOT EXECUTED
printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
1fde4: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
1fde8: e3a00064 mov r0, #100 ; 0x64 <== NOT EXECUTED
1fdec: e1a0100b mov r1, fp <== NOT EXECUTED
1fdf0: e0000099 mul r0, r9, r0 <== NOT EXECUTED
1fdf4: e58d9008 str r9, [sp, #8] <== NOT EXECUTED
1fdf8: eb00d3fe bl 54df8 <__aeabi_uidiv> <== NOT EXECUTED
1fdfc: e58d000c str r0, [sp, #12] <== NOT EXECUTED
1fe00: e1a01006 mov r1, r6 <== NOT EXECUTED
1fe04: e7982007 ldr r2, [r8, r7] <== NOT EXECUTED
1fe08: e1a0300a mov r3, sl <== NOT EXECUTED
1fe0c: e59f002c ldr r0, [pc, #44] ; 1fe40 <rtems_rfs_shell_group+0x168><== NOT EXECUTED
1fe10: eb008598 bl 41478 <printf> <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (g = start; g <= end; g++)
1fe14: e2866001 add r6, r6, #1 <== NOT EXECUTED
1fe18: e2877050 add r7, r7, #80 ; 0x50 <== NOT EXECUTED
1fe1c: e1560005 cmp r6, r5 <== NOT EXECUTED
1fe20: daffffe2 ble 1fdb0 <rtems_rfs_shell_group+0xd8> <== NOT EXECUTED
g, group->base, group->size,
blocks, (blocks * 100) / group->size,
inodes, (inodes * 100) / fs->group_inodes);
}
rtems_rfs_shell_unlock_rfs (fs);
1fe24: e1a00004 mov r0, r4 <== NOT EXECUTED
1fe28: ebfffe97 bl 1f88c <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
1fe2c: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
}
1fe30: e28dd010 add sp, sp, #16 <== NOT EXECUTED
1fe34: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0001f8a4 <rtems_rfs_shell_inode>:
return 0;
}
static int
rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
{
1f8a4: 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;
1f8a8: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
{
1f8ac: e1a04000 mov r4, r0 <== NOT EXECUTED
bool have_end;
int arg;
int b;
int rc;
total = fs->group_inodes * fs->group_count;
1f8b0: e5900028 ldr r0, [r0, #40] ; 0x28 <== NOT EXECUTED
1f8b4: e0070390 mul r7, r0, r3 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
{
1f8b8: 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;
1f8bc: e3a06000 mov r6, #0 <== NOT EXECUTED
1f8c0: e247b001 sub fp, r7, #1 <== NOT EXECUTED
1f8c4: e3a08001 mov r8, #1 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
{
1f8c8: e58d1018 str r1, [sp, #24] <== NOT EXECUTED
1f8cc: e58d201c str r2, [sp, #28] <== NOT EXECUTED
int b;
int rc;
total = fs->group_inodes * fs->group_count;
start = RTEMS_RFS_ROOT_INO;
end = total - 1;
1f8d0: e1a0500b mov r5, fp <== NOT EXECUTED
1f8d4: e1a0a006 mov sl, r6 <== NOT EXECUTED
1f8d8: e58d600c str r6, [sp, #12] <== NOT EXECUTED
1f8dc: e58d6010 str r6, [sp, #16] <== NOT EXECUTED
1f8e0: e58d6014 str r6, [sp, #20] <== NOT EXECUTED
1f8e4: e1a09008 mov r9, r8 <== NOT EXECUTED
show_all = false;
error_check_only = false;
forced = false;
have_start = have_end = false;
for (arg = 1; arg < argc; arg++)
1f8e8: ea000029 b 1f994 <rtems_rfs_shell_inode+0xf0> <== NOT EXECUTED
{
if (argv[arg][0] == '-')
1f8ec: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED
1f8f0: e7910108 ldr r0, [r1, r8, lsl #2] <== NOT EXECUTED
1f8f4: e5d03000 ldrb r3, [r0] <== NOT EXECUTED
1f8f8: e353002d cmp r3, #45 ; 0x2d <== NOT EXECUTED
1f8fc: 1a00000d bne 1f938 <rtems_rfs_shell_inode+0x94> <== NOT EXECUTED
{
switch (argv[arg][1])
1f900: e5d03001 ldrb r3, [r0, #1] <== NOT EXECUTED
1f904: e3530065 cmp r3, #101 ; 0x65 <== NOT EXECUTED
1f908: 03a02001 moveq r2, #1 <== NOT EXECUTED
1f90c: 058d2010 streq r2, [sp, #16] <== NOT EXECUTED
1f910: 0a00001e beq 1f990 <rtems_rfs_shell_inode+0xec> <== NOT EXECUTED
1f914: e3530066 cmp r3, #102 ; 0x66 <== NOT EXECUTED
1f918: 03a01001 moveq r1, #1 <== NOT EXECUTED
1f91c: 058d100c streq r1, [sp, #12] <== NOT EXECUTED
1f920: 0a00001a beq 1f990 <rtems_rfs_shell_inode+0xec> <== NOT EXECUTED
1f924: e3530061 cmp r3, #97 ; 0x61 <== NOT EXECUTED
1f928: 1a000006 bne 1f948 <rtems_rfs_shell_inode+0xa4> <== NOT EXECUTED
1f92c: e3a03001 mov r3, #1 <== NOT EXECUTED
1f930: e58d3014 str r3, [sp, #20] <== NOT EXECUTED
1f934: ea000015 b 1f990 <rtems_rfs_shell_inode+0xec> <== NOT EXECUTED
break;
}
}
else
{
if (have_end && have_start)
1f938: e3560000 cmp r6, #0 <== NOT EXECUTED
1f93c: 0a000005 beq 1f958 <rtems_rfs_shell_inode+0xb4> <== NOT EXECUTED
1f940: e35a0000 cmp sl, #0 <== NOT EXECUTED
1f944: 0a000005 beq 1f960 <rtems_rfs_shell_inode+0xbc> <== NOT EXECUTED
printf ("warning: option ignored: %s\n", argv[arg]);
1f948: e1a01000 mov r1, r0 <== NOT EXECUTED
1f94c: e59f0340 ldr r0, [pc, #832] ; 1fc94 <rtems_rfs_shell_inode+0x3f0><== NOT EXECUTED
1f950: eb0086c8 bl 41478 <printf> <== NOT EXECUTED
break;
}
}
else
{
if (have_end && have_start)
1f954: ea00000d b 1f990 <rtems_rfs_shell_inode+0xec> <== NOT EXECUTED
printf ("warning: option ignored: %s\n", argv[arg]);
else if (!have_start)
1f958: e35a0000 cmp sl, #0 <== NOT EXECUTED
1f95c: 1a000006 bne 1f97c <rtems_rfs_shell_inode+0xd8> <== NOT EXECUTED
{
start = end = strtoul (argv[arg], 0, 0);
1f960: e3a01000 mov r1, #0 <== NOT EXECUTED
1f964: e1a02001 mov r2, r1 <== NOT EXECUTED
1f968: eb00957d bl 44f64 <strtoul> <== NOT EXECUTED
1f96c: e3a0a001 mov sl, #1 <== NOT EXECUTED
1f970: e1a05000 mov r5, r0 <== NOT EXECUTED
1f974: e1a09000 mov r9, r0 <== NOT EXECUTED
1f978: ea000004 b 1f990 <rtems_rfs_shell_inode+0xec> <== NOT EXECUTED
have_start = true;
}
else
{
end = strtoul (argv[arg], 0, 0);
1f97c: e1a01006 mov r1, r6 <== NOT EXECUTED
1f980: e1a02006 mov r2, r6 <== NOT EXECUTED
1f984: eb009576 bl 44f64 <strtoul> <== NOT EXECUTED
1f988: e3a06001 mov r6, #1 <== NOT EXECUTED
1f98c: e1a05000 mov r5, r0 <== NOT EXECUTED
show_all = false;
error_check_only = false;
forced = false;
have_start = have_end = false;
for (arg = 1; arg < argc; arg++)
1f990: e2888001 add r8, r8, #1 <== NOT EXECUTED
1f994: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED
1f998: e1580002 cmp r8, r2 <== NOT EXECUTED
1f99c: baffffd2 blt 1f8ec <rtems_rfs_shell_inode+0x48> <== NOT EXECUTED
have_end = true;
}
}
}
if ((start >= total) || (end >= total))
1f9a0: e1590007 cmp r9, r7 <== NOT EXECUTED
1f9a4: 31550007 cmpcc r5, r7 <== NOT EXECUTED
1f9a8: 33a01000 movcc r1, #0 <== NOT EXECUTED
1f9ac: 23a01001 movcs r1, #1 <== NOT EXECUTED
1f9b0: 3a000003 bcc 1f9c4 <rtems_rfs_shell_inode+0x120> <== NOT EXECUTED
{
printf ("error: inode out of range (0->%" PRId32 ").\n", total - 1);
1f9b4: e1a0100b mov r1, fp <== NOT EXECUTED
1f9b8: e59f02d8 ldr r0, [pc, #728] ; 1fc98 <rtems_rfs_shell_inode+0x3f4><== NOT EXECUTED
1f9bc: eb0086ad bl 41478 <printf> <== NOT EXECUTED
1f9c0: ea000018 b 1fa28 <rtems_rfs_shell_inode+0x184> <== 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);
1f9c4: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
1f9c8: e1a02001 mov r2, r1 <== NOT EXECUTED
1f9cc: e5930000 ldr r0, [r3] <== NOT EXECUTED
1f9d0: ebffafba bl b8c0 <rtems_semaphore_obtain> <== 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);
1f9d4: 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);
1f9d8: e28d7020 add r7, sp, #32 <== 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)
1f9dc: e59fb2b8 ldr fp, [pc, #696] ; 1fc9c <rtems_rfs_shell_inode+0x3f8><== NOT EXECUTED
1f9e0: e1a08005 mov r8, r5 <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (ino = start; ino <= end; ino++)
1f9e4: ea0000a3 b 1fc78 <rtems_rfs_shell_inode+0x3d4> <== NOT EXECUTED
{
rtems_rfs_inode_handle inode;
bool allocated;
rc = rtems_rfs_group_bitmap_test (fs, true, ino, &allocated);
1f9e8: e1a00004 mov r0, r4 <== NOT EXECUTED
1f9ec: e3a01001 mov r1, #1 <== NOT EXECUTED
1f9f0: e1a02009 mov r2, r9 <== NOT EXECUTED
1f9f4: e1a0300a mov r3, sl <== NOT EXECUTED
1f9f8: eb005df0 bl 371c0 <rtems_rfs_group_bitmap_test> <== NOT EXECUTED
if (rc > 0)
1f9fc: e2506000 subs r6, r0, #0 <== NOT EXECUTED
1fa00: da00000a ble 1fa30 <rtems_rfs_shell_inode+0x18c> <== NOT EXECUTED
{
rtems_rfs_shell_unlock_rfs (fs);
1fa04: e1a00004 mov r0, r4 <== NOT EXECUTED
1fa08: ebffff9f bl 1f88c <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
printf ("error: testing inode state: ino=%" PRIu32 ": (%d) %s\n",
1fa0c: e1a00006 mov r0, r6 <== NOT EXECUTED
1fa10: eb008eab bl 434c4 <strerror> <== NOT EXECUTED
1fa14: e1a03000 mov r3, r0 <== NOT EXECUTED
1fa18: e59f0280 ldr r0, [pc, #640] ; 1fca0 <rtems_rfs_shell_inode+0x3fc><== NOT EXECUTED
1fa1c: e1a01009 mov r1, r9 <== NOT EXECUTED
1fa20: e1a02006 mov r2, r6 <== NOT EXECUTED
1fa24: eb008693 bl 41478 <printf> <== NOT EXECUTED
1fa28: e3a00001 mov r0, #1 <== NOT EXECUTED
ino, rc, strerror (rc));
return 1;
1fa2c: ea000096 b 1fc8c <rtems_rfs_shell_inode+0x3e8> <== NOT EXECUTED
}
if (show_all || allocated)
1fa30: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED
1fa34: e3530000 cmp r3, #0 <== NOT EXECUTED
1fa38: 1a000002 bne 1fa48 <rtems_rfs_shell_inode+0x1a4> <== NOT EXECUTED
1fa3c: e5dd304b ldrb r3, [sp, #75] ; 0x4b <== NOT EXECUTED
1fa40: e3530000 cmp r3, #0 <== NOT EXECUTED
1fa44: 0a00008a beq 1fc74 <rtems_rfs_shell_inode+0x3d0> <== NOT EXECUTED
{
uint16_t mode;
bool error;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1fa48: e1a00004 mov r0, r4 <== NOT EXECUTED
1fa4c: e1a01009 mov r1, r9 <== NOT EXECUTED
1fa50: e1a02007 mov r2, r7 <== NOT EXECUTED
1fa54: e3a03001 mov r3, #1 <== NOT EXECUTED
1fa58: eb005fc9 bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
1fa5c: e2506000 subs r6, r0, #0 <== NOT EXECUTED
1fa60: da000008 ble 1fa88 <rtems_rfs_shell_inode+0x1e4> <== NOT EXECUTED
{
rtems_rfs_shell_unlock_rfs (fs);
1fa64: e1a00004 mov r0, r4 <== NOT EXECUTED
1fa68: ebffff87 bl 1f88c <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
printf ("error: opening inode handle: ino=%" PRIu32 ": (%d) %s\n",
1fa6c: e1a00006 mov r0, r6 <== NOT EXECUTED
1fa70: eb008e93 bl 434c4 <strerror> <== NOT EXECUTED
1fa74: e1a01009 mov r1, r9 <== NOT EXECUTED
1fa78: e1a03000 mov r3, r0 <== NOT EXECUTED
1fa7c: e1a02006 mov r2, r6 <== NOT EXECUTED
1fa80: e59f021c ldr r0, [pc, #540] ; 1fca4 <rtems_rfs_shell_inode+0x400><== NOT EXECUTED
1fa84: eaffffe6 b 1fa24 <rtems_rfs_shell_inode+0x180> <== 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);
1fa88: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED
error = false;
mode = rtems_rfs_inode_get_mode (&inode);
if (error_check_only)
1fa8c: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
1fa90: e5d32003 ldrb r2, [r3, #3] <== NOT EXECUTED
1fa94: e5d35002 ldrb r5, [r3, #2] <== NOT EXECUTED
1fa98: e3510000 cmp r1, #0 <== NOT EXECUTED
1fa9c: e1825405 orr r5, r2, r5, lsl #8 <== NOT EXECUTED
1faa0: 0a000009 beq 1facc <rtems_rfs_shell_inode+0x228> <== NOT EXECUTED
{
if (!RTEMS_RFS_S_ISDIR (mode) &&
1faa4: e2053a0f and r3, r5, #61440 ; 0xf000 <== NOT EXECUTED
1faa8: e3530a02 cmp r3, #8192 ; 0x2000 <== NOT EXECUTED
1faac: 13530901 cmpne r3, #16384 ; 0x4000 <== NOT EXECUTED
1fab0: 0a000061 beq 1fc3c <rtems_rfs_shell_inode+0x398> <== NOT EXECUTED
1fab4: e3530a06 cmp r3, #24576 ; 0x6000 <== NOT EXECUTED
1fab8: 0a00005f beq 1fc3c <rtems_rfs_shell_inode+0x398> <== NOT EXECUTED
1fabc: e3530902 cmp r3, #32768 ; 0x8000 <== NOT EXECUTED
1fac0: 0a00005d beq 1fc3c <rtems_rfs_shell_inode+0x398> <== NOT EXECUTED
}
#endif
}
}
if (!error_check_only || error)
1fac4: e3530a0a cmp r3, #40960 ; 0xa000 <== NOT EXECUTED
1fac8: 0a00005b beq 1fc3c <rtems_rfs_shell_inode+0x398> <== NOT EXECUTED
{
printf (" %5" PRIu32 ": pos=%06" PRIu32 ":%04zx %c ",
1facc: e5ddc04b ldrb ip, [sp, #75] ; 0x4b <== NOT EXECUTED
1fad0: e59d3040 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED
1fad4: e35c0000 cmp ip, #0 <== NOT EXECUTED
1fad8: e3a02038 mov r2, #56 ; 0x38 <== NOT EXECUTED
1fadc: 13a0c041 movne ip, #65 ; 0x41 <== NOT EXECUTED
1fae0: 03a0c046 moveq ip, #70 ; 0x46 <== NOT EXECUTED
1fae4: e0030392 mul r3, r2, r3 <== NOT EXECUTED
1fae8: e59f01b8 ldr r0, [pc, #440] ; 1fca8 <rtems_rfs_shell_inode+0x404><== NOT EXECUTED
1faec: e59d2034 ldr r2, [sp, #52] ; 0x34 <== NOT EXECUTED
1faf0: e1a01009 mov r1, r9 <== NOT EXECUTED
1faf4: e58dc000 str ip, [sp] <== NOT EXECUTED
1faf8: eb00865e bl 41478 <printf> <== NOT EXECUTED
ino, rtems_rfs_buffer_bnum (&inode.buffer),
inode.offset * RTEMS_RFS_INODE_SIZE,
allocated ? 'A' : 'F');
if (!allocated && !forced)
1fafc: e5dd304b ldrb r3, [sp, #75] ; 0x4b <== NOT EXECUTED
1fb00: e3530000 cmp r3, #0 <== NOT EXECUTED
1fb04: 1a000005 bne 1fb20 <rtems_rfs_shell_inode+0x27c> <== NOT EXECUTED
1fb08: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
1fb0c: e3520000 cmp r2, #0 <== NOT EXECUTED
1fb10: 1a000002 bne 1fb20 <rtems_rfs_shell_inode+0x27c> <== NOT EXECUTED
printf (" --\n");
1fb14: e59f0190 ldr r0, [pc, #400] ; 1fcac <rtems_rfs_shell_inode+0x408><== NOT EXECUTED
1fb18: eb0086fb bl 4170c <puts> <== NOT EXECUTED
printf (" %5" PRIu32 ": pos=%06" PRIu32 ":%04zx %c ",
ino, rtems_rfs_buffer_bnum (&inode.buffer),
inode.offset * RTEMS_RFS_INODE_SIZE,
allocated ? 'A' : 'F');
if (!allocated && !forced)
1fb1c: ea000046 b 1fc3c <rtems_rfs_shell_inode+0x398> <== NOT EXECUTED
printf (" --\n");
else
{
const char* type;
type = "UKN";
if (RTEMS_RFS_S_ISDIR (mode))
1fb20: e2053a0f and r3, r5, #61440 ; 0xf000 <== NOT EXECUTED
1fb24: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED
1fb28: 059f3180 ldreq r3, [pc, #384] ; 1fcb0 <rtems_rfs_shell_inode+0x40c><== NOT EXECUTED
1fb2c: 0a00000d beq 1fb68 <rtems_rfs_shell_inode+0x2c4> <== NOT EXECUTED
type = "DIR";
else if (RTEMS_RFS_S_ISCHR (mode))
1fb30: e3530a02 cmp r3, #8192 ; 0x2000 <== NOT EXECUTED
1fb34: 059f3178 ldreq r3, [pc, #376] ; 1fcb4 <rtems_rfs_shell_inode+0x410><== NOT EXECUTED
1fb38: 0a00000a beq 1fb68 <rtems_rfs_shell_inode+0x2c4> <== NOT EXECUTED
type = "CHR";
else if (RTEMS_RFS_S_ISBLK (mode))
1fb3c: e3530a06 cmp r3, #24576 ; 0x6000 <== NOT EXECUTED
1fb40: 059f3170 ldreq r3, [pc, #368] ; 1fcb8 <rtems_rfs_shell_inode+0x414><== NOT EXECUTED
1fb44: 0a000007 beq 1fb68 <rtems_rfs_shell_inode+0x2c4> <== NOT EXECUTED
type = "BLK";
else if (RTEMS_RFS_S_ISREG (mode))
1fb48: e3530902 cmp r3, #32768 ; 0x8000 <== NOT EXECUTED
1fb4c: 059f3168 ldreq r3, [pc, #360] ; 1fcbc <rtems_rfs_shell_inode+0x418><== NOT EXECUTED
1fb50: 0a000004 beq 1fb68 <rtems_rfs_shell_inode+0x2c4> <== NOT EXECUTED
type = "REG";
else if (RTEMS_RFS_S_ISLNK (mode))
1fb54: e59f2164 ldr r2, [pc, #356] ; 1fcc0 <rtems_rfs_shell_inode+0x41c><== NOT EXECUTED
1fb58: e59f1164 ldr r1, [pc, #356] ; 1fcc4 <rtems_rfs_shell_inode+0x420><== NOT EXECUTED
1fb5c: e3530a0a cmp r3, #40960 ; 0xa000 <== NOT EXECUTED
1fb60: 01a01002 moveq r1, r2 <== NOT EXECUTED
1fb64: e1a03001 mov r3, r1 <== 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);
1fb68: e59d002c ldr r0, [sp, #44] ; 0x2c <== NOT EXECUTED
type = "LNK";
printf ("links=%03i mode=%04x (%s/%03o) bo=%04u bc=%04" PRIu32 " b=[",
1fb6c: e1a02b05 lsl r2, r5, #22 <== NOT EXECUTED
1fb70: e1a02b22 lsr r2, r2, #22 <== NOT EXECUTED
1fb74: e5d0e000 ldrb lr, [r0] <== NOT EXECUTED
1fb78: e5d01001 ldrb r1, [r0, #1] <== NOT EXECUTED
1fb7c: e58d2000 str r2, [sp] <== NOT EXECUTED
1fb80: e5d0c00a ldrb ip, [r0, #10] <== NOT EXECUTED
1fb84: e5d0200b ldrb r2, [r0, #11] <== NOT EXECUTED
1fb88: e182240c orr r2, r2, ip, lsl #8 <== NOT EXECUTED
1fb8c: 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);
1fb90: e280200c add r2, r0, #12 <== NOT EXECUTED
1fb94: e5d2c003 ldrb ip, [r2, #3] <== NOT EXECUTED
1fb98: e5d0600c ldrb r6, [r0, #12] <== NOT EXECUTED
1fb9c: e5d20001 ldrb r0, [r2, #1] <== 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);
1fba0: e181140e orr r1, r1, lr, lsl #8 <== NOT EXECUTED
1fba4: e5d22002 ldrb r2, [r2, #2] <== NOT EXECUTED
1fba8: e18c6c06 orr r6, ip, r6, lsl #24 <== NOT EXECUTED
1fbac: e186c800 orr ip, r6, r0, lsl #16 <== NOT EXECUTED
1fbb0: e151000b cmp r1, fp <== NOT EXECUTED
1fbb4: e18cc402 orr ip, ip, r2, lsl #8 <== NOT EXECUTED
1fbb8: 03a01000 moveq r1, #0 <== NOT EXECUTED
1fbbc: e1a02005 mov r2, r5 <== NOT EXECUTED
1fbc0: e59f0100 ldr r0, [pc, #256] ; 1fcc8 <rtems_rfs_shell_inode+0x424><== NOT EXECUTED
1fbc4: e58dc008 str ip, [sp, #8] <== NOT EXECUTED
1fbc8: eb00862a bl 41478 <printf> <== NOT EXECUTED
1fbcc: e3a05000 mov r5, #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]);
1fbd0: e59d202c ldr r2, [sp, #44] ; 0x2c <== NOT EXECUTED
1fbd4: 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));
1fbd8: e0823005 add r3, r2, r5 <== NOT EXECUTED
1fbdc: e7d21005 ldrb r1, [r2, r5] <== NOT EXECUTED
1fbe0: e5d32003 ldrb r2, [r3, #3] <== NOT EXECUTED
1fbe4: e5d30001 ldrb r0, [r3, #1] <== NOT EXECUTED
1fbe8: e1822c01 orr r2, r2, r1, lsl #24 <== NOT EXECUTED
1fbec: e5d31002 ldrb r1, [r3, #2] <== NOT EXECUTED
1fbf0: e1823800 orr r3, r2, r0, lsl #16 <== NOT EXECUTED
1fbf4: e1831401 orr r1, r3, r1, lsl #8 <== NOT EXECUTED
1fbf8: e2855004 add r5, r5, #4 <== NOT EXECUTED
1fbfc: e59f00c8 ldr r0, [pc, #200] ; 1fccc <rtems_rfs_shell_inode+0x428><== NOT EXECUTED
1fc00: eb00861c bl 41478 <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++)
1fc04: e3550010 cmp r5, #16 <== NOT EXECUTED
1fc08: 1afffff0 bne 1fbd0 <rtems_rfs_shell_inode+0x32c> <== NOT EXECUTED
1fc0c: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED
1fc10: 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));
1fc14: e5d30011 ldrb r0, [r3, #17] <== NOT EXECUTED
1fc18: e5d31010 ldrb r1, [r3, #16] <== NOT EXECUTED
1fc1c: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
1fc20: e5d32013 ldrb r2, [r3, #19] <== NOT EXECUTED
1fc24: e1800c01 orr r0, r0, r1, lsl #24 <== NOT EXECUTED
1fc28: e5d31012 ldrb r1, [r3, #18] <== NOT EXECUTED
1fc2c: e1803002 orr r3, r0, r2 <== NOT EXECUTED
1fc30: e1831401 orr r1, r3, r1, lsl #8 <== NOT EXECUTED
1fc34: e59f0094 ldr r0, [pc, #148] ; 1fcd0 <rtems_rfs_shell_inode+0x42c><== NOT EXECUTED
1fc38: eb00860e bl 41478 <printf> <== NOT EXECUTED
}
}
rc = rtems_rfs_inode_close (fs, &inode);
1fc3c: e1a00004 mov r0, r4 <== NOT EXECUTED
1fc40: e1a01007 mov r1, r7 <== NOT EXECUTED
1fc44: eb005f2b bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
1fc48: e2506000 subs r6, r0, #0 <== NOT EXECUTED
1fc4c: da000008 ble 1fc74 <rtems_rfs_shell_inode+0x3d0> <== NOT EXECUTED
{
rtems_rfs_shell_unlock_rfs (fs);
1fc50: e1a00004 mov r0, r4 <== NOT EXECUTED
1fc54: ebffff0c bl 1f88c <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
printf ("error: closing inode handle: ino=%" PRIu32 ": (%d) %s\n",
1fc58: e1a00006 mov r0, r6 <== NOT EXECUTED
1fc5c: eb008e18 bl 434c4 <strerror> <== NOT EXECUTED
1fc60: e1a01009 mov r1, r9 <== NOT EXECUTED
1fc64: e1a03000 mov r3, r0 <== NOT EXECUTED
1fc68: e1a02006 mov r2, r6 <== NOT EXECUTED
1fc6c: e59f0060 ldr r0, [pc, #96] ; 1fcd4 <rtems_rfs_shell_inode+0x430><== NOT EXECUTED
1fc70: eaffff6b b 1fa24 <rtems_rfs_shell_inode+0x180> <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (ino = start; ino <= end; ino++)
1fc74: e2899001 add r9, r9, #1 <== NOT EXECUTED
1fc78: e1590008 cmp r9, r8 <== NOT EXECUTED
1fc7c: 9affff59 bls 1f9e8 <rtems_rfs_shell_inode+0x144> <== NOT EXECUTED
return 1;
}
}
}
rtems_rfs_shell_unlock_rfs (fs);
1fc80: e1a00004 mov r0, r4 <== NOT EXECUTED
1fc84: ebffff00 bl 1f88c <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
1fc88: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
}
1fc8c: e28dd04c add sp, sp, #76 ; 0x4c <== NOT EXECUTED
1fc90: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0001f88c <rtems_rfs_shell_unlock_rfs>:
/**
* Unlock the file system.
*/
static void
rtems_rfs_shell_unlock_rfs (rtems_rfs_file_system* fs)
{
1f88c: 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);
1f890: e590407c ldr r4, [r0, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
1f894: eb0052f7 bl 34478 <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);
1f898: e5940000 ldr r0, [r4] <== NOT EXECUTED
#if __rtems__
rtems_rfs_rtems_unlock (fs);
#endif
}
1f89c: e8bd4010 pop {r4, lr} <== NOT EXECUTED
1f8a0: eaffb04c b b9d8 <rtems_semaphore_release> <== NOT EXECUTED
0001f650 <rtems_rfs_shell_usage>:
}
void
rtems_rfs_shell_usage (const char* arg)
{
1f650: e92d4010 push {r4, lr} <== NOT EXECUTED
printf ("%s: RFS debugger\n", arg);
1f654: e1a01000 mov r1, r0 <== NOT EXECUTED
}
void
rtems_rfs_shell_usage (const char* arg)
{
1f658: e1a04000 mov r4, r0 <== NOT EXECUTED
printf ("%s: RFS debugger\n", arg);
1f65c: e59f0038 ldr r0, [pc, #56] ; 1f69c <rtems_rfs_shell_usage+0x4c><== NOT EXECUTED
1f660: eb008784 bl 41478 <printf> <== NOT EXECUTED
printf (" %s [-hl] <path> <command>\n", arg);
1f664: e1a01004 mov r1, r4 <== NOT EXECUTED
1f668: e59f0030 ldr r0, [pc, #48] ; 1f6a0 <rtems_rfs_shell_usage+0x50><== NOT EXECUTED
1f66c: eb008781 bl 41478 <printf> <== NOT EXECUTED
printf (" where:\n");
1f670: e59f002c ldr r0, [pc, #44] ; 1f6a4 <rtems_rfs_shell_usage+0x54><== NOT EXECUTED
1f674: eb008824 bl 4170c <puts> <== NOT EXECUTED
printf (" path: Path to the mounted RFS file system\n");
1f678: e59f0028 ldr r0, [pc, #40] ; 1f6a8 <rtems_rfs_shell_usage+0x58><== NOT EXECUTED
1f67c: eb008822 bl 4170c <puts> <== NOT EXECUTED
printf (" command: A debugger command. See -l for a list plus help.\n");
1f680: e59f0024 ldr r0, [pc, #36] ; 1f6ac <rtems_rfs_shell_usage+0x5c><== NOT EXECUTED
1f684: eb008820 bl 4170c <puts> <== NOT EXECUTED
printf (" -h: This help\n");
1f688: e59f0020 ldr r0, [pc, #32] ; 1f6b0 <rtems_rfs_shell_usage+0x60><== NOT EXECUTED
1f68c: eb00881e bl 4170c <puts> <== NOT EXECUTED
printf (" -l: The debugger command list.\n");
1f690: e59f001c ldr r0, [pc, #28] ; 1f6b4 <rtems_rfs_shell_usage+0x64><== NOT EXECUTED
}
1f694: 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");
1f698: ea00881b b 4170c <puts> <== NOT EXECUTED
00037f0c <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
37f0c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
37f10: e24dd0a0 sub sp, sp, #160 ; 0xa0 <== NOT EXECUTED
37f14: e59d80c4 ldr r8, [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))
37f18: e5902008 ldr r2, [r0, #8] <== NOT EXECUTED
37f1c: e1580002 cmp r8, r2 <== NOT EXECUTED
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
37f20: e1a04000 mov r4, r0 <== NOT EXECUTED
37f24: e1a05001 mov r5, r1 <== NOT EXECUTED
37f28: e1a0b003 mov fp, r3 <== NOT EXECUTED
37f2c: e1dd6cb8 ldrh r6, [sp, #200] ; 0xc8 <== NOT EXECUTED
37f30: e1dd7cbc ldrh r7, [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))
37f34: 23a0a05b movcs sl, #91 ; 0x5b <== NOT EXECUTED
37f38: 2a00006f bcs 380fc <rtems_rfs_symlink+0x1f0> <== NOT EXECUTED
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
37f3c: e1a00001 mov r0, r1 <== NOT EXECUTED
37f40: eb002eeb bl 43af4 <strlen> <== NOT EXECUTED
37f44: e59fc1bc ldr ip, [pc, #444] ; 38108 <rtems_rfs_symlink+0x1fc><== NOT EXECUTED
37f48: e1a03000 mov r3, r0 <== NOT EXECUTED
37f4c: e1a02005 mov r2, r5 <== NOT EXECUTED
37f50: e58dc000 str ip, [sp] <== NOT EXECUTED
37f54: e59d10d0 ldr r1, [sp, #208] ; 0xd0 <== NOT EXECUTED
37f58: e28dc09c add ip, sp, #156 ; 0x9c <== NOT EXECUTED
37f5c: e3a05001 mov r5, #1 <== NOT EXECUTED
37f60: e1a00004 mov r0, r4 <== NOT EXECUTED
37f64: e98d10e0 stmib sp, {r5, r6, r7, ip} <== NOT EXECUTED
37f68: ebfffee7 bl 37b0c <rtems_rfs_inode_create> <== NOT EXECUTED
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
37f6c: e250a000 subs sl, r0, #0 <== NOT EXECUTED
37f70: ca000061 bgt 380fc <rtems_rfs_symlink+0x1f0> <== NOT EXECUTED
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
37f74: e28d6064 add r6, sp, #100 ; 0x64 <== NOT EXECUTED
37f78: e1a00004 mov r0, r4 <== NOT EXECUTED
37f7c: e59d109c ldr r1, [sp, #156] ; 0x9c <== NOT EXECUTED
37f80: e1a02006 mov r2, r6 <== NOT EXECUTED
37f84: e1a03005 mov r3, r5 <== NOT EXECUTED
37f88: ebfffe7d bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
37f8c: e250a000 subs sl, r0, #0 <== NOT EXECUTED
37f90: ca000059 bgt 380fc <rtems_rfs_symlink+0x1f0> <== 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)
37f94: e3580013 cmp r8, #19 <== NOT EXECUTED
37f98: 8a000013 bhi 37fec <rtems_rfs_symlink+0xe0> <== NOT EXECUTED
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
37f9c: e59d0070 ldr r0, [sp, #112] ; 0x70 <== NOT EXECUTED
37fa0: e3a01000 mov r1, #0 <== NOT EXECUTED
37fa4: e3a02014 mov r2, #20 <== NOT EXECUTED
37fa8: e280001c add r0, r0, #28 <== NOT EXECUTED
37fac: eb00210a bl 403dc <memset> <== NOT EXECUTED
memcpy (inode.node->data.name, link, link_length);
37fb0: e59d0070 ldr r0, [sp, #112] ; 0x70 <== NOT EXECUTED
37fb4: e1a02008 mov r2, r8 <== NOT EXECUTED
37fb8: e1a0100b mov r1, fp <== NOT EXECUTED
37fbc: e280001c add r0, r0, #28 <== NOT EXECUTED
37fc0: eb00207e bl 401c0 <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);
37fc4: e59d2070 ldr r2, [sp, #112] ; 0x70 <== NOT EXECUTED
37fc8: e3a03000 mov r3, #0 <== NOT EXECUTED
37fcc: e5c2300c strb r3, [r2, #12] <== NOT EXECUTED
37fd0: e59d2070 ldr r2, [sp, #112] ; 0x70 <== NOT EXECUTED
37fd4: e5c2300d strb r3, [r2, #13] <== NOT EXECUTED
37fd8: e59d2070 ldr r2, [sp, #112] ; 0x70 <== NOT EXECUTED
37fdc: e5c2300e strb r3, [r2, #14] <== NOT EXECUTED
37fe0: e59d2070 ldr r2, [sp, #112] ; 0x70 <== NOT EXECUTED
37fe4: e5c2300f strb r3, [r2, #15] <== NOT EXECUTED
37fe8: ea000036 b 380c8 <rtems_rfs_symlink+0x1bc> <== 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);
37fec: e28d7014 add r7, sp, #20 <== NOT EXECUTED
37ff0: e1a00004 mov r0, r4 <== NOT EXECUTED
37ff4: e1a01006 mov r1, r6 <== NOT EXECUTED
37ff8: e1a02007 mov r2, r7 <== NOT EXECUTED
37ffc: ebfff0a7 bl 342a0 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
38000: e250a000 subs sl, r0, #0 <== NOT EXECUTED
38004: ca00002b bgt 380b8 <rtems_rfs_symlink+0x1ac> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
38008: e1a02005 mov r2, r5 <== NOT EXECUTED
3800c: e1a00004 mov r0, r4 <== NOT EXECUTED
38010: e1a01007 mov r1, r7 <== NOT EXECUTED
38014: e28d3098 add r3, sp, #152 ; 0x98 <== NOT EXECUTED
38018: ebffef42 bl 33d28 <rtems_rfs_block_map_grow> <== NOT EXECUTED
if (rc > 0)
3801c: e250a000 subs sl, r0, #0 <== NOT EXECUTED
38020: ca00000b bgt 38054 <rtems_rfs_symlink+0x148> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
38024: e3a05000 mov r5, #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);
38028: e28d908c add r9, sp, #140 ; 0x8c <== NOT EXECUTED
3802c: e1a00004 mov r0, r4 <== NOT EXECUTED
38030: e1a01009 mov r1, r9 <== NOT EXECUTED
38034: e59d2098 ldr r2, [sp, #152] ; 0x98 <== NOT EXECUTED
38038: e1a03005 mov r3, r5 <== NOT EXECUTED
3803c: e5cd508c strb r5, [sp, #140] ; 0x8c <== NOT EXECUTED
handle->bnum = 0;
38040: e58d5090 str r5, [sp, #144] ; 0x90 <== NOT EXECUTED
handle->buffer = NULL;
38044: e58d5094 str r5, [sp, #148] ; 0x94 <== NOT EXECUTED
38048: ebfff1a4 bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
3804c: e250a000 subs sl, r0, #0 <== NOT EXECUTED
38050: da000003 ble 38064 <rtems_rfs_symlink+0x158> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
38054: e1a01007 mov r1, r7 <== NOT EXECUTED
38058: e1a00004 mov r0, r4 <== NOT EXECUTED
3805c: ebfff01d bl 340d8 <rtems_rfs_block_map_close> <== NOT EXECUTED
38060: ea000014 b 380b8 <rtems_rfs_symlink+0x1ac> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
38064: e59d3094 ldr r3, [sp, #148] ; 0x94 <== NOT EXECUTED
38068: e593a020 ldr sl, [r3, #32] <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
3806c: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED
38070: e1a0000a mov r0, sl <== NOT EXECUTED
38074: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED
38078: eb0020d7 bl 403dc <memset> <== NOT EXECUTED
memcpy (data, link, link_length);
3807c: e1a02008 mov r2, r8 <== NOT EXECUTED
38080: e1a0000a mov r0, sl <== NOT EXECUTED
38084: e1a0100b mov r1, fp <== NOT EXECUTED
38088: eb00204c bl 401c0 <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);
3808c: e1a01009 mov r1, r9 <== NOT EXECUTED
38090: e1a00004 mov r0, r4 <== NOT EXECUTED
38094: ebfff148 bl 345bc <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);
38098: e1a01007 mov r1, r7 <== NOT EXECUTED
3809c: e1a00004 mov r0, r4 <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
handle->buffer = NULL;
380a0: e58d5094 str r5, [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;
380a4: e5cd508c strb r5, [sp, #140] ; 0x8c <== NOT EXECUTED
handle->bnum = 0;
380a8: e58d5090 str r5, [sp, #144] ; 0x90 <== NOT EXECUTED
380ac: ebfff009 bl 340d8 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
380b0: e250a000 subs sl, r0, #0 <== NOT EXECUTED
380b4: da000003 ble 380c8 <rtems_rfs_symlink+0x1bc> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
380b8: e1a00004 mov r0, r4 <== NOT EXECUTED
380bc: e1a01006 mov r1, r6 <== NOT EXECUTED
380c0: ebfffe0c bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
380c4: ea00000c b 380fc <rtems_rfs_symlink+0x1f0> <== 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);
380c8: e59d3070 ldr r3, [sp, #112] ; 0x70 <== NOT EXECUTED
}
}
rtems_rfs_inode_set_block_offset (&inode, link_length);
380cc: e1a08808 lsl r8, r8, #16 <== NOT EXECUTED
380d0: e1a02c28 lsr r2, r8, #24 <== NOT EXECUTED
380d4: e5c3200a strb r2, [r3, #10] <== NOT EXECUTED
380d8: e59d3070 ldr r3, [sp, #112] ; 0x70 <== NOT EXECUTED
380dc: e1a08828 lsr r8, r8, #16 <== NOT EXECUTED
380e0: e5c3800b strb r8, [r3, #11] <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
380e4: e1a00004 mov r0, r4 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
380e8: e3a03001 mov r3, #1 <== NOT EXECUTED
380ec: e28d1064 add r1, sp, #100 ; 0x64 <== NOT EXECUTED
380f0: e5cd3074 strb r3, [sp, #116] ; 0x74 <== NOT EXECUTED
380f4: ebfffdff bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
380f8: e1a0a000 mov sl, r0 <== NOT EXECUTED
return rc;
}
380fc: e1a0000a mov r0, sl <== NOT EXECUTED
38100: e28dd0a0 add sp, sp, #160 ; 0xa0 <== NOT EXECUTED
38104: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00037d6c <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)
{
37d6c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
37d70: 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);
37d74: e28d5054 add r5, 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)
{
37d78: e1a08002 mov r8, r2 <== NOT EXECUTED
37d7c: 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);
37d80: e1a02005 mov r2, r5 <== NOT EXECUTED
37d84: 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)
{
37d88: e1a04000 mov r4, r0 <== NOT EXECUTED
37d8c: e59d90b0 ldr r9, [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);
37d90: ebfffefb bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
37d94: e250b000 subs fp, r0, #0 <== NOT EXECUTED
37d98: 1a000058 bne 37f00 <rtems_rfs_symlink_read+0x194> <== 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);
37d9c: e59d1060 ldr r1, [sp, #96] ; 0x60 <== NOT EXECUTED
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
37da0: e5d13002 ldrb r3, [r1, #2] <== NOT EXECUTED
37da4: e1a03403 lsl r3, r3, #8 <== NOT EXECUTED
37da8: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
37dac: e3530a0a cmp r3, #40960 ; 0xa000 <== NOT EXECUTED
37db0: 1a000005 bne 37dcc <rtems_rfs_symlink_read+0x60> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
37db4: e5d1200a ldrb r2, [r1, #10] <== NOT EXECUTED
37db8: e5d1300b ldrb r3, [r1, #11] <== NOT EXECUTED
37dbc: e1832402 orr r2, r3, r2, lsl #8 <== NOT EXECUTED
if (size < *length)
37dc0: e1560002 cmp r6, r2 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
37dc4: e5892000 str r2, [r9] <== NOT EXECUTED
if (size < *length)
37dc8: 2a000004 bcs 37de0 <rtems_rfs_symlink_read+0x74> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
37dcc: e1a00004 mov r0, r4 <== NOT EXECUTED
37dd0: e1a01005 mov r1, r5 <== NOT EXECUTED
37dd4: ebfffec7 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
37dd8: e3a0b016 mov fp, #22 <== NOT EXECUTED
return EINVAL;
37ddc: ea000047 b 37f00 <rtems_rfs_symlink_read+0x194> <== 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);
37de0: e281300c add r3, r1, #12 <== NOT EXECUTED
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
37de4: e5d30003 ldrb r0, [r3, #3] <== NOT EXECUTED
37de8: e5d1c00c ldrb ip, [r1, #12] <== NOT EXECUTED
37dec: e5d3e001 ldrb lr, [r3, #1] <== NOT EXECUTED
37df0: e180cc0c orr ip, r0, ip, lsl #24 <== NOT EXECUTED
37df4: e5d30002 ldrb r0, [r3, #2] <== NOT EXECUTED
37df8: e18c380e orr r3, ip, lr, lsl #16 <== NOT EXECUTED
37dfc: e1930400 orrs r0, r3, r0, lsl #8 <== NOT EXECUTED
37e00: 1a000003 bne 37e14 <rtems_rfs_symlink_read+0xa8> <== NOT EXECUTED
{
memcpy (path, inode.node->data.name, *length);
37e04: e281101c add r1, r1, #28 <== NOT EXECUTED
37e08: e1a00008 mov r0, r8 <== NOT EXECUTED
37e0c: eb0020eb bl 401c0 <memcpy> <== NOT EXECUTED
37e10: ea000033 b 37ee4 <rtems_rfs_symlink_read+0x178> <== 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);
37e14: e28d7004 add r7, sp, #4 <== NOT EXECUTED
37e18: e1a00004 mov r0, r4 <== NOT EXECUTED
37e1c: e1a01005 mov r1, r5 <== NOT EXECUTED
37e20: e1a02007 mov r2, r7 <== NOT EXECUTED
37e24: ebfff11d bl 342a0 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
37e28: e250b000 subs fp, r0, #0 <== NOT EXECUTED
37e2c: ca000028 bgt 37ed4 <rtems_rfs_symlink_read+0x168> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
37e30: e28dc088 add ip, sp, #136 ; 0x88 <== NOT EXECUTED
37e34: e1a00004 mov r0, r4 <== NOT EXECUTED
37e38: e1a01007 mov r1, r7 <== NOT EXECUTED
37e3c: e3a02000 mov r2, #0 <== NOT EXECUTED
37e40: e3a03000 mov r3, #0 <== NOT EXECUTED
37e44: e58dc000 str ip, [sp] <== NOT EXECUTED
37e48: ebffee7a bl 33838 <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
37e4c: e250b000 subs fp, r0, #0 <== NOT EXECUTED
37e50: ca00000b bgt 37e84 <rtems_rfs_symlink_read+0x118> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
37e54: e3a06000 mov r6, #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);
37e58: e28da07c add sl, sp, #124 ; 0x7c <== NOT EXECUTED
37e5c: e1a00004 mov r0, r4 <== NOT EXECUTED
37e60: e1a0100a mov r1, sl <== NOT EXECUTED
37e64: e59d2088 ldr r2, [sp, #136] ; 0x88 <== NOT EXECUTED
37e68: e1a03006 mov r3, r6 <== NOT EXECUTED
37e6c: e5cd607c strb r6, [sp, #124] ; 0x7c <== NOT EXECUTED
handle->bnum = 0;
37e70: e58d6080 str r6, [sp, #128] ; 0x80 <== NOT EXECUTED
handle->buffer = NULL;
37e74: e58d6084 str r6, [sp, #132] ; 0x84 <== NOT EXECUTED
37e78: ebfff218 bl 346e0 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
37e7c: e250b000 subs fp, r0, #0 <== NOT EXECUTED
37e80: da000003 ble 37e94 <rtems_rfs_symlink_read+0x128> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
37e84: e1a01007 mov r1, r7 <== NOT EXECUTED
37e88: e1a00004 mov r0, r4 <== NOT EXECUTED
37e8c: ebfff091 bl 340d8 <rtems_rfs_block_map_close> <== NOT EXECUTED
37e90: ea00000f b 37ed4 <rtems_rfs_symlink_read+0x168> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
memcpy (path, data, *length);
37e94: e59d3084 ldr r3, [sp, #132] ; 0x84 <== NOT EXECUTED
37e98: e5992000 ldr r2, [r9] <== NOT EXECUTED
37e9c: e5931020 ldr r1, [r3, #32] <== NOT EXECUTED
37ea0: e1a00008 mov r0, r8 <== NOT EXECUTED
37ea4: eb0020c5 bl 401c0 <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);
37ea8: e1a0100a mov r1, sl <== NOT EXECUTED
37eac: e1a00004 mov r0, r4 <== NOT EXECUTED
37eb0: ebfff1c1 bl 345bc <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);
37eb4: e1a01007 mov r1, r7 <== NOT EXECUTED
37eb8: e1a00004 mov r0, r4 <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
handle->buffer = NULL;
37ebc: e58d6084 str r6, [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;
37ec0: e5cd607c strb r6, [sp, #124] ; 0x7c <== NOT EXECUTED
handle->bnum = 0;
37ec4: e58d6080 str r6, [sp, #128] ; 0x80 <== NOT EXECUTED
37ec8: ebfff082 bl 340d8 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
37ecc: e250b000 subs fp, r0, #0 <== NOT EXECUTED
37ed0: da000003 ble 37ee4 <rtems_rfs_symlink_read+0x178> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
37ed4: e1a00004 mov r0, r4 <== NOT EXECUTED
37ed8: e1a01005 mov r1, r5 <== NOT EXECUTED
37edc: ebfffe85 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
37ee0: ea000006 b 37f00 <rtems_rfs_symlink_read+0x194> <== NOT EXECUTED
}
}
path[*length] = '\0';
37ee4: e5993000 ldr r3, [r9] <== NOT EXECUTED
37ee8: e3a02000 mov r2, #0 <== NOT EXECUTED
37eec: e7c82003 strb r2, [r8, r3] <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
37ef0: e1a00004 mov r0, r4 <== NOT EXECUTED
37ef4: e28d1054 add r1, sp, #84 ; 0x54 <== NOT EXECUTED
37ef8: ebfffe7e bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
37efc: e1a0b000 mov fp, r0 <== NOT EXECUTED
return rc;
}
37f00: e1a0000b mov r0, fp <== NOT EXECUTED
37f04: e28dd08c add sp, sp, #140 ; 0x8c <== NOT EXECUTED
37f08: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0003810c <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)
{
3810c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
38110: e24dd050 sub sp, sp, #80 ; 0x50 <== NOT EXECUTED
38114: e1a07002 mov r7, r2 <== NOT EXECUTED
38118: e1a0a001 mov sl, r1 <== NOT EXECUTED
3811c: e1a0b003 mov fp, 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);
38120: e1a01002 mov r1, r2 <== NOT EXECUTED
38124: e3a03001 mov r3, #1 <== NOT EXECUTED
38128: 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)
{
3812c: e1a04000 mov r4, r0 <== NOT EXECUTED
38130: e59d8074 ldr r8, [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);
38134: ebfffe12 bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
38138: e2509000 subs r9, 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);
3813c: e1a0500d mov r5, sp <== NOT EXECUTED
if (rc)
38140: 1a00006f bne 38304 <rtems_rfs_unlink+0x1f8> <== 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);
38144: 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));
38148: e5d36002 ldrb r6, [r3, #2] <== NOT EXECUTED
3814c: e1a06406 lsl r6, r6, #8 <== NOT EXECUTED
38150: e2066a0f and r6, r6, #61440 ; 0xf000 <== NOT EXECUTED
38154: e3560901 cmp r6, #16384 ; 0x4000 <== NOT EXECUTED
38158: 13a06000 movne r6, #0 <== NOT EXECUTED
3815c: 03a06001 moveq r6, #1 <== NOT EXECUTED
if (dir)
38160: e3560000 cmp r6, #0 <== NOT EXECUTED
38164: 0a00000e beq 381a4 <rtems_rfs_unlink+0x98> <== NOT EXECUTED
{
switch (dir_mode)
38168: e3580000 cmp r8, #0 <== NOT EXECUTED
3816c: 0a000002 beq 3817c <rtems_rfs_unlink+0x70> <== NOT EXECUTED
38170: e3580001 cmp r8, #1 <== NOT EXECUTED
38174: 1a00000a bne 381a4 <rtems_rfs_unlink+0x98> <== NOT EXECUTED
38178: ea000004 b 38190 <rtems_rfs_unlink+0x84> <== 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);
3817c: e1a00004 mov r0, r4 <== NOT EXECUTED
38180: e1a0100d mov r1, sp <== NOT EXECUTED
38184: ebfffddb bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
38188: e3a09015 mov r9, #21 <== NOT EXECUTED
return EISDIR;
3818c: ea00005c b 38304 <rtems_rfs_unlink+0x1f8> <== NOT EXECUTED
case rtems_rfs_unlink_dir_if_empty:
rc = rtems_rfs_dir_empty (fs, &target_inode);
38190: e1a00004 mov r0, r4 <== NOT EXECUTED
38194: e1a0100d mov r1, sp <== NOT EXECUTED
38198: ebfff1da bl 34908 <rtems_rfs_dir_empty> <== NOT EXECUTED
if (rc > 0)
3819c: e2509000 subs r9, r0, #0 <== NOT EXECUTED
381a0: ca000047 bgt 382c4 <rtems_rfs_unlink+0x1b8> <== NOT EXECUTED
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
381a4: e28d5028 add r5, sp, #40 ; 0x28 <== NOT EXECUTED
381a8: e1a0100a mov r1, sl <== NOT EXECUTED
381ac: e1a00004 mov r0, r4 <== NOT EXECUTED
381b0: e1a02005 mov r2, r5 <== NOT EXECUTED
381b4: e3a03001 mov r3, #1 <== NOT EXECUTED
381b8: ebfffdf1 bl 37984 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
381bc: e2509000 subs r9, r0, #0 <== NOT EXECUTED
381c0: 1a00003f bne 382c4 <rtems_rfs_unlink+0x1b8> <== 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);
381c4: e1a02007 mov r2, r7 <== NOT EXECUTED
381c8: e1a0300b mov r3, fp <== NOT EXECUTED
381cc: e1a00004 mov r0, r4 <== NOT EXECUTED
381d0: e1a01005 mov r1, r5 <== NOT EXECUTED
381d4: ebfff2d8 bl 34d3c <rtems_rfs_dir_del_entry> <== NOT EXECUTED
if (rc > 0)
381d8: e2509000 subs r9, r0, #0 <== NOT EXECUTED
381dc: ca000035 bgt 382b8 <rtems_rfs_unlink+0x1ac> <== 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);
381e0: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
381e4: e5d31000 ldrb r1, [r3] <== NOT EXECUTED
381e8: e5d32001 ldrb r2, [r3, #1] <== NOT EXECUTED
381ec: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED
if (links == 0xffff)
381f0: e59f1118 ldr r1, [pc, #280] ; 38310 <rtems_rfs_unlink+0x204><== NOT EXECUTED
381f4: e1520001 cmp r2, r1 <== NOT EXECUTED
381f8: 0a00000b beq 3822c <rtems_rfs_unlink+0x120> <== 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)
381fc: e3520001 cmp r2, #1 <== NOT EXECUTED
38200: 9a000009 bls 3822c <rtems_rfs_unlink+0x120> <== NOT EXECUTED
{
links--;
38204: e2422001 sub r2, r2, #1 <== NOT EXECUTED
38208: e1a02802 lsl r2, r2, #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);
3820c: e1a01c22 lsr r1, r2, #24 <== NOT EXECUTED
38210: e5c31000 strb r1, [r3] <== NOT EXECUTED
38214: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
38218: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED
3821c: e5c32001 strb r2, [r3, #1] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
38220: e3a03001 mov r3, #1 <== NOT EXECUTED
38224: e5cd3010 strb r3, [sp, #16] <== NOT EXECUTED
38228: ea00001b b 3829c <rtems_rfs_unlink+0x190> <== NOT EXECUTED
else
{
/*
* Erasing the inode releases all blocks attached to it.
*/
rc = rtems_rfs_inode_delete (fs, &target_inode);
3822c: e1a0100d mov r1, sp <== NOT EXECUTED
38230: e1a00004 mov r0, r4 <== NOT EXECUTED
38234: ebfffe05 bl 37a50 <rtems_rfs_inode_delete> <== NOT EXECUTED
if (rc > 0)
38238: e2509000 subs r9, r0, #0 <== NOT EXECUTED
else
{
/*
* Erasing the inode releases all blocks attached to it.
*/
rc = rtems_rfs_inode_delete (fs, &target_inode);
3823c: e1a0500d mov r5, sp <== NOT EXECUTED
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
38240: c1a00004 movgt r0, r4 <== NOT EXECUTED
38244: c28d1028 addgt r1, sp, #40 ; 0x28 <== NOT EXECUTED
{
/*
* Erasing the inode releases all blocks attached to it.
*/
rc = rtems_rfs_inode_delete (fs, &target_inode);
if (rc > 0)
38248: ca00001c bgt 382c0 <rtems_rfs_unlink+0x1b4> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
if (dir)
3824c: e3560000 cmp r6, #0 <== NOT EXECUTED
38250: 0a000011 beq 3829c <rtems_rfs_unlink+0x190> <== 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);
38254: e59d2034 ldr r2, [sp, #52] ; 0x34 <== NOT EXECUTED
38258: e5d21000 ldrb r1, [r2] <== NOT EXECUTED
3825c: e5d23001 ldrb r3, [r2, #1] <== NOT EXECUTED
38260: e1833401 orr r3, r3, r1, lsl #8 <== NOT EXECUTED
if (links == 0xffff)
38264: e59f10a4 ldr r1, [pc, #164] ; 38310 <rtems_rfs_unlink+0x204><== NOT EXECUTED
38268: e1530001 cmp r3, r1 <== NOT EXECUTED
3826c: 03a03000 moveq r3, #0 <== NOT EXECUTED
38270: 0a000003 beq 38284 <rtems_rfs_unlink+0x178> <== NOT EXECUTED
{
links = rtems_rfs_inode_get_links (&parent_inode);
if (links > 1)
38274: e3530001 cmp r3, #1 <== NOT EXECUTED
links--;
38278: 82433001 subhi r3, r3, #1 <== NOT EXECUTED
3827c: 81a03803 lslhi r3, r3, #16 <== NOT EXECUTED
38280: 81a03823 lsrhi r3, r3, #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);
38284: e1a01423 lsr r1, r3, #8 <== NOT EXECUTED
38288: e5c21000 strb r1, [r2] <== NOT EXECUTED
3828c: e59d2034 ldr r2, [sp, #52] ; 0x34 <== NOT EXECUTED
38290: e5c23001 strb r3, [r2, #1] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
38294: e3a03001 mov r3, #1 <== NOT EXECUTED
38298: e5cd3038 strb r3, [sp, #56] ; 0x38 <== NOT EXECUTED
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
3829c: e3a01001 mov r1, #1 <== NOT EXECUTED
382a0: e28d5028 add r5, sp, #40 ; 0x28 <== NOT EXECUTED
382a4: e1a00005 mov r0, r5 <== NOT EXECUTED
382a8: e1a02001 mov r2, r1 <== NOT EXECUTED
382ac: ebfffce0 bl 37634 <rtems_rfs_inode_time_stamp_now> <== NOT EXECUTED
if (rc > 0)
382b0: e2509000 subs r9, r0, #0 <== NOT EXECUTED
382b4: da000005 ble 382d0 <rtems_rfs_unlink+0x1c4> <== 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);
382b8: e1a01005 mov r1, r5 <== NOT EXECUTED
382bc: e1a00004 mov r0, r4 <== NOT EXECUTED
382c0: ebfffd8c bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
382c4: e1a00004 mov r0, r4 <== NOT EXECUTED
382c8: e1a0100d mov r1, sp <== NOT EXECUTED
382cc: ea000006 b 382ec <rtems_rfs_unlink+0x1e0> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
382d0: e1a01005 mov r1, r5 <== NOT EXECUTED
382d4: e1a00004 mov r0, r4 <== NOT EXECUTED
382d8: ebfffd86 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
382dc: e2509000 subs r9, r0, #0 <== NOT EXECUTED
382e0: e1a0100d mov r1, sp <== NOT EXECUTED
382e4: da000002 ble 382f4 <rtems_rfs_unlink+0x1e8> <== 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);
382e8: e1a00004 mov r0, r4 <== NOT EXECUTED
382ec: ebfffd81 bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
382f0: ea000003 b 38304 <rtems_rfs_unlink+0x1f8> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &target_inode);
382f4: e1a00004 mov r0, r4 <== NOT EXECUTED
382f8: e1a0100d mov r1, sp <== NOT EXECUTED
382fc: ebfffd7d bl 378f8 <rtems_rfs_inode_close> <== NOT EXECUTED
38300: e1a09000 mov r9, 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;
}
38304: e1a00009 mov r0, r9 <== NOT EXECUTED
38308: e28dd050 add sp, sp, #80 ; 0x50 <== NOT EXECUTED
3830c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
000204c0 <rtems_shell_debugrfs>:
printf (" -l: The debugger command list.\n");
}
int
rtems_shell_debugrfs (int argc, char *argv[])
{
204c0: e92d45f0 push {r4, r5, r6, r7, r8, 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>" }
};
204c4: e59fe20c ldr lr, [pc, #524] ; 206d8 <rtems_shell_debugrfs+0x218><== NOT EXECUTED
printf (" -l: The debugger command list.\n");
}
int
rtems_shell_debugrfs (int argc, char *argv[])
{
204c8: e1a05000 mov r5, r0 <== NOT EXECUTED
204cc: e24dd08c sub sp, sp, #140 ; 0x8c <== NOT EXECUTED
204d0: e1a04001 mov r4, 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>" }
};
204d4: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
204d8: e28dc004 add ip, sp, #4 <== NOT EXECUTED
204dc: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
204e0: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
204e4: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
204e8: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
204ec: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
204f0: e89e0007 ldm lr, {r0, r1, r2} <== NOT EXECUTED
int arg;
int t;
for (arg = 1; arg < argc; arg++)
204f4: e3550001 cmp r5, #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>" }
};
204f8: e88c0007 stm ip, {r0, r1, r2} <== NOT EXECUTED
int arg;
int t;
for (arg = 1; arg < argc; arg++)
204fc: da000029 ble 205a8 <rtems_shell_debugrfs+0xe8> <== NOT EXECUTED
{
if (argv[arg][0] != '-')
20500: e5947004 ldr r7, [r4, #4] <== NOT EXECUTED
20504: e5d73000 ldrb r3, [r7] <== NOT EXECUTED
20508: e353002d cmp r3, #45 ; 0x2d <== NOT EXECUTED
2050c: 1a000023 bne 205a0 <rtems_shell_debugrfs+0xe0> <== NOT EXECUTED
break;
switch (argv[arg][1])
20510: e5d73001 ldrb r3, [r7, #1] <== NOT EXECUTED
20514: e3530068 cmp r3, #104 ; 0x68 <== NOT EXECUTED
20518: 0a000004 beq 20530 <rtems_shell_debugrfs+0x70> <== NOT EXECUTED
2051c: e353006c cmp r3, #108 ; 0x6c <== 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]);
20520: 11a01007 movne r1, r7 <== NOT EXECUTED
20524: 159f01b0 ldrne r0, [pc, #432] ; 206dc <rtems_shell_debugrfs+0x21c><== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] != '-')
break;
switch (argv[arg][1])
20528: 1a000066 bne 206c8 <rtems_shell_debugrfs+0x208> <== NOT EXECUTED
2052c: ea000002 b 2053c <rtems_shell_debugrfs+0x7c> <== NOT EXECUTED
{
case 'h':
rtems_rfs_shell_usage (argv[0]);
20530: e5940000 ldr r0, [r4] <== NOT EXECUTED
20534: ebfffc45 bl 1f650 <rtems_rfs_shell_usage> <== NOT EXECUTED
20538: ea000016 b 20598 <rtems_shell_debugrfs+0xd8> <== NOT EXECUTED
return 0;
case 'l':
printf ("%s: commands are:\n", argv[0]);
2053c: e5941000 ldr r1, [r4] <== NOT EXECUTED
20540: e59f0198 ldr r0, [pc, #408] ; 206e0 <rtems_shell_debugrfs+0x220><== NOT EXECUTED
20544: eb0083cb bl 41478 <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);
20548: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
2054c: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
20550: e59f018c ldr r0, [pc, #396] ; 206e4 <rtems_shell_debugrfs+0x224><== NOT EXECUTED
20554: eb0083c7 bl 41478 <printf> <== NOT EXECUTED
20558: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
2055c: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED
20560: e59f017c ldr r0, [pc, #380] ; 206e4 <rtems_shell_debugrfs+0x224><== NOT EXECUTED
20564: eb0083c3 bl 41478 <printf> <== NOT EXECUTED
20568: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED
2056c: e59d2024 ldr r2, [sp, #36] ; 0x24 <== NOT EXECUTED
20570: e59f016c ldr r0, [pc, #364] ; 206e4 <rtems_shell_debugrfs+0x224><== NOT EXECUTED
20574: eb0083bf bl 41478 <printf> <== NOT EXECUTED
20578: e59d1028 ldr r1, [sp, #40] ; 0x28 <== NOT EXECUTED
2057c: e59d2030 ldr r2, [sp, #48] ; 0x30 <== NOT EXECUTED
20580: e59f015c ldr r0, [pc, #348] ; 206e4 <rtems_shell_debugrfs+0x224><== NOT EXECUTED
20584: eb0083bb bl 41478 <printf> <== NOT EXECUTED
20588: e59f0154 ldr r0, [pc, #340] ; 206e4 <rtems_shell_debugrfs+0x224><== NOT EXECUTED
2058c: e59d1034 ldr r1, [sp, #52] ; 0x34 <== NOT EXECUTED
20590: e59d203c ldr r2, [sp, #60] ; 0x3c <== NOT EXECUTED
20594: eb0083b7 bl 41478 <printf> <== NOT EXECUTED
20598: e3a00000 mov r0, #0 <== NOT EXECUTED
2059c: ea00004b b 206d0 <rtems_shell_debugrfs+0x210> <== NOT EXECUTED
printf ("error: unknown option: %s\n", argv[arg]);
return 1;
}
}
if ((argc - arg) < 2)
205a0: e3550002 cmp r5, #2 <== NOT EXECUTED
205a4: 1a000002 bne 205b4 <rtems_shell_debugrfs+0xf4> <== NOT EXECUTED
printf ("error: you need at least a path and command, try %s -h\n", argv[0]);
205a8: e5941000 ldr r1, [r4] <== NOT EXECUTED
205ac: e59f0134 ldr r0, [pc, #308] ; 206e8 <rtems_shell_debugrfs+0x228><== NOT EXECUTED
205b0: ea000044 b 206c8 <rtems_shell_debugrfs+0x208> <== NOT EXECUTED
rtems_rfs_get_fs (const char* path, rtems_rfs_file_system** fs)
{
struct statvfs sb;
int rc;
rc = statvfs (path, &sb);
205b4: e1a00007 mov r0, r7 <== NOT EXECUTED
205b8: e28d1040 add r1, sp, #64 ; 0x40 <== NOT EXECUTED
205bc: eb001929 bl 26a68 <statvfs> <== NOT EXECUTED
if (rc < 0)
205c0: e3500000 cmp r0, #0 <== NOT EXECUTED
205c4: aa00000a bge 205f4 <rtems_shell_debugrfs+0x134> <== NOT EXECUTED
{
printf ("error: cannot statvfs path: %s: (%d) %s\n",
205c8: eb00724c bl 3cf00 <__errno> <== NOT EXECUTED
205cc: e5904000 ldr r4, [r0] <== NOT EXECUTED
205d0: eb00724a bl 3cf00 <__errno> <== NOT EXECUTED
205d4: e5900000 ldr r0, [r0] <== NOT EXECUTED
205d8: eb008bb9 bl 434c4 <strerror> <== NOT EXECUTED
205dc: e1a01007 mov r1, r7 <== NOT EXECUTED
205e0: e1a03000 mov r3, r0 <== NOT EXECUTED
205e4: e1a02004 mov r2, r4 <== NOT EXECUTED
205e8: e59f00fc ldr r0, [pc, #252] ; 206ec <rtems_shell_debugrfs+0x22c><== NOT EXECUTED
205ec: eb0083a1 bl 41478 <printf> <== NOT EXECUTED
205f0: ea000035 b 206cc <rtems_shell_debugrfs+0x20c> <== NOT EXECUTED
path, errno, strerror (errno));
return -1;
}
if (sb.f_fsid != RTEMS_RFS_SB_MAGIC)
205f4: e59d206c ldr r2, [sp, #108] ; 0x6c <== NOT EXECUTED
205f8: e59f30f0 ldr r3, [pc, #240] ; 206f0 <rtems_shell_debugrfs+0x230><== NOT EXECUTED
205fc: e1520003 cmp r2, r3 <== NOT EXECUTED
{
printf ("error: path '%s' is not on an RFS file system\n", path);
20600: 11a01007 movne r1, r7 <== NOT EXECUTED
20604: 159f00e8 ldrne r0, [pc, #232] ; 206f4 <rtems_shell_debugrfs+0x234><== 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)
20608: 1a00002e bne 206c8 <rtems_shell_debugrfs+0x208> <== 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);
2060c: e1a00007 mov r0, r7 <== NOT EXECUTED
20610: eb008d37 bl 43af4 <strlen> <== NOT EXECUTED
20614: e28d6078 add r6, sp, #120 ; 0x78 <== NOT EXECUTED
20618: e1a01000 mov r1, r0 <== NOT EXECUTED
2061c: e3a02000 mov r2, #0 <== NOT EXECUTED
20620: e1a00007 mov r0, r7 <== NOT EXECUTED
20624: e1a03006 mov r3, r6 <== NOT EXECUTED
20628: e3a0c001 mov ip, #1 <== NOT EXECUTED
2062c: e58dc000 str ip, [sp] <== NOT EXECUTED
20630: ebff9c01 bl 763c <rtems_filesystem_evaluate_path> <== NOT EXECUTED
*fs = rtems_rfs_rtems_pathloc_dev (&pathloc);
rtems_filesystem_freenode (&pathloc);
20634: 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);
20638: e59d2088 ldr r2, [sp, #136] ; 0x88 <== NOT EXECUTED
rtems_filesystem_freenode (&pathloc);
2063c: 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);
20640: e1a07000 mov r7, r0 <== NOT EXECUTED
*fs = rtems_rfs_rtems_pathloc_dev (&pathloc);
20644: e5928034 ldr r8, [r2, #52] ; 0x34 <== NOT EXECUTED
rtems_filesystem_freenode (&pathloc);
20648: 0a000004 beq 20660 <rtems_shell_debugrfs+0x1a0> <== NOT EXECUTED
2064c: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
20650: e3530000 cmp r3, #0 <== NOT EXECUTED
20654: 11a00006 movne r0, r6 <== NOT EXECUTED
20658: 11a0e00f movne lr, pc <== NOT EXECUTED
2065c: 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)
20660: e3570000 cmp r7, #0 <== NOT EXECUTED
{
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
if (strcmp (argv[arg + 1], table[t].name) == 0)
20664: 02844008 addeq r4, r4, #8 <== 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)
20668: 01a06007 moveq r6, r7 <== NOT EXECUTED
{
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
if (strcmp (argv[arg + 1], table[t].name) == 0)
2066c: 028da004 addeq sl, sp, #4 <== 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)
20670: 1a000015 bne 206cc <rtems_shell_debugrfs+0x20c> <== NOT EXECUTED
{
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
if (strcmp (argv[arg + 1], table[t].name) == 0)
20674: e79a1007 ldr r1, [sl, r7] <== NOT EXECUTED
20678: e5940000 ldr r0, [r4] <== NOT EXECUTED
2067c: eb008ab4 bl 43154 <strcmp> <== NOT EXECUTED
20680: e3500000 cmp r0, #0 <== NOT EXECUTED
20684: e287700c add r7, r7, #12 <== NOT EXECUTED
20688: 1a000009 bne 206b4 <rtems_shell_debugrfs+0x1f4> <== NOT EXECUTED
return table[t].handler (fs, argc - 2, argv + 2);
2068c: e3a02003 mov r2, #3 <== NOT EXECUTED
20690: e0030692 mul r3, r2, r6 <== NOT EXECUTED
20694: e28d208c add r2, sp, #140 ; 0x8c <== NOT EXECUTED
20698: e0823103 add r3, r2, r3, lsl #2 <== NOT EXECUTED
2069c: e1a00008 mov r0, r8 <== NOT EXECUTED
206a0: e2451002 sub r1, r5, #2 <== NOT EXECUTED
206a4: e1a02004 mov r2, r4 <== NOT EXECUTED
206a8: e1a0e00f mov lr, pc <== NOT EXECUTED
206ac: e513f084 ldr pc, [r3, #-132] ; 0x84 <== NOT EXECUTED
206b0: ea000006 b 206d0 <rtems_shell_debugrfs+0x210> <== 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++)
206b4: e2866001 add r6, r6, #1 <== NOT EXECUTED
206b8: e3560005 cmp r6, #5 <== NOT EXECUTED
206bc: 1affffec bne 20674 <rtems_shell_debugrfs+0x1b4> <== 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]);
206c0: e5941000 ldr r1, [r4] <== NOT EXECUTED
206c4: e59f002c ldr r0, [pc, #44] ; 206f8 <rtems_shell_debugrfs+0x238><== NOT EXECUTED
206c8: eb00836a bl 41478 <printf> <== NOT EXECUTED
206cc: e3a00001 mov r0, #1 <== NOT EXECUTED
}
}
return 1;
}
206d0: e28dd08c add sp, sp, #140 ; 0x8c <== NOT EXECUTED
206d4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
0001f6b8 <rtems_shell_rfs_format>:
return 1;
}
int
rtems_shell_rfs_format (int argc, char* argv[])
{
1f6b8: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
1f6bc: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
1f6c0: e1a07000 mov r7, r0 <== NOT EXECUTED
1f6c4: e1a06001 mov r6, r1 <== NOT EXECUTED
rtems_rfs_format_config config;
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
1f6c8: e1a0000d mov r0, sp <== NOT EXECUTED
1f6cc: e3a01000 mov r1, #0 <== NOT EXECUTED
1f6d0: e3a02018 mov r2, #24 <== NOT EXECUTED
1f6d4: e3a04001 mov r4, #1 <== NOT EXECUTED
1f6d8: eb00833f bl 403dc <memset> <== NOT EXECUTED
1f6dc: e3a05000 mov r5, #0 <== NOT EXECUTED
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
{
case 'v':
config.verbose = true;
1f6e0: e1a08004 mov r8, r4 <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
1f6e4: ea000049 b 1f810 <rtems_shell_rfs_format+0x158> <== NOT EXECUTED
{
if (argv[arg][0] == '-')
1f6e8: e7961104 ldr r1, [r6, r4, lsl #2] <== NOT EXECUTED
1f6ec: e5d13000 ldrb r3, [r1] <== NOT EXECUTED
1f6f0: e353002d cmp r3, #45 ; 0x2d <== NOT EXECUTED
1f6f4: 1a00003e bne 1f7f4 <rtems_shell_rfs_format+0x13c> <== NOT EXECUTED
{
switch (argv[arg][1])
1f6f8: e5d13001 ldrb r3, [r1, #1] <== NOT EXECUTED
1f6fc: e3530069 cmp r3, #105 ; 0x69 <== NOT EXECUTED
1f700: 0a000023 beq 1f794 <rtems_shell_rfs_format+0xdc> <== NOT EXECUTED
1f704: 8a000004 bhi 1f71c <rtems_shell_rfs_format+0x64> <== NOT EXECUTED
1f708: e3530049 cmp r3, #73 ; 0x49 <== NOT EXECUTED
1f70c: 0a00002a beq 1f7bc <rtems_shell_rfs_format+0x104> <== NOT EXECUTED
1f710: e3530062 cmp r3, #98 ; 0x62 <== NOT EXECUTED
1f714: 1a000034 bne 1f7ec <rtems_shell_rfs_format+0x134> <== NOT EXECUTED
1f718: ea000013 b 1f76c <rtems_shell_rfs_format+0xb4> <== NOT EXECUTED
1f71c: e3530073 cmp r3, #115 ; 0x73 <== NOT EXECUTED
1f720: 0a000006 beq 1f740 <rtems_shell_rfs_format+0x88> <== NOT EXECUTED
1f724: e3530076 cmp r3, #118 ; 0x76 <== NOT EXECUTED
1f728: 0a000002 beq 1f738 <rtems_shell_rfs_format+0x80> <== NOT EXECUTED
1f72c: e353006f cmp r3, #111 ; 0x6f <== NOT EXECUTED
1f730: 1a00002d bne 1f7ec <rtems_shell_rfs_format+0x134> <== NOT EXECUTED
1f734: ea000022 b 1f7c4 <rtems_shell_rfs_format+0x10c> <== NOT EXECUTED
{
case 'v':
config.verbose = true;
1f738: e5cd8015 strb r8, [sp, #21] <== NOT EXECUTED
1f73c: ea000008 b 1f764 <rtems_shell_rfs_format+0xac> <== NOT EXECUTED
break;
case 's':
arg++;
1f740: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (arg >= argc)
1f744: e1540007 cmp r4, r7 <== NOT EXECUTED
{
printf ("error: block size needs an argument\n");
1f748: a59f011c ldrge r0, [pc, #284] ; 1f86c <rtems_shell_rfs_format+0x1b4><== NOT EXECUTED
1f74c: aa000034 bge 1f824 <rtems_shell_rfs_format+0x16c> <== NOT EXECUTED
return 1;
}
config.block_size = strtoul (argv[arg], 0, 0);
1f750: e3a01000 mov r1, #0 <== NOT EXECUTED
1f754: e7960104 ldr r0, [r6, r4, lsl #2] <== NOT EXECUTED
1f758: e1a02001 mov r2, r1 <== NOT EXECUTED
1f75c: eb009600 bl 44f64 <strtoul> <== NOT EXECUTED
1f760: e58d0000 str r0, [sp] <== NOT EXECUTED
1f764: e1a01005 mov r1, r5 <== NOT EXECUTED
break;
1f768: ea000026 b 1f808 <rtems_shell_rfs_format+0x150> <== NOT EXECUTED
case 'b':
arg++;
1f76c: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (arg >= argc)
1f770: e1540007 cmp r4, r7 <== NOT EXECUTED
{
printf ("error: group block count needs an argument\n");
1f774: a59f00f4 ldrge r0, [pc, #244] ; 1f870 <rtems_shell_rfs_format+0x1b8><== NOT EXECUTED
1f778: aa000029 bge 1f824 <rtems_shell_rfs_format+0x16c> <== NOT EXECUTED
return 1;
}
config.group_blocks = strtoul (argv[arg], 0, 0);
1f77c: e3a01000 mov r1, #0 <== NOT EXECUTED
1f780: e7960104 ldr r0, [r6, r4, lsl #2] <== NOT EXECUTED
1f784: e1a02001 mov r2, r1 <== NOT EXECUTED
1f788: eb0095f5 bl 44f64 <strtoul> <== NOT EXECUTED
1f78c: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
1f790: eafffff3 b 1f764 <rtems_shell_rfs_format+0xac> <== NOT EXECUTED
break;
case 'i':
arg++;
1f794: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (arg >= argc)
1f798: e1540007 cmp r4, r7 <== NOT EXECUTED
{
printf ("error: group inode count needs an argument\n");
1f79c: a59f00d0 ldrge r0, [pc, #208] ; 1f874 <rtems_shell_rfs_format+0x1bc><== NOT EXECUTED
1f7a0: aa00001f bge 1f824 <rtems_shell_rfs_format+0x16c> <== NOT EXECUTED
return 1;
}
config.group_inodes = strtoul (argv[arg], 0, 0);
1f7a4: e3a01000 mov r1, #0 <== NOT EXECUTED
1f7a8: e7960104 ldr r0, [r6, r4, lsl #2] <== NOT EXECUTED
1f7ac: e1a02001 mov r2, r1 <== NOT EXECUTED
1f7b0: eb0095eb bl 44f64 <strtoul> <== NOT EXECUTED
1f7b4: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
1f7b8: eaffffe9 b 1f764 <rtems_shell_rfs_format+0xac> <== NOT EXECUTED
break;
case 'I':
config.initialise_inodes = true;
1f7bc: e5cd8014 strb r8, [sp, #20] <== NOT EXECUTED
1f7c0: eaffffe7 b 1f764 <rtems_shell_rfs_format+0xac> <== NOT EXECUTED
break;
case 'o':
arg++;
1f7c4: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (arg >= argc)
1f7c8: e1540007 cmp r4, r7 <== NOT EXECUTED
{
printf ("error: inode percentage overhead needs an argument\n");
1f7cc: a59f00a4 ldrge r0, [pc, #164] ; 1f878 <rtems_shell_rfs_format+0x1c0><== NOT EXECUTED
1f7d0: aa000013 bge 1f824 <rtems_shell_rfs_format+0x16c> <== NOT EXECUTED
return 1;
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
1f7d4: e3a01000 mov r1, #0 <== NOT EXECUTED
1f7d8: e7960104 ldr r0, [r6, r4, lsl #2] <== NOT EXECUTED
1f7dc: e1a02001 mov r2, r1 <== NOT EXECUTED
1f7e0: eb0095df bl 44f64 <strtoul> <== NOT EXECUTED
1f7e4: e58d000c str r0, [sp, #12] <== NOT EXECUTED
1f7e8: eaffffdd b 1f764 <rtems_shell_rfs_format+0xac> <== NOT EXECUTED
break;
default:
printf ("error: invalid option: %s\n", argv[arg]);
1f7ec: e59f0088 ldr r0, [pc, #136] ; 1f87c <rtems_shell_rfs_format+0x1c4><== NOT EXECUTED
1f7f0: ea000002 b 1f800 <rtems_shell_rfs_format+0x148> <== NOT EXECUTED
return 1;
}
}
else
{
if (!driver)
1f7f4: e3550000 cmp r5, #0 <== NOT EXECUTED
1f7f8: 0a000002 beq 1f808 <rtems_shell_rfs_format+0x150> <== NOT EXECUTED
driver = argv[arg];
else
{
printf ("error: only one driver name allowed: %s\n", argv[arg]);
1f7fc: e59f007c ldr r0, [pc, #124] ; 1f880 <rtems_shell_rfs_format+0x1c8><== NOT EXECUTED
1f800: eb00871c bl 41478 <printf> <== NOT EXECUTED
1f804: ea000015 b 1f860 <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
1f808: e2844001 add r4, r4, #1 <== NOT EXECUTED
1f80c: e1a05001 mov r5, r1 <== NOT EXECUTED
1f810: e1540007 cmp r4, r7 <== NOT EXECUTED
1f814: baffffb3 blt 1f6e8 <rtems_shell_rfs_format+0x30> <== NOT EXECUTED
return 1;
}
}
}
if (!driver) {
1f818: e3550000 cmp r5, #0 <== NOT EXECUTED
1f81c: 1a000002 bne 1f82c <rtems_shell_rfs_format+0x174> <== NOT EXECUTED
printf ("error: no driver name provided\n");
1f820: e59f005c ldr r0, [pc, #92] ; 1f884 <rtems_shell_rfs_format+0x1cc><== NOT EXECUTED
1f824: eb0087b8 bl 4170c <puts> <== NOT EXECUTED
1f828: ea00000c b 1f860 <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
1f82c: e1a00005 mov r0, r5 <== NOT EXECUTED
1f830: e1a0100d mov r1, sp <== NOT EXECUTED
1f834: eb005b2f bl 364f8 <rtems_rfs_format> <== NOT EXECUTED
1f838: e3500000 cmp r0, #0 <== NOT EXECUTED
1f83c: a3a00000 movge r0, #0 <== NOT EXECUTED
1f840: aa000007 bge 1f864 <rtems_shell_rfs_format+0x1ac> <== NOT EXECUTED
{
printf ("error: format of %s failed: %s\n",
1f844: eb0075ad bl 3cf00 <__errno> <== NOT EXECUTED
1f848: e5900000 ldr r0, [r0] <== NOT EXECUTED
1f84c: eb008f1c bl 434c4 <strerror> <== NOT EXECUTED
1f850: e1a01005 mov r1, r5 <== NOT EXECUTED
1f854: e1a02000 mov r2, r0 <== NOT EXECUTED
1f858: e59f0028 ldr r0, [pc, #40] ; 1f888 <rtems_shell_rfs_format+0x1d0><== NOT EXECUTED
1f85c: eb008705 bl 41478 <printf> <== NOT EXECUTED
1f860: e3a00001 mov r0, #1 <== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
1f864: e28dd018 add sp, sp, #24 <== NOT EXECUTED
1f868: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00005e58 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
5e58: e92d4810 push {r4, fp, lr}
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
5e5c: e59f307c ldr r3, [pc, #124] ; 5ee0 <rtems_stack_checker_is_blown+0x88>
5e60: e5933000 ldr r3, [r3]
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
5e64: e59300c4 ldr r0, [r3, #196] ; 0xc4
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
5e68: e28db008 add fp, sp, #8
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
5e6c: e15b0000 cmp fp, r0
5e70: 33a04000 movcc r4, #0
5e74: 3a000004 bcc 5e8c <rtems_stack_checker_is_blown+0x34>
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
5e78: e59340c0 ldr r4, [r3, #192] ; 0xc0
5e7c: e0804004 add r4, r0, r4
5e80: e15b0004 cmp fp, r4
5e84: 83a04000 movhi r4, #0
5e88: 93a04001 movls r4, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
5e8c: e59f3050 ldr r3, [pc, #80] ; 5ee4 <rtems_stack_checker_is_blown+0x8c>
5e90: e5933000 ldr r3, [r3]
5e94: e3530000 cmp r3, #0
5e98: 03a01001 moveq r1, #1
5e9c: 0a000005 beq 5eb8 <rtems_stack_checker_is_blown+0x60>
pattern_ok = (!memcmp(
5ea0: e59f1040 ldr r1, [pc, #64] ; 5ee8 <rtems_stack_checker_is_blown+0x90>
5ea4: e2800008 add r0, r0, #8
5ea8: e3a02010 mov r2, #16
5eac: eb00e899 bl 40118 <memcmp>
5eb0: e2701001 rsbs r1, r0, #1
5eb4: 33a01000 movcc r1, #0
}
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
if ( sp_ok && pattern_ok )
5eb8: e3540000 cmp r4, #0
5ebc: 0a000002 beq 5ecc <rtems_stack_checker_is_blown+0x74>
5ec0: e3510000 cmp r1, #0
5ec4: 13a00000 movne r0, #0
5ec8: 18bd8810 popne {r4, fp, pc}
return false;
/*
* Let's report as much as we can.
*/
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
5ecc: e59f300c ldr r3, [pc, #12] ; 5ee0 <rtems_stack_checker_is_blown+0x88><== NOT EXECUTED
5ed0: e5930000 ldr r0, [r3] <== NOT EXECUTED
5ed4: ebffffb4 bl 5dac <Stack_check_report_blown_task> <== NOT EXECUTED
5ed8: e3a00001 mov r0, #1 <== NOT EXECUTED
return true;
}
5edc: e8bd8810 pop {r4, fp, pc} <== NOT EXECUTED
00005d9c <rtems_stack_checker_report_usage>:
void rtems_stack_checker_report_usage( void )
{
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
5d9c: e59f1004 ldr r1, [pc, #4] ; 5da8 <rtems_stack_checker_report_usage+0xc><== NOT EXECUTED
5da0: e3a00000 mov r0, #0 <== NOT EXECUTED
5da4: eaffffe3 b 5d38 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
00005d38 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
5d38: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
print_context = context;
5d3c: e59f4048 ldr r4, [pc, #72] ; 5d8c <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
)
{
5d40: e1a05001 mov r5, r1 <== NOT EXECUTED
5d44: e1a06000 mov r6, r0 <== NOT EXECUTED
print_context = context;
print_handler = print;
5d48: 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;
5d4c: e5840008 str r0, [r4, #8] <== NOT EXECUTED
print_handler = print;
(*print)( context, "Stack usage by thread\n");
5d50: e59f1038 ldr r1, [pc, #56] ; 5d90 <rtems_stack_checker_report_usage_with_plugin+0x58><== NOT EXECUTED
5d54: e1a0e00f mov lr, pc <== NOT EXECUTED
5d58: e12fff15 bx r5 <== NOT EXECUTED
(*print)( context,
5d5c: e59f1030 ldr r1, [pc, #48] ; 5d94 <rtems_stack_checker_report_usage_with_plugin+0x5c><== NOT EXECUTED
5d60: e1a00006 mov r0, r6 <== NOT EXECUTED
5d64: e1a0e00f mov lr, pc <== NOT EXECUTED
5d68: 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 );
5d6c: e59f0024 ldr r0, [pc, #36] ; 5d98 <rtems_stack_checker_report_usage_with_plugin+0x60><== NOT EXECUTED
5d70: eb001c02 bl cd80 <rtems_iterate_over_all_threads> <== NOT EXECUTED
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
5d74: e3e00000 mvn r0, #0 <== NOT EXECUTED
5d78: ebffff9f bl 5bfc <Stack_check_Dump_threads_usage> <== NOT EXECUTED
print_context = NULL;
5d7c: e3a03000 mov r3, #0 <== NOT EXECUTED
print_handler = NULL;
5d80: 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;
5d84: e5843008 str r3, [r4, #8] <== NOT EXECUTED
print_handler = NULL;
}
5d88: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
0000ad80 <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
ad80: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr}
double result;
char *end;
if ( !n )
ad84: e2516000 subs r6, r1, #0
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
ad88: e1a07000 mov r7, r0
ad8c: e1a08002 mov r8, r2
double result;
char *end;
if ( !n )
ad90: 03a00009 moveq r0, #9
ad94: 0a00002e beq ae54 <rtems_string_to_double+0xd4>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ad98: eb00084f bl cedc <__errno>
ad9c: e3a03000 mov r3, #0
ada0: e5803000 str r3, [r0]
*n = 0;
ada4: e3a04000 mov r4, #0
ada8: e3a03000 mov r3, #0
adac: e8860018 stm r6, {r3, r4}
result = strtod( s, &end );
adb0: e1a00007 mov r0, r7
adb4: e1a0100d mov r1, sp
adb8: eb0013c5 bl fcd4 <strtod>
if ( endptr )
adbc: e3580000 cmp r8, #0
*endptr = end;
adc0: 159d3000 ldrne r3, [sp]
adc4: 15883000 strne r3, [r8]
if ( end == s )
adc8: e59d3000 ldr r3, [sp]
adcc: e1530007 cmp r3, r7
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
add0: e1a04000 mov r4, r0
add4: e1a05001 mov r5, r1
if ( endptr )
*endptr = end;
if ( end == s )
add8: 03a0000b moveq r0, #11
addc: 0a00001c beq ae54 <rtems_string_to_double+0xd4>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ade0: eb00083d bl cedc <__errno>
ade4: e5903000 ldr r3, [r0]
ade8: e3530022 cmp r3, #34 ; 0x22
adec: 1a000014 bne ae44 <rtems_string_to_double+0xc4>
adf0: e1a00004 mov r0, r4
adf4: e1a01005 mov r1, r5
adf8: e3a02000 mov r2, #0
adfc: e3a03000 mov r3, #0
ae00: ebffdf79 bl 2bec <__cmpdf2>
ae04: e3500000 cmp r0, #0
ae08: 0a000010 beq ae50 <rtems_string_to_double+0xd0>
ae0c: e1a00004 mov r0, r4
ae10: e1a01005 mov r1, r5
ae14: e3e02000 mvn r2, #0
ae18: e59f3038 ldr r3, [pc, #56] ; ae58 <rtems_string_to_double+0xd8>
ae1c: ebffdf6e bl 2bdc <__gedf2>
ae20: e3500000 cmp r0, #0
ae24: ca000009 bgt ae50 <rtems_string_to_double+0xd0>
ae28: e1a00004 mov r0, r4 <== NOT EXECUTED
ae2c: e1a01005 mov r1, r5 <== NOT EXECUTED
ae30: e3e02000 mvn r2, #0 <== NOT EXECUTED
ae34: e3e03601 mvn r3, #1048576 ; 0x100000 <== NOT EXECUTED
ae38: ebffdf69 bl 2be4 <__ledf2> <== NOT EXECUTED
ae3c: e3500000 cmp r0, #0 <== NOT EXECUTED
ae40: ba000002 blt ae50 <rtems_string_to_double+0xd0> <== NOT EXECUTED
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
ae44: e8860030 stm r6, {r4, r5}
ae48: e3a00000 mov r0, #0
return RTEMS_SUCCESSFUL;
ae4c: ea000000 b ae54 <rtems_string_to_double+0xd4>
ae50: e3a0000a mov r0, #10
}
ae54: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc}
0000ae5c <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
ae5c: e92d40f1 push {r0, r4, r5, r6, r7, lr}
float result;
char *end;
if ( !n )
ae60: e2514000 subs r4, r1, #0
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
ae64: e1a05000 mov r5, r0
ae68: e1a07002 mov r7, r2
float result;
char *end;
if ( !n )
ae6c: 03a00009 moveq r0, #9
ae70: 0a000026 beq af10 <rtems_string_to_float+0xb4>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ae74: eb000818 bl cedc <__errno>
ae78: e3a03000 mov r3, #0
ae7c: e5803000 str r3, [r0]
*n = 0;
ae80: e3a03000 mov r3, #0
ae84: e5843000 str r3, [r4]
result = strtof( s, &end );
ae88: e1a00005 mov r0, r5
ae8c: e1a0100d mov r1, sp
ae90: eb00137c bl fc88 <strtof>
if ( endptr )
ae94: e3570000 cmp r7, #0
*endptr = end;
ae98: 159d3000 ldrne r3, [sp]
ae9c: 15873000 strne r3, [r7]
if ( end == s )
aea0: e59d3000 ldr r3, [sp]
aea4: e1530005 cmp r3, r5
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtof( s, &end );
aea8: e1a06000 mov r6, r0
if ( endptr )
*endptr = end;
if ( end == s )
aeac: 03a0000b moveq r0, #11
aeb0: 0a000016 beq af10 <rtems_string_to_float+0xb4>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
aeb4: eb000808 bl cedc <__errno>
aeb8: e5903000 ldr r3, [r0]
aebc: e3530022 cmp r3, #34 ; 0x22
aec0: 1a00000e bne af00 <rtems_string_to_float+0xa4>
aec4: e1a00006 mov r0, r6
aec8: e3a01000 mov r1, #0
aecc: ebffdf91 bl 2d18 <__cmpsf2>
aed0: e3500000 cmp r0, #0
aed4: 0a00000c beq af0c <rtems_string_to_float+0xb0>
aed8: e1a00006 mov r0, r6
aedc: e59f1030 ldr r1, [pc, #48] ; af14 <rtems_string_to_float+0xb8>
aee0: ebffdf88 bl 2d08 <__gesf2>
aee4: e3500000 cmp r0, #0
aee8: ca000007 bgt af0c <rtems_string_to_float+0xb0>
aeec: e1a00006 mov r0, r6 <== NOT EXECUTED
aef0: e3e01502 mvn r1, #8388608 ; 0x800000 <== NOT EXECUTED
aef4: ebffdf85 bl 2d10 <__lesf2> <== NOT EXECUTED
aef8: e3500000 cmp r0, #0 <== NOT EXECUTED
aefc: ba000002 blt af0c <rtems_string_to_float+0xb0> <== NOT EXECUTED
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
*n = result;
af00: e5846000 str r6, [r4]
af04: e3a00000 mov r0, #0
return RTEMS_SUCCESSFUL;
af08: ea000000 b af10 <rtems_string_to_float+0xb4>
af0c: e3a0000a mov r0, #10
}
af10: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
0001c1c4 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
1c1c4: e92d40f1 push {r0, r4, r5, r6, r7, lr}
long result;
char *end;
if ( !n )
1c1c8: e2514000 subs r4, r1, #0
const char *s,
int *n,
char **endptr,
int base
)
{
1c1cc: e1a05000 mov r5, r0
1c1d0: e1a06002 mov r6, r2
1c1d4: e1a07003 mov r7, r3
long result;
char *end;
if ( !n )
1c1d8: 03a00009 moveq r0, #9
1c1dc: 0a00001c beq 1c254 <rtems_string_to_int+0x90>
return RTEMS_INVALID_ADDRESS;
errno = 0;
1c1e0: eb008346 bl 3cf00 <__errno>
1c1e4: e3a03000 mov r3, #0
1c1e8: e5803000 str r3, [r0]
*n = 0;
result = strtol( s, &end, base );
1c1ec: e1a02007 mov r2, r7
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
1c1f0: e5843000 str r3, [r4]
result = strtol( s, &end, base );
1c1f4: e1a00005 mov r0, r5
1c1f8: e1a0100d mov r1, sp
1c1fc: eb00a23b bl 44af0 <strtol>
if ( endptr )
1c200: e3560000 cmp r6, #0
*endptr = end;
1c204: 159d3000 ldrne r3, [sp]
1c208: 15863000 strne r3, [r6]
if ( end == s )
1c20c: e59d3000 ldr r3, [sp]
1c210: e1530005 cmp r3, r5
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
1c214: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
if ( end == s )
1c218: 03a0000b moveq r0, #11
1c21c: 0a00000c beq 1c254 <rtems_string_to_int+0x90>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1c220: eb008336 bl 3cf00 <__errno>
1c224: e5903000 ldr r3, [r0]
1c228: e3530022 cmp r3, #34 ; 0x22
1c22c: 1a000004 bne 1c244 <rtems_string_to_int+0x80>
1c230: e3770106 cmn r7, #-2147483647 ; 0x80000001
1c234: 13570000 cmpne r7, #0
1c238: 0a000004 beq 1c250 <rtems_string_to_int+0x8c>
1c23c: e3570102 cmp r7, #-2147483648 ; 0x80000000 <== NOT EXECUTED
1c240: 0a000002 beq 1c250 <rtems_string_to_int+0x8c> <== NOT EXECUTED
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
1c244: e5847000 str r7, [r4]
1c248: e3a00000 mov r0, #0
return RTEMS_SUCCESSFUL;
1c24c: ea000000 b 1c254 <rtems_string_to_int+0x90>
1c250: e3a0000a mov r0, #10
}
1c254: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
0001c260 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
1c260: e92d40f1 push {r0, r4, r5, r6, r7, lr}
unsigned long result;
char *end;
if ( !n )
1c264: e2514000 subs r4, r1, #0
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
1c268: e1a05000 mov r5, r0
1c26c: e1a06002 mov r6, r2
1c270: e1a07003 mov r7, r3
unsigned long result;
char *end;
if ( !n )
1c274: 03a00009 moveq r0, #9
1c278: 0a00001e beq 1c2f8 <rtems_string_to_unsigned_char+0x98>
return RTEMS_INVALID_ADDRESS;
errno = 0;
1c27c: eb00831f bl 3cf00 <__errno>
1c280: e3a03000 mov r3, #0
1c284: e5803000 str r3, [r0]
*n = 0;
result = strtoul( s, &end, base );
1c288: e1a02007 mov r2, r7
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
1c28c: e5c43000 strb r3, [r4]
result = strtoul( s, &end, base );
1c290: e1a00005 mov r0, r5
1c294: e1a0100d mov r1, sp
1c298: eb00a331 bl 44f64 <strtoul>
if ( endptr )
1c29c: e3560000 cmp r6, #0
*endptr = end;
1c2a0: 159d3000 ldrne r3, [sp]
1c2a4: 15863000 strne r3, [r6]
if ( end == s )
1c2a8: e59d3000 ldr r3, [sp]
1c2ac: e1530005 cmp r3, r5
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
1c2b0: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
if ( end == s )
1c2b4: 03a0000b moveq r0, #11
1c2b8: 0a00000e beq 1c2f8 <rtems_string_to_unsigned_char+0x98>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1c2bc: eb00830f bl 3cf00 <__errno>
1c2c0: e5903000 ldr r3, [r0]
1c2c4: e3530022 cmp r3, #34 ; 0x22
1c2c8: 1a000002 bne 1c2d8 <rtems_string_to_unsigned_char+0x78>
1c2cc: e2473001 sub r3, r7, #1 <== NOT EXECUTED
1c2d0: e3730003 cmn r3, #3 <== NOT EXECUTED
1c2d4: 8a000006 bhi 1c2f4 <rtems_string_to_unsigned_char+0x94> <== NOT EXECUTED
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
1c2d8: e35700ff cmp r7, #255 ; 0xff
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
1c2dc: 95c47000 strbls r7, [r4]
1c2e0: 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 ) {
1c2e4: 9a000003 bls 1c2f8 <rtems_string_to_unsigned_char+0x98>
errno = ERANGE;
1c2e8: eb008304 bl 3cf00 <__errno> <== NOT EXECUTED
1c2ec: e3a03022 mov r3, #34 ; 0x22 <== NOT EXECUTED
1c2f0: e5803000 str r3, [r0] <== NOT EXECUTED
1c2f4: e3a0000a mov r0, #10 <== NOT EXECUTED
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
1c2f8: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
000042c4 <rtems_termios_baud_to_index>:
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
42c4: e3500009 cmp r0, #9
42c8: 012fff1e bxeq lr
42cc: ca000016 bgt 432c <rtems_termios_baud_to_index+0x68>
42d0: e3500004 cmp r0, #4
42d4: 012fff1e bxeq lr
42d8: ca00000a bgt 4308 <rtems_termios_baud_to_index+0x44>
42dc: e3500001 cmp r0, #1
42e0: 012fff1e bxeq lr
42e4: ca000002 bgt 42f4 <rtems_termios_baud_to_index+0x30>
42e8: e3500000 cmp r0, #0
42ec: 012fff1e bxeq lr
42f0: ea000030 b 43b8 <rtems_termios_baud_to_index+0xf4>
42f4: e3500002 cmp r0, #2 <== NOT EXECUTED
42f8: 012fff1e bxeq lr <== NOT EXECUTED
42fc: e3500003 cmp r0, #3 <== NOT EXECUTED
4300: 1a00002c bne 43b8 <rtems_termios_baud_to_index+0xf4> <== NOT EXECUTED
4304: e12fff1e bx lr <== NOT EXECUTED
4308: e3500006 cmp r0, #6 <== NOT EXECUTED
430c: 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;
4310: b3a00005 movlt r0, #5 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
4314: b12fff1e bxlt lr <== NOT EXECUTED
4318: e3500007 cmp r0, #7 <== NOT EXECUTED
431c: 012fff1e bxeq lr <== NOT EXECUTED
4320: e3500008 cmp r0, #8 <== NOT EXECUTED
4324: 1a000023 bne 43b8 <rtems_termios_baud_to_index+0xf4> <== NOT EXECUTED
4328: e12fff1e bx lr <== NOT EXECUTED
432c: e350000e cmp r0, #14 <== NOT EXECUTED
4330: 012fff1e bxeq lr <== NOT EXECUTED
4334: ca000008 bgt 435c <rtems_termios_baud_to_index+0x98> <== NOT EXECUTED
4338: e350000b cmp r0, #11 <== NOT EXECUTED
433c: 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;
4340: b3a0000a movlt r0, #10 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
4344: b12fff1e bxlt lr <== NOT EXECUTED
4348: e350000c cmp r0, #12 <== NOT EXECUTED
434c: 012fff1e bxeq lr <== NOT EXECUTED
4350: e350000d cmp r0, #13 <== NOT EXECUTED
4354: 1a000017 bne 43b8 <rtems_termios_baud_to_index+0xf4> <== NOT EXECUTED
4358: e12fff1e bx lr <== NOT EXECUTED
435c: e59f305c ldr r3, [pc, #92] ; 43c0 <rtems_termios_baud_to_index+0xfc><== NOT EXECUTED
4360: 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;
4364: 03a00011 moveq r0, #17 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
4368: 012fff1e bxeq lr <== NOT EXECUTED
436c: ca000005 bgt 4388 <rtems_termios_baud_to_index+0xc4> <== NOT EXECUTED
4370: e350000f cmp r0, #15 <== NOT EXECUTED
4374: 012fff1e bxeq lr <== NOT EXECUTED
4378: e2433001 sub r3, r3, #1 <== NOT EXECUTED
437c: e1500003 cmp r0, r3 <== NOT EXECUTED
4380: 1a00000c bne 43b8 <rtems_termios_baud_to_index+0xf4> <== NOT EXECUTED
4384: ea000007 b 43a8 <rtems_termios_baud_to_index+0xe4> <== NOT EXECUTED
4388: e59f3034 ldr r3, [pc, #52] ; 43c4 <rtems_termios_baud_to_index+0x100><== NOT EXECUTED
438c: 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;
4390: 03a00012 moveq r0, #18 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
4394: 012fff1e bxeq lr <== NOT EXECUTED
4398: e2833001 add r3, r3, #1 <== NOT EXECUTED
439c: e1500003 cmp r0, r3 <== NOT EXECUTED
43a0: 1a000004 bne 43b8 <rtems_termios_baud_to_index+0xf4> <== NOT EXECUTED
43a4: ea000001 b 43b0 <rtems_termios_baud_to_index+0xec> <== 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;
43a8: e3a00010 mov r0, #16 <== NOT EXECUTED
case B57600: baud_index = 16; break;
43ac: e12fff1e bx lr <== NOT EXECUTED
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
43b0: e3a00013 mov r0, #19 <== NOT EXECUTED
case B460800: baud_index = 19; break;
43b4: e12fff1e bx lr <== NOT EXECUTED
43b8: e3e00000 mvn r0, #0
default: baud_index = -1; break;
}
return baud_index;
}
43bc: e12fff1e bx lr
00002e0c <rtems_termios_bufsize>:
int cbufsize,
int raw_input,
int raw_output
)
{
rtems_termios_cbufsize = cbufsize;
2e0c: e59f3008 ldr r3, [pc, #8] ; 2e1c <rtems_termios_bufsize+0x10><== NOT EXECUTED
2e10: 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;
}
2e14: e3a00000 mov r0, #0 <== NOT EXECUTED
2e18: e12fff1e bx lr <== NOT EXECUTED
00004204 <rtems_termios_close>:
{
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);
4204: e59f2180 ldr r2, [pc, #384] ; 438c <rtems_termios_close+0x188>
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
4208: e5903000 ldr r3, [r0]
rtems_status_code sc;
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
420c: e3a01000 mov r1, #0
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
4210: e92d4030 push {r4, r5, lr}
4214: e1a05000 mov r5, 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);
4218: e5920000 ldr r0, [r2]
421c: e1a02001 mov r2, r1
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
4220: e5934034 ldr r4, [r3, #52] ; 0x34
rtems_status_code sc;
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4224: eb0003dc bl 519c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
4228: e3500000 cmp r0, #0
422c: 1a000022 bne 42bc <rtems_termios_close+0xb8>
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
4230: e5943008 ldr r3, [r4, #8]
4234: e2433001 sub r3, r3, #1
4238: e3530000 cmp r3, #0
423c: e5843008 str r3, [r4, #8]
4240: 1a00004c bne 4378 <rtems_termios_close+0x174>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
4244: e59420cc ldr r2, [r4, #204] ; 0xcc
4248: e59f3140 ldr r3, [pc, #320] ; 4390 <rtems_termios_close+0x18c>
424c: e0833282 add r3, r3, r2, lsl #5
4250: e5931004 ldr r1, [r3, #4]
4254: e3510000 cmp r1, #0
4258: 0a000003 beq 426c <rtems_termios_close+0x68>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
425c: e1a00004 mov r0, r4 <== NOT EXECUTED
4260: e1a0e00f mov lr, pc <== NOT EXECUTED
4264: e12fff11 bx r1 <== NOT EXECUTED
4268: ea000006 b 4288 <rtems_termios_close+0x84> <== NOT EXECUTED
}
else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
426c: e5940018 ldr r0, [r4, #24]
4270: e1a02001 mov r2, r1
4274: eb0003c8 bl 519c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
4278: e3500000 cmp r0, #0
427c: 1a00000e bne 42bc <rtems_termios_close+0xb8>
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
4280: e1a00004 mov r0, r4
4284: ebfffe05 bl 3aa0 <drainOutput>
}
if (tty->device.outputUsesInterrupts
4288: e59430b4 ldr r3, [r4, #180] ; 0xb4
428c: e3530002 cmp r3, #2
4290: 1a00000a bne 42c0 <rtems_termios_close+0xbc>
== TERMIOS_TASK_DRIVEN) {
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send(
4294: e59400c4 ldr r0, [r4, #196] ; 0xc4 <== NOT EXECUTED
4298: e3a01001 mov r1, #1 <== NOT EXECUTED
429c: eb0002ab bl 4d50 <rtems_event_send> <== NOT EXECUTED
tty->rxTaskId,
TERMIOS_RX_TERMINATE_EVENT);
if (sc != RTEMS_SUCCESSFUL)
42a0: e3500000 cmp r0, #0 <== NOT EXECUTED
42a4: 1a000004 bne 42bc <rtems_termios_close+0xb8> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_event_send(
42a8: e59400c8 ldr r0, [r4, #200] ; 0xc8 <== NOT EXECUTED
42ac: e3a01001 mov r1, #1 <== NOT EXECUTED
42b0: eb0002a6 bl 4d50 <rtems_event_send> <== NOT EXECUTED
tty->txTaskId,
TERMIOS_TX_TERMINATE_EVENT);
if (sc != RTEMS_SUCCESSFUL)
42b4: e3500000 cmp r0, #0 <== NOT EXECUTED
42b8: 0a000000 beq 42c0 <rtems_termios_close+0xbc> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
42bc: eb000539 bl 57a8 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
if (tty->device.lastClose)
42c0: e594309c ldr r3, [r4, #156] ; 0x9c
42c4: e3530000 cmp r3, #0
(*tty->device.lastClose)(tty->major, tty->minor, arg);
42c8: 11a02005 movne r2, r5
42cc: 1284000c addne r0, r4, #12
42d0: 18900003 ldmne r0, {r0, r1}
42d4: 11a0e00f movne lr, pc
42d8: 112fff13 bxne r3
if (tty->forw == NULL) {
42dc: e894000c ldm r4, {r2, r3}
42e0: e3520000 cmp r2, #0
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
}
}
else {
tty->forw->back = tty->back;
42e4: 15823004 strne r3, [r2, #4]
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
42e8: 1a000003 bne 42fc <rtems_termios_close+0xf8>
rtems_termios_ttyTail = tty->back;
42ec: e59f10a0 ldr r1, [pc, #160] ; 4394 <rtems_termios_close+0x190>
if ( rtems_termios_ttyTail != NULL ) {
42f0: e3530000 cmp r3, #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;
42f4: e5813000 str r3, [r1]
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
42f8: 15832000 strne r2, [r3]
}
}
else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
42fc: e5942004 ldr r2, [r4, #4]
4300: e5943000 ldr r3, [r4]
4304: e3520000 cmp r2, #0
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
}
else {
tty->back->forw = tty->forw;
4308: 15823000 strne r3, [r2]
}
}
else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
430c: 1a000003 bne 4320 <rtems_termios_close+0x11c>
rtems_termios_ttyHead = tty->forw;
4310: e59f1080 ldr r1, [pc, #128] ; 4398 <rtems_termios_close+0x194>
if ( rtems_termios_ttyHead != NULL ) {
4314: e3530000 cmp r3, #0
}
else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
4318: e5813000 str r3, [r1]
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
431c: 15832004 strne r2, [r3, #4]
}
}
else {
tty->back->forw = tty->forw;
}
rtems_semaphore_delete (tty->isem);
4320: e5940014 ldr r0, [r4, #20]
4324: eb000375 bl 5100 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
4328: e5940018 ldr r0, [r4, #24]
432c: eb000373 bl 5100 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
4330: e594008c ldr r0, [r4, #140] ; 0x8c
4334: eb000371 bl 5100 <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
4338: e59430a0 ldr r3, [r4, #160] ; 0xa0
433c: e3530000 cmp r3, #0
4340: 0a000002 beq 4350 <rtems_termios_close+0x14c>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
4344: e59430b4 ldr r3, [r4, #180] ; 0xb4
4348: e3530002 cmp r3, #2
434c: 1a000001 bne 4358 <rtems_termios_close+0x154>
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
4350: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED
4354: eb000369 bl 5100 <rtems_semaphore_delete> <== NOT EXECUTED
free (tty->rawInBuf.theBuf);
4358: e5940058 ldr r0, [r4, #88] ; 0x58
435c: ebfff6db bl 1ed0 <free>
free (tty->rawOutBuf.theBuf);
4360: e594007c ldr r0, [r4, #124] ; 0x7c
4364: ebfff6d9 bl 1ed0 <free>
free (tty->cbuf);
4368: e594001c ldr r0, [r4, #28]
436c: ebfff6d7 bl 1ed0 <free>
free (tty);
4370: e1a00004 mov r0, r4
4374: ebfff6d5 bl 1ed0 <free>
}
rtems_semaphore_release (rtems_termios_ttyMutex);
4378: e59f300c ldr r3, [pc, #12] ; 438c <rtems_termios_close+0x188>
437c: e5930000 ldr r0, [r3]
4380: eb0003cb bl 52b4 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
4384: e3a00000 mov r0, #0
4388: e8bd8030 pop {r4, r5, pc}
00003008 <rtems_termios_dequeue_characters>:
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
3008: e590c090 ldr ip, [r0, #144] ; 0x90 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
300c: e59020b4 ldr r2, [r0, #180] ; 0xb4 <== NOT EXECUTED
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
3010: e08c1001 add r1, ip, r1 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
3014: 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)
{
3018: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
301c: e5801090 str r1, [r0, #144] ; 0x90 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
3020: 1a000005 bne 303c <rtems_termios_dequeue_characters+0x34> <== NOT EXECUTED
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId,
3024: e59000c8 ldr r0, [r0, #200] ; 0xc8 <== NOT EXECUTED
3028: e1a01002 mov r1, r2 <== NOT EXECUTED
302c: eb000747 bl 4d50 <rtems_event_send> <== NOT EXECUTED
TERMIOS_TX_START_EVENT);
if (sc != RTEMS_SUCCESSFUL)
3030: e3500000 cmp r0, #0 <== NOT EXECUTED
3034: 0a00000c beq 306c <rtems_termios_dequeue_characters+0x64> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
3038: eb0009da bl 57a8 <rtems_fatal_error_occurred> <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
else if (tty->t_line == PPPDISC ) {
303c: e59030cc ldr r3, [r0, #204] ; 0xcc <== NOT EXECUTED
3040: e3530005 cmp r3, #5 <== NOT EXECUTED
3044: 1a000006 bne 3064 <rtems_termios_dequeue_characters+0x5c> <== NOT EXECUTED
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
3048: e59f3024 ldr r3, [pc, #36] ; 3074 <rtems_termios_dequeue_characters+0x6c><== NOT EXECUTED
304c: e59330b4 ldr r3, [r3, #180] ; 0xb4 <== NOT EXECUTED
3050: e3530000 cmp r3, #0 <== NOT EXECUTED
3054: 0a000004 beq 306c <rtems_termios_dequeue_characters+0x64> <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
3058: e1a0e00f mov lr, pc <== NOT EXECUTED
305c: e12fff13 bx r3 <== NOT EXECUTED
3060: ea000001 b 306c <rtems_termios_dequeue_characters+0x64> <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
else {
return rtems_termios_refill_transmitter(tty);
}
}
3064: 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);
3068: eaffff6f b 2e2c <rtems_termios_refill_transmitter> <== NOT EXECUTED
}
}
306c: e3a00000 mov r0, #0 <== NOT EXECUTED
3070: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00003078 <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)
{
3078: e92d4ff7 push {r0, r1, r2, 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) {
307c: e59f32b8 ldr r3, [pc, #696] ; 333c <rtems_termios_enqueue_raw_characters+0x2c4><== 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)
{
3080: e1a04000 mov r4, r0 <== 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) {
3084: e59000cc ldr r0, [r0, #204] ; 0xcc <== NOT EXECUTED
3088: e0830280 add r0, r3, r0, lsl #5 <== NOT EXECUTED
308c: e5906010 ldr r6, [r0, #16] <== NOT EXECUTED
3090: 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)
{
3094: e1a0b001 mov fp, r1 <== 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);
3098: 11a05002 movne r5, r2 <== NOT EXECUTED
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
309c: 11a07003 movne r7, r3 <== 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);
30a0: 13a06000 movne r6, #0 <== 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) {
30a4: 1a00000e bne 30e4 <rtems_termios_enqueue_raw_characters+0x6c><== 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);
30a8: e1a08002 mov r8, r2 <== NOT EXECUTED
30ac: e2843030 add r3, r4, #48 ; 0x30 <== 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,
30b0: e284204a add r2, r4, #74 ; 0x4a <== NOT EXECUTED
30b4: e58d2008 str r2, [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);
30b8: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
30bc: e1a09006 mov r9, r6 <== NOT EXECUTED
30c0: e1a05006 mov r5, r6 <== NOT EXECUTED
30c4: ea000091 b 3310 <rtems_termios_enqueue_raw_characters+0x298><== NOT EXECUTED
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
30c8: e59430cc ldr r3, [r4, #204] ; 0xcc <== NOT EXECUTED
30cc: e7db0006 ldrb r0, [fp, r6] <== NOT EXECUTED
30d0: e0873283 add r3, r7, r3, lsl #5 <== NOT EXECUTED
30d4: e1a0e00f mov lr, pc <== NOT EXECUTED
30d8: e593f010 ldr pc, [r3, #16] <== NOT EXECUTED
30dc: e2866001 add r6, r6, #1 <== NOT EXECUTED
30e0: e2455001 sub r5, r5, #1 <== 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--) {
30e4: e3550000 cmp r5, #0 <== NOT EXECUTED
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
30e8: e1a01004 mov r1, r4 <== 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--) {
30ec: 1afffff5 bne 30c8 <rtems_termios_enqueue_raw_characters+0x50><== NOT EXECUTED
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
30f0: e59430e4 ldr r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
30f4: e3530000 cmp r3, #0 <== NOT EXECUTED
30f8: 1a00008c bne 3330 <rtems_termios_enqueue_raw_characters+0x2b8><== NOT EXECUTED
30fc: e59430dc ldr r3, [r4, #220] ; 0xdc <== NOT EXECUTED
3100: e3530000 cmp r3, #0 <== NOT EXECUTED
3104: 0a000089 beq 3330 <rtems_termios_enqueue_raw_characters+0x2b8><== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
3108: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED
310c: e59410e0 ldr r1, [r4, #224] ; 0xe0 <== NOT EXECUTED
3110: e1a0e00f mov lr, pc <== NOT EXECUTED
3114: e12fff13 bx r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
3118: e3a03001 mov r3, #1 <== NOT EXECUTED
311c: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
3120: ea000083 b 3334 <rtems_termios_enqueue_raw_characters+0x2bc><== NOT EXECUTED
while (len--) {
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
3124: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
3128: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
}
return 0;
}
while (len--) {
c = *buf++;
312c: e7dba006 ldrb sl, [fp, r6] <== NOT EXECUTED
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
3130: 0a00000f beq 3174 <rtems_termios_enqueue_raw_characters+0xfc><== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
3134: e5d4204a ldrb r2, [r4, #74] ; 0x4a <== NOT EXECUTED
3138: e152000a cmp r2, sl <== NOT EXECUTED
313c: e5d43049 ldrb r3, [r4, #73] ; 0x49 <== NOT EXECUTED
3140: 1a000007 bne 3164 <rtems_termios_enqueue_raw_characters+0xec><== NOT EXECUTED
if (c == tty->termios.c_cc[VSTART]) {
3144: e1530002 cmp r3, r2 <== NOT EXECUTED
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
3148: 059430b8 ldreq r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
314c: 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;
3150: 02233010 eoreq r3, r3, #16 <== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
3154: 13833010 orrne r3, r3, #16 <== NOT EXECUTED
3158: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
}
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
315c: e3a09001 mov r9, #1 <== NOT EXECUTED
3160: ea000005 b 317c <rtems_termios_enqueue_raw_characters+0x104><== NOT EXECUTED
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
3164: e153000a cmp r3, sl <== NOT EXECUTED
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
3168: 059430b8 ldreq r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
316c: 03c33010 biceq r3, r3, #16 <== NOT EXECUTED
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
3170: 0afffff8 beq 3158 <rtems_termios_enqueue_raw_characters+0xe0><== NOT EXECUTED
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
3174: e3590000 cmp r9, #0 <== NOT EXECUTED
3178: 0a000015 beq 31d4 <rtems_termios_enqueue_raw_characters+0x15c><== NOT EXECUTED
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
317c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
3180: e2033030 and r3, r3, #48 ; 0x30 <== NOT EXECUTED
3184: e3530020 cmp r3, #32 <== NOT EXECUTED
3188: 1a00005e bne 3308 <rtems_termios_enqueue_raw_characters+0x290><== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
318c: e10f7000 mrs r7, CPSR <== NOT EXECUTED
3190: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED
3194: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
3198: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
319c: 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;
31a0: e3c33020 bic r3, r3, #32 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
31a4: 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;
31a8: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
31ac: 0a000006 beq 31cc <rtems_termios_enqueue_raw_characters+0x154><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
31b0: 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,
31b4: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED
31b8: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
31bc: e0811003 add r1, r1, r3 <== NOT EXECUTED
31c0: e3a02001 mov r2, #1 <== NOT EXECUTED
31c4: e1a0e00f mov lr, pc <== NOT EXECUTED
31c8: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
31cc: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
31d0: ea00004c b 3308 <rtems_termios_enqueue_raw_characters+0x290><== NOT EXECUTED
/* reenable interrupts */
rtems_interrupt_enable(level);
}
}
else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
31d4: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED
31d8: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED
31dc: e2800001 add r0, r0, #1 <== NOT EXECUTED
31e0: eb004e95 bl 16c3c <__umodsi3> <== NOT EXECUTED
31e4: e1a07000 mov r7, r0 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
31e8: e10f2000 mrs r2, CPSR <== NOT EXECUTED
31ec: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED
31f0: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
31f4: e58d2000 str r2, [sp] <== NOT EXECUTED
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
31f8: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED
31fc: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED
3200: e0630000 rsb r0, r3, r0 <== NOT EXECUTED
3204: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED
3208: e0800007 add r0, r0, r7 <== NOT EXECUTED
320c: eb004e8a bl 16c3c <__umodsi3> <== NOT EXECUTED
% tty->rawInBuf.Size)
> tty->highwater) &&
3210: e59430c0 ldr r3, [r4, #192] ; 0xc0 <== NOT EXECUTED
3214: e1500003 cmp r0, r3 <== NOT EXECUTED
3218: 9a000025 bls 32b4 <rtems_termios_enqueue_raw_characters+0x23c><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
321c: 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)
3220: e3130001 tst r3, #1 <== NOT EXECUTED
3224: 1a000022 bne 32b4 <rtems_termios_enqueue_raw_characters+0x23c><== NOT EXECUTED
% tty->rawInBuf.Size)
> tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
3228: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
322c: e3833001 orr r3, r3, #1 <== NOT EXECUTED
3230: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
3234: e59f3104 ldr r3, [pc, #260] ; 3340 <rtems_termios_enqueue_raw_characters+0x2c8><== NOT EXECUTED
3238: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
323c: e0023003 and r3, r2, r3 <== NOT EXECUTED
3240: e3530b01 cmp r3, #1024 ; 0x400 <== NOT EXECUTED
3244: 1a00000e bne 3284 <rtems_termios_enqueue_raw_characters+0x20c><== NOT EXECUTED
== (FL_MDXOF ) ){
if ((tty->flow_ctrl & FL_OSTOP) ||
3248: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
324c: e3130020 tst r3, #32 <== NOT EXECUTED
3250: 1a000002 bne 3260 <rtems_termios_enqueue_raw_characters+0x1e8><== NOT EXECUTED
(tty->rawOutBufState == rob_idle)) {
3254: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
3258: e3530000 cmp r3, #0 <== NOT EXECUTED
325c: 1a000014 bne 32b4 <rtems_termios_enqueue_raw_characters+0x23c><== NOT EXECUTED
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
3260: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
3264: e3833002 orr r3, r3, #2 <== NOT EXECUTED
3268: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
326c: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
3270: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED
3274: e3a02001 mov r2, #1 <== NOT EXECUTED
3278: e1a0e00f mov lr, pc <== NOT EXECUTED
327c: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
3280: ea00000b b 32b4 <rtems_termios_enqueue_raw_characters+0x23c><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]),
1);
}
}
else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))
3284: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
3288: e2033f41 and r3, r3, #260 ; 0x104 <== NOT EXECUTED
328c: e3530c01 cmp r3, #256 ; 0x100 <== NOT EXECUTED
3290: 1a000007 bne 32b4 <rtems_termios_enqueue_raw_characters+0x23c><== NOT EXECUTED
== (FL_MDRTS ) ) {
tty->flow_ctrl |= FL_IRTSOFF;
3294: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
3298: 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;
329c: e3822004 orr r2, r2, #4 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
32a0: e3530000 cmp r3, #0 <== NOT EXECUTED
1);
}
}
else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))
== (FL_MDRTS ) ) {
tty->flow_ctrl |= FL_IRTSOFF;
32a4: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
tty->device.stopRemoteTx(tty->minor);
32a8: 15940010 ldrne r0, [r4, #16] <== NOT EXECUTED
32ac: 11a0e00f movne lr, pc <== NOT EXECUTED
32b0: 112fff13 bxne r3 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
32b4: e59d3000 ldr r3, [sp] <== NOT EXECUTED
32b8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
32bc: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED
32c0: e1570003 cmp r7, r3 <== NOT EXECUTED
dropped++;
32c4: 02855001 addeq r5, r5, #1 <== NOT EXECUTED
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
32c8: 0a00000e beq 3308 <rtems_termios_enqueue_raw_characters+0x290><== NOT EXECUTED
dropped++;
}
else {
tty->rawInBuf.theBuf[newTail] = c;
32cc: e5943058 ldr r3, [r4, #88] ; 0x58 <== NOT EXECUTED
32d0: e7c3a007 strb sl, [r3, r7] <== 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 )) {
32d4: e59430e4 ldr r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
32d8: e3530000 cmp r3, #0 <== NOT EXECUTED
if (newTail == tty->rawInBuf.Head) {
dropped++;
}
else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
32dc: e5847060 str r7, [r4, #96] ; 0x60 <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
32e0: 1a000008 bne 3308 <rtems_termios_enqueue_raw_characters+0x290><== NOT EXECUTED
32e4: e59430dc ldr r3, [r4, #220] ; 0xdc <== NOT EXECUTED
32e8: e3530000 cmp r3, #0 <== NOT EXECUTED
32ec: 0a000005 beq 3308 <rtems_termios_enqueue_raw_characters+0x290><== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
32f0: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
32f4: e59410e0 ldr r1, [r4, #224] ; 0xe0 <== NOT EXECUTED
32f8: e1a0e00f mov lr, pc <== NOT EXECUTED
32fc: e12fff13 bx r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
3300: e3a02001 mov r2, #1 <== NOT EXECUTED
3304: e58420e4 str r2, [r4, #228] ; 0xe4 <== NOT EXECUTED
3308: e2866001 add r6, r6, #1 <== NOT EXECUTED
330c: e2488001 sub r8, r8, #1 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
3310: e3580000 cmp r8, #0 <== NOT EXECUTED
3314: 1affff82 bne 3124 <rtems_termios_enqueue_raw_characters+0xac><== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
}
}
}
tty->rawInBufDropped += dropped;
3318: e5943078 ldr r3, [r4, #120] ; 0x78 <== NOT EXECUTED
331c: e0833005 add r3, r3, r5 <== NOT EXECUTED
3320: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
3324: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED
3328: eb0007e1 bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
return dropped;
332c: ea000000 b 3334 <rtems_termios_enqueue_raw_characters+0x2bc><== NOT EXECUTED
3330: e3a05000 mov r5, #0 <== NOT EXECUTED
}
3334: e1a00005 mov r0, r5 <== NOT EXECUTED
3338: e8bd8ffe pop {r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}<== NOT EXECUTED
00003e5c <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;
3e5c: e5903000 ldr r3, [r0]
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
3e60: e3a01000 mov r1, #0
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
3e64: e92d41f0 push {r4, r5, r6, r7, r8, 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;
3e68: 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;
3e6c: e5934034 ldr r4, [r3, #52] ; 0x34
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
3e70: e1a05000 mov r5, 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);
3e74: e1a02001 mov r2, r1
3e78: e5940018 ldr r0, [r4, #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;
3e7c: e5957008 ldr r7, [r5, #8]
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3e80: eb0004c5 bl 519c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
3e84: e2506000 subs r6, r0, #0
3e88: 1a0000d7 bne 41ec <rtems_termios_ioctl+0x390>
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
3e8c: e5953004 ldr r3, [r5, #4]
3e90: e3530004 cmp r3, #4
3e94: 0a0000ab beq 4148 <rtems_termios_ioctl+0x2ec>
3e98: 8a000005 bhi 3eb4 <rtems_termios_ioctl+0x58>
3e9c: e3530002 cmp r3, #2
3ea0: 0a000029 beq 3f4c <rtems_termios_ioctl+0xf0>
3ea4: 8a0000a0 bhi 412c <rtems_termios_ioctl+0x2d0>
3ea8: e3530001 cmp r3, #1
3eac: 1a000010 bne 3ef4 <rtems_termios_ioctl+0x98>
3eb0: ea00001b b 3f24 <rtems_termios_ioctl+0xc8>
3eb4: e59f233c ldr r2, [pc, #828] ; 41f8 <rtems_termios_ioctl+0x39c><== NOT EXECUTED
3eb8: e1530002 cmp r3, r2 <== NOT EXECUTED
3ebc: 0a0000bd beq 41b8 <rtems_termios_ioctl+0x35c> <== NOT EXECUTED
3ec0: 8a000002 bhi 3ed0 <rtems_termios_ioctl+0x74> <== NOT EXECUTED
3ec4: e3530005 cmp r3, #5 <== NOT EXECUTED
3ec8: 1a000009 bne 3ef4 <rtems_termios_ioctl+0x98> <== NOT EXECUTED
3ecc: ea000099 b 4138 <rtems_termios_ioctl+0x2dc> <== NOT EXECUTED
3ed0: e59f2324 ldr r2, [pc, #804] ; 41fc <rtems_termios_ioctl+0x3a0><== NOT EXECUTED
3ed4: e1530002 cmp r3, r2 <== NOT EXECUTED
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
3ed8: 05953008 ldreq r3, [r5, #8] <== NOT EXECUTED
3edc: 059420cc ldreq r2, [r4, #204] ; 0xcc <== NOT EXECUTED
3ee0: 05832000 streq r2, [r3] <== 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) {
3ee4: 0a0000be beq 41e4 <rtems_termios_ioctl+0x388> <== NOT EXECUTED
3ee8: e2822105 add r2, r2, #1073741825 ; 0x40000001 <== NOT EXECUTED
3eec: e1530002 cmp r3, r2 <== NOT EXECUTED
3ef0: 0a000098 beq 4158 <rtems_termios_ioctl+0x2fc> <== NOT EXECUTED
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
3ef4: e59420cc ldr r2, [r4, #204] ; 0xcc <== NOT EXECUTED
3ef8: e59f3300 ldr r3, [pc, #768] ; 4200 <rtems_termios_ioctl+0x3a4><== NOT EXECUTED
3efc: e0833282 add r3, r3, r2, lsl #5 <== NOT EXECUTED
3f00: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED
3f04: e3530000 cmp r3, #0 <== NOT EXECUTED
3f08: 03a0600a moveq r6, #10 <== NOT EXECUTED
3f0c: 0a0000b4 beq 41e4 <rtems_termios_ioctl+0x388> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
3f10: e1a00004 mov r0, r4 <== NOT EXECUTED
3f14: e1a01005 mov r1, r5 <== NOT EXECUTED
3f18: e1a0e00f mov lr, pc <== NOT EXECUTED
3f1c: e12fff13 bx r3 <== NOT EXECUTED
3f20: ea0000a2 b 41b0 <rtems_termios_ioctl+0x354> <== NOT EXECUTED
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
3f24: e5957008 ldr r7, [r5, #8]
3f28: e284c030 add ip, r4, #48 ; 0x30
3f2c: e8bc000f ldm ip!, {r0, r1, r2, r3}
3f30: e1a0e007 mov lr, r7
3f34: e8ae000f stmia lr!, {r0, r1, r2, r3}
3f38: e8bc000f ldm ip!, {r0, r1, r2, r3}
3f3c: e8ae000f stmia lr!, {r0, r1, r2, r3}
3f40: e59c3000 ldr r3, [ip]
3f44: e58e3000 str r3, [lr]
break;
3f48: ea0000a5 b 41e4 <rtems_termios_ioctl+0x388>
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
3f4c: e595e008 ldr lr, [r5, #8]
3f50: e8be000f ldm lr!, {r0, r1, r2, r3}
3f54: e284c030 add ip, r4, #48 ; 0x30
3f58: e8ac000f stmia ip!, {r0, r1, r2, r3}
3f5c: e8be000f ldm lr!, {r0, r1, r2, r3}
3f60: 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) &&
3f64: e59420b8 ldr r2, [r4, #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;
3f68: 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) &&
3f6c: 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;
3f70: 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) &&
3f74: 0a000019 beq 3fe0 <rtems_termios_ioctl+0x184>
3f78: e5943030 ldr r3, [r4, #48] ; 0x30
3f7c: e3130b01 tst r3, #1024 ; 0x400
3f80: 1a000016 bne 3fe0 <rtems_termios_ioctl+0x184>
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
3f84: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
3f88: e3c33e21 bic r3, r3, #528 ; 0x210 <== NOT EXECUTED
3f8c: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
3f90: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
3f94: e3130020 tst r3, #32 <== NOT EXECUTED
3f98: 0a000010 beq 3fe0 <rtems_termios_ioctl+0x184> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
3f9c: e10f7000 mrs r7, CPSR <== NOT EXECUTED
3fa0: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED
3fa4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
3fa8: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
3fac: e5942094 ldr r2, [r4, #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;
3fb0: e3c33020 bic r3, r3, #32 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
3fb4: 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;
3fb8: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
3fbc: 0a000006 beq 3fdc <rtems_termios_ioctl+0x180> <== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
3fc0: 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,
3fc4: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED
3fc8: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
3fcc: e0811003 add r1, r1, r3 <== NOT EXECUTED
3fd0: e3a02001 mov r2, #1 <== NOT EXECUTED
3fd4: e1a0e00f mov lr, pc <== NOT EXECUTED
3fd8: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3fdc: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
/* reenable interrupts */
rtems_interrupt_enable(level);
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) &&
3fe0: e59430b8 ldr r3, [r4, #184] ; 0xb8
3fe4: e3130b01 tst r3, #1024 ; 0x400
3fe8: 0a000008 beq 4010 <rtems_termios_ioctl+0x1b4>
3fec: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED
3ff0: e3130a01 tst r3, #4096 ; 0x1000 <== NOT EXECUTED
3ff4: 1a000005 bne 4010 <rtems_termios_ioctl+0x1b4> <== NOT EXECUTED
!(tty->termios.c_iflag & IXOFF)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
3ff8: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
3ffc: e3c33b01 bic r3, r3, #1024 ; 0x400 <== NOT EXECUTED
4000: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
4004: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4008: e3c33002 bic r3, r3, #2 <== NOT EXECUTED
400c: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) &&
4010: e59430b8 ldr r3, [r4, #184] ; 0xb8
4014: e3130c01 tst r3, #256 ; 0x100
4018: 0a000010 beq 4060 <rtems_termios_ioctl+0x204>
401c: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED
4020: e3530000 cmp r3, #0 <== NOT EXECUTED
4024: ba00000d blt 4060 <rtems_termios_ioctl+0x204> <== NOT EXECUTED
!(tty->termios.c_cflag & CRTSCTS)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
4028: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
402c: e3c33c01 bic r3, r3, #256 ; 0x100 <== NOT EXECUTED
4030: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) &&
4034: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4038: e3130004 tst r3, #4 <== NOT EXECUTED
403c: 0a000004 beq 4054 <rtems_termios_ioctl+0x1f8> <== NOT EXECUTED
(tty->device.startRemoteTx != NULL)) {
4040: e59430b0 ldr r3, [r4, #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) &&
4044: e3530000 cmp r3, #0 <== NOT EXECUTED
(tty->device.startRemoteTx != NULL)) {
tty->device.startRemoteTx(tty->minor);
4048: 15940010 ldrne r0, [r4, #16] <== NOT EXECUTED
404c: 11a0e00f movne lr, pc <== NOT EXECUTED
4050: 112fff13 bxne r3 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
4054: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4058: e3c33004 bic r3, r3, #4 <== NOT EXECUTED
405c: e58430b8 str r3, [r4, #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) {
4060: e5943038 ldr r3, [r4, #56] ; 0x38
4064: e3530000 cmp r3, #0
tty->flow_ctrl |= FL_MDRTS;
4068: b59430b8 ldrlt r3, [r4, #184] ; 0xb8
406c: b3833c01 orrlt r3, r3, #256 ; 0x100
4070: b58430b8 strlt r3, [r4, #184] ; 0xb8
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
4074: e5943030 ldr r3, [r4, #48] ; 0x30
4078: e3130a01 tst r3, #4096 ; 0x1000
tty->flow_ctrl |= FL_MDXOF;
407c: 159430b8 ldrne r3, [r4, #184] ; 0xb8
4080: 13833b01 orrne r3, r3, #1024 ; 0x400
4084: 158430b8 strne r3, [r4, #184] ; 0xb8
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
4088: e5943030 ldr r3, [r4, #48] ; 0x30
408c: e3130b01 tst r3, #1024 ; 0x400
tty->flow_ctrl |= FL_MDXON;
4090: 159430b8 ldrne r3, [r4, #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) {
4094: e594703c ldr r7, [r4, #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;
4098: 13833c02 orrne r3, r3, #512 ; 0x200
409c: 158430b8 strne r3, [r4, #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) {
40a0: e2177002 ands r7, r7, #2
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
40a4: 13a03000 movne r3, #0
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) {
40a8: 1a000014 bne 4100 <rtems_termios_ioctl+0x2a4>
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;
40ac: e5d48046 ldrb r8, [r4, #70] ; 0x46
40b0: eb0002a5 bl 4b4c <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] *
40b4: e3a0100a mov r1, #10
40b8: e0000098 mul r0, r8, r0
40bc: eb004a4a bl 169ec <__aeabi_uidiv>
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
40c0: e5d43046 ldrb r3, [r4, #70] ; 0x46
40c4: e3530000 cmp r3, #0
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
}
else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
40c8: e5840054 str r0, [r4, #84] ; 0x54
40cc: e5d42047 ldrb r2, [r4, #71] ; 0x47
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
40d0: 0a000006 beq 40f0 <rtems_termios_ioctl+0x294>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
40d4: e3520000 cmp r2, #0 <== NOT EXECUTED
40d8: 01a02000 moveq r2, r0 <== NOT EXECUTED
40dc: 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;
40e0: e584706c str r7, [r4, #108] ; 0x6c <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
40e4: e5842074 str r2, [r4, #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;
40e8: e5840070 str r0, [r4, #112] ; 0x70 <== NOT EXECUTED
40ec: ea000006 b 410c <rtems_termios_ioctl+0x2b0> <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
}
else {
if (tty->termios.c_cc[VMIN]) {
40f0: e3520000 cmp r2, #0
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
}
else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
40f4: 03a03001 moveq r3, #1
40f8: 0584306c streq r3, [r4, #108] ; 0x6c
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
}
else {
if (tty->termios.c_cc[VMIN]) {
40fc: 0a000002 beq 410c <rtems_termios_ioctl+0x2b0>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
4100: e5843074 str r3, [r4, #116] ; 0x74
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
}
else {
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
4104: e584306c str r3, [r4, #108] ; 0x6c
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
4108: e5843070 str r3, [r4, #112] ; 0x70
else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
410c: e59430a8 ldr r3, [r4, #168] ; 0xa8
4110: e3530000 cmp r3, #0
4114: 0a000032 beq 41e4 <rtems_termios_ioctl+0x388>
(*tty->device.setAttributes)(tty->minor, &tty->termios);
4118: e5940010 ldr r0, [r4, #16]
411c: e2841030 add r1, r4, #48 ; 0x30
4120: e1a0e00f mov lr, pc
4124: e12fff13 bx r3
4128: ea00002d b 41e4 <rtems_termios_ioctl+0x388>
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
412c: e1a00004 mov r0, r4
4130: ebfffe5a bl 3aa0 <drainOutput>
break;
4134: ea00002a b 41e4 <rtems_termios_ioctl+0x388>
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
4138: e897000c ldm r7, {r2, r3} <== NOT EXECUTED
413c: e58420d4 str r2, [r4, #212] ; 0xd4 <== NOT EXECUTED
4140: e58430d8 str r3, [r4, #216] ; 0xd8 <== NOT EXECUTED
break;
4144: ea000026 b 41e4 <rtems_termios_ioctl+0x388> <== NOT EXECUTED
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
4148: e897000c ldm r7, {r2, r3} <== NOT EXECUTED
414c: e58420dc str r2, [r4, #220] ; 0xdc <== NOT EXECUTED
4150: e58430e0 str r3, [r4, #224] ; 0xe0 <== NOT EXECUTED
break;
4154: ea000022 b 41e4 <rtems_termios_ioctl+0x388> <== NOT EXECUTED
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
4158: e59420cc ldr r2, [r4, #204] ; 0xcc <== NOT EXECUTED
415c: e59f309c ldr r3, [pc, #156] ; 4200 <rtems_termios_ioctl+0x3a4><== NOT EXECUTED
4160: e0833282 add r3, r3, r2, lsl #5 <== NOT EXECUTED
4164: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
4168: e3530000 cmp r3, #0 <== NOT EXECUTED
416c: 0a000003 beq 4180 <rtems_termios_ioctl+0x324> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
4170: e1a00004 mov r0, r4 <== NOT EXECUTED
4174: e1a0e00f mov lr, pc <== NOT EXECUTED
4178: e12fff13 bx r3 <== NOT EXECUTED
417c: e1a06000 mov r6, r0 <== NOT EXECUTED
}
tty->t_line=*(int*)(args->buffer);
4180: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
4184: 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) {
4188: e59f3070 ldr r3, [pc, #112] ; 4200 <rtems_termios_ioctl+0x3a4><== NOT EXECUTED
418c: e7933282 ldr r3, [r3, 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 */
4190: e3a01000 mov r1, #0 <== NOT EXECUTED
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
4194: 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 */
4198: e58410d0 str r1, [r4, #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);
419c: e58420cc str r2, [r4, #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) {
41a0: 0a00000f beq 41e4 <rtems_termios_ioctl+0x388> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
41a4: e1a00004 mov r0, r4 <== NOT EXECUTED
41a8: e1a0e00f mov lr, pc <== NOT EXECUTED
41ac: e12fff13 bx r3 <== NOT EXECUTED
41b0: e1a06000 mov r6, r0 <== NOT EXECUTED
41b4: ea00000a b 41e4 <rtems_termios_ioctl+0x388> <== NOT EXECUTED
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD:
{
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
41b8: e5942060 ldr r2, [r4, #96] ; 0x60 <== NOT EXECUTED
41bc: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED
if ( rawnc < 0 )
41c0: e0523003 subs r3, r2, r3 <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
41c4: 45942064 ldrmi r2, [r4, #100] ; 0x64 <== NOT EXECUTED
41c8: 40833002 addmi r3, r3, r2 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
41cc: e2842020 add r2, r4, #32 <== NOT EXECUTED
41d0: e8920006 ldm r2, {r1, r2} <== NOT EXECUTED
41d4: e0411002 sub r1, r1, r2 <== NOT EXECUTED
41d8: e5952008 ldr r2, [r5, #8] <== NOT EXECUTED
41dc: e0813003 add r3, r1, r3 <== NOT EXECUTED
41e0: e5823000 str r3, [r2] <== NOT EXECUTED
}
break;
}
rtems_semaphore_release (tty->osem);
41e4: e5940018 ldr r0, [r4, #24]
41e8: eb000431 bl 52b4 <rtems_semaphore_release>
args->ioctl_return = sc;
41ec: e585600c str r6, [r5, #12]
return sc;
}
41f0: e1a00006 mov r0, r6
41f4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
0000439c <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
439c: e92d4ff3 push {r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr}
43a0: e1a08002 mov r8, r2
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,
43a4: e59f23e0 ldr r2, [pc, #992] ; 478c <rtems_termios_open+0x3f0>
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
43a8: e1a0a001 mov sl, r1
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,
43ac: e3a01000 mov r1, #0
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
43b0: e1a09000 mov r9, r0
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,
43b4: e5920000 ldr r0, [r2]
43b8: e1a02001 mov r2, r1
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
43bc: e1a0b003 mov fp, r3
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,
43c0: eb000375 bl 519c <rtems_semaphore_obtain>
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
43c4: e2506000 subs r6, r0, #0
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
43c8: 059f33c0 ldreq r3, [pc, #960] ; 4790 <rtems_termios_open+0x3f4>
43cc: 05935000 ldreq r5, [r3]
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
43d0: 0a000007 beq 43f4 <rtems_termios_open+0x58>
43d4: ea0000e2 b 4764 <rtems_termios_open+0x3c8> <== NOT EXECUTED
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
if ((tty->major == major) && (tty->minor == minor))
43d8: e595300c ldr r3, [r5, #12]
43dc: e1530009 cmp r3, r9
43e0: 1a000002 bne 43f0 <rtems_termios_open+0x54>
43e4: e5953010 ldr r3, [r5, #16]
43e8: e153000a cmp r3, sl
43ec: 0a0000bb beq 46e0 <rtems_termios_open+0x344>
*/
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
43f0: e5955000 ldr r5, [r5]
43f4: e3550000 cmp r5, #0
43f8: 1afffff6 bne 43d8 <rtems_termios_open+0x3c>
43fc: ea0000da b 476c <rtems_termios_open+0x3d0>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
4400: e59f738c ldr r7, [pc, #908] ; 4794 <rtems_termios_open+0x3f8>
4404: e5973004 ldr r3, [r7, #4]
4408: e5853064 str r3, [r5, #100] ; 0x64
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
440c: e5950064 ldr r0, [r5, #100] ; 0x64
4410: ebfff77a bl 2200 <malloc>
if (tty->rawInBuf.theBuf == NULL) {
4414: e3500000 cmp r0, #0
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
4418: e5850058 str r0, [r5, #88] ; 0x58
if (tty->rawInBuf.theBuf == NULL) {
441c: 1a000006 bne 443c <rtems_termios_open+0xa0>
free(tty);
4420: e1a00005 mov r0, r5 <== NOT EXECUTED
4424: ebfff6a9 bl 1ed0 <free> <== NOT EXECUTED
rtems_semaphore_release (rtems_termios_ttyMutex);
4428: e59f335c ldr r3, [pc, #860] ; 478c <rtems_termios_open+0x3f0><== NOT EXECUTED
442c: e5930000 ldr r0, [r3] <== NOT EXECUTED
4430: eb00039f bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
4434: e3a0601a mov r6, #26 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
4438: ea0000c9 b 4764 <rtems_termios_open+0x3c8> <== NOT EXECUTED
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
443c: e5973008 ldr r3, [r7, #8]
4440: e5853088 str r3, [r5, #136] ; 0x88
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
4444: e5950088 ldr r0, [r5, #136] ; 0x88
4448: ebfff76c bl 2200 <malloc>
if (tty->rawOutBuf.theBuf == NULL) {
444c: e3500000 cmp r0, #0
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
4450: e585007c str r0, [r5, #124] ; 0x7c
if (tty->rawOutBuf.theBuf == NULL) {
4454: 0a000006 beq 4474 <rtems_termios_open+0xd8>
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
4458: e5970000 ldr r0, [r7]
445c: ebfff767 bl 2200 <malloc>
if (tty->cbuf == NULL) {
4460: e3500000 cmp r0, #0
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
4464: e585001c str r0, [r5, #28]
if (tty->cbuf == NULL) {
4468: 1a000004 bne 4480 <rtems_termios_open+0xe4>
free((void *)(tty->rawOutBuf.theBuf));
446c: e595007c ldr r0, [r5, #124] ; 0x7c <== NOT EXECUTED
4470: ebfff696 bl 1ed0 <free> <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
4474: e5950058 ldr r0, [r5, #88] ; 0x58 <== NOT EXECUTED
4478: ebfff694 bl 1ed0 <free> <== NOT EXECUTED
447c: eaffffe7 b 4420 <rtems_termios_open+0x84> <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
4480: e59f3308 ldr r3, [pc, #776] ; 4790 <rtems_termios_open+0x3f4>
4484: e5932000 ldr r2, [r3]
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
4488: e3a03000 mov r3, #0
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
448c: e3520000 cmp r2, #0
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
4490: e885000c stm r5, {r2, r3}
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
4494: 15825004 strne r5, [r2, #4]
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
4498: e58530d4 str r3, [r5, #212] ; 0xd4
tty->tty_snd.sw_arg = NULL;
449c: e58530d8 str r3, [r5, #216] ; 0xd8
tty->tty_rcv.sw_pfn = NULL;
44a0: e58530dc str r3, [r5, #220] ; 0xdc
tty->tty_rcv.sw_arg = NULL;
44a4: e58530e0 str r3, [r5, #224] ; 0xe0
tty->tty_rcvwakeup = 0;
44a8: e58530e4 str r3, [r5, #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)
44ac: e59f32e4 ldr r3, [pc, #740] ; 4798 <rtems_termios_open+0x3fc>
44b0: e5932000 ldr r2, [r3]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
44b4: e59f72d8 ldr r7, [pc, #728] ; 4794 <rtems_termios_open+0x3f8>
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)
44b8: e3520000 cmp r2, #0
rtems_termios_ttyTail = tty;
44bc: 05834000 streq r4, [r3]
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
44c0: e59f22c8 ldr r2, [pc, #712] ; 4790 <rtems_termios_open+0x3f4>
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
44c4: e5d7300c ldrb r3, [r7, #12]
44c8: e59f02cc ldr r0, [pc, #716] ; 479c <rtems_termios_open+0x400>
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
44cc: e5824000 str r4, [r2]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
44d0: e1830000 orr r0, r3, r0
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
44d4: e584a010 str sl, [r4, #16]
tty->major = major;
44d8: e584900c str r9, [r4, #12]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
44dc: e284c014 add ip, r4, #20
44e0: e3a03000 mov r3, #0
44e4: e3a01001 mov r1, #1
44e8: e3a02054 mov r2, #84 ; 0x54
44ec: e58dc000 str ip, [sp]
44f0: eb000297 bl 4f54 <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)
44f4: e2503000 subs r3, r0, #0
44f8: 1a000095 bne 4754 <rtems_termios_open+0x3b8>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
44fc: e5d7200c ldrb r2, [r7, #12]
4500: e59f0298 ldr r0, [pc, #664] ; 47a0 <rtems_termios_open+0x404>
4504: e284c018 add ip, r4, #24
4508: e1820000 orr r0, r2, r0
450c: e3a01001 mov r1, #1
4510: e3a02054 mov r2, #84 ; 0x54
4514: e58dc000 str ip, [sp]
4518: eb00028d bl 4f54 <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)
451c: e2501000 subs r1, r0, #0
4520: 1a00008b bne 4754 <rtems_termios_open+0x3b8>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
4524: e5d7300c ldrb r3, [r7, #12]
4528: e59f0274 ldr r0, [pc, #628] ; 47a4 <rtems_termios_open+0x408>
452c: e284c08c add ip, r4, #140 ; 0x8c
4530: e1830000 orr r0, r3, r0
4534: e3a02020 mov r2, #32
4538: e1a03001 mov r3, r1
453c: e58dc000 str ip, [sp]
4540: eb000283 bl 4f54 <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)
4544: e250e000 subs lr, r0, #0
4548: 1a000081 bne 4754 <rtems_termios_open+0x3b8>
tty->rawOutBufState = rob_idle;
/*
* Set callbacks
*/
tty->device = *callbacks;
454c: e8bb000f ldm fp!, {r0, r1, r2, r3}
4550: e284c098 add ip, r4, #152 ; 0x98
4554: e8ac000f stmia ip!, {r0, r1, r2, r3}
4558: e89b000f ldm fp, {r0, r1, r2, r3}
455c: e88c000f stm ip, {r0, r1, r2, r3}
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
4560: e59430b4 ldr r3, [r4, #180] ; 0xb4
4564: 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;
4568: e584e094 str lr, [r4, #148] ; 0x94
tty->device = *callbacks;
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
456c: 1a000017 bne 45d0 <rtems_termios_open+0x234>
sc = rtems_task_create (
4570: e5d7300c ldrb r3, [r7, #12] <== NOT EXECUTED
4574: e59f022c ldr r0, [pc, #556] ; 47a8 <rtems_termios_open+0x40c><== NOT EXECUTED
4578: e284c0c8 add ip, r4, #200 ; 0xc8 <== NOT EXECUTED
457c: e1830000 orr r0, r3, r0 <== NOT EXECUTED
4580: e3a0100a mov r1, #10 <== NOT EXECUTED
4584: e3a02b01 mov r2, #1024 ; 0x400 <== NOT EXECUTED
4588: e3a03c05 mov r3, #1280 ; 0x500 <== NOT EXECUTED
458c: e58de000 str lr, [sp] <== NOT EXECUTED
4590: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
4594: eb00036d bl 5350 <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)
4598: e250e000 subs lr, r0, #0 <== NOT EXECUTED
459c: 1a00006c bne 4754 <rtems_termios_open+0x3b8> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
45a0: e5d7300c ldrb r3, [r7, #12] <== NOT EXECUTED
45a4: e59f0200 ldr r0, [pc, #512] ; 47ac <rtems_termios_open+0x410><== NOT EXECUTED
45a8: e284c0c4 add ip, r4, #196 ; 0xc4 <== NOT EXECUTED
45ac: e1830000 orr r0, r3, r0 <== NOT EXECUTED
45b0: e3a01009 mov r1, #9 <== NOT EXECUTED
45b4: e3a02b01 mov r2, #1024 ; 0x400 <== NOT EXECUTED
45b8: e3a03c05 mov r3, #1280 ; 0x500 <== NOT EXECUTED
45bc: e58de000 str lr, [sp] <== NOT EXECUTED
45c0: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
45c4: eb000361 bl 5350 <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)
45c8: e3500000 cmp r0, #0 <== NOT EXECUTED
45cc: 1a000060 bne 4754 <rtems_termios_open+0x3b8> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
45d0: e59430a0 ldr r3, [r4, #160] ; 0xa0
45d4: e3530000 cmp r3, #0
45d8: 0a000002 beq 45e8 <rtems_termios_open+0x24c>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
45dc: e59430b4 ldr r3, [r4, #180] ; 0xb4
45e0: e3530002 cmp r3, #2
45e4: 1a00000b bne 4618 <rtems_termios_open+0x27c>
sc = rtems_semaphore_create (
45e8: e59f31a4 ldr r3, [pc, #420] ; 4794 <rtems_termios_open+0x3f8><== NOT EXECUTED
45ec: e59f01bc ldr r0, [pc, #444] ; 47b0 <rtems_termios_open+0x414><== NOT EXECUTED
45f0: e5d3300c ldrb r3, [r3, #12] <== NOT EXECUTED
45f4: e3a01000 mov r1, #0 <== NOT EXECUTED
45f8: e1830000 orr r0, r3, r0 <== NOT EXECUTED
45fc: e284c068 add ip, r4, #104 ; 0x68 <== NOT EXECUTED
4600: e3a02024 mov r2, #36 ; 0x24 <== NOT EXECUTED
4604: e1a03001 mov r3, r1 <== NOT EXECUTED
4608: e58dc000 str ip, [sp] <== NOT EXECUTED
460c: eb000250 bl 4f54 <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)
4610: e3500000 cmp r0, #0 <== NOT EXECUTED
4614: 1a00004e bne 4754 <rtems_termios_open+0x3b8> <== NOT EXECUTED
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';
4618: 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;
461c: e58430b8 str r3, [r4, #184] ; 0xb8
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
4620: e5941064 ldr r1, [r4, #100] ; 0x64
tty->highwater = tty->rawInBuf.Size * 3/4;
4624: e594c064 ldr ip, [r4, #100] ; 0x64
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;
tty->termios.c_cc[VINTR] = '\003';
4628: e3a02003 mov r2, #3
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;
462c: e0000c92 mul r0, r2, ip
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;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
4630: e3a0c01c mov ip, #28
4634: e5c4c042 strb ip, [r4, #66] ; 0x42
tty->termios.c_cc[VERASE] = '\177';
4638: e28cc063 add ip, ip, #99 ; 0x63
463c: e5c4c043 strb ip, [r4, #67] ; 0x43
tty->termios.c_cc[VKILL] = '\025';
4640: e3a0c015 mov ip, #21
4644: e5c4c044 strb ip, [r4, #68] ; 0x44
tty->termios.c_cc[VEOF] = '\004';
4648: e3a0c004 mov ip, #4
464c: e5c4c045 strb ip, [r4, #69] ; 0x45
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
4650: e28cc00d add ip, ip, #13
4654: e5c4c049 strb ip, [r4, #73] ; 0x49
tty->termios.c_cc[VSTOP] = '\023';
4658: e28cc002 add ip, ip, #2
465c: e5c4c04a strb ip, [r4, #74] ; 0x4a
tty->termios.c_cc[VSUSP] = '\032';
4660: e28cc007 add ip, ip, #7
4664: e5c4c04b strb ip, [r4, #75] ; 0x4b
tty->termios.c_cc[VREPRINT] = '\022';
4668: e3a0c012 mov ip, #18
466c: e5c4c04d strb ip, [r4, #77] ; 0x4d
tty->termios.c_cc[VDISCARD] = '\017';
4670: e3a0c00f mov ip, #15
4674: e5c4c04e strb ip, [r4, #78] ; 0x4e
tty->termios.c_cc[VWERASE] = '\027';
4678: e28cc008 add ip, ip, #8
467c: e5c4c04f strb ip, [r4, #79] ; 0x4f
tty->termios.c_cc[VLNEXT] = '\026';
4680: e3a0c016 mov ip, #22
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';
4684: e5c4304c strb r3, [r4, #76] ; 0x4c
tty->termios.c_cc[VEOL2] = '\000';
4688: e5c43051 strb r3, [r4, #81] ; 0x51
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';
468c: e5c4c050 strb ip, [r4, #80] ; 0x50
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;
tty->termios.c_cc[VINTR] = '\003';
4690: e5c42041 strb r2, [r4, #65] ; 0x41
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
4694: e59f30f8 ldr r3, [pc, #248] ; 4794 <rtems_termios_open+0x3f8>
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;
4698: e1a00120 lsr r0, r0, #2
/*
* Bump name characer
*/
if (c++ == 'z')
469c: e5d3200c ldrb r2, [r3, #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;
46a0: e58400c0 str r0, [r4, #192] ; 0xc0
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
46a4: e59f0108 ldr r0, [pc, #264] ; 47b4 <rtems_termios_open+0x418>
46a8: e5840030 str r0, [r4, #48] ; 0x30
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
46ac: e59f0104 ldr r0, [pc, #260] ; 47b8 <rtems_termios_open+0x41c>
46b0: e5840034 str r0, [r4, #52] ; 0x34
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
46b4: e59f0100 ldr r0, [pc, #256] ; 47bc <rtems_termios_open+0x420>
46b8: e5840038 str r0, [r4, #56] ; 0x38
tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
46bc: e59f00fc ldr r0, [pc, #252] ; 47c0 <rtems_termios_open+0x424>
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
46c0: e352007a cmp r2, #122 ; 0x7a
/* 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;
46c4: e1a010a1 lsr r1, r1, #1
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
46c8: e2822001 add r2, r2, #1
* 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;
46cc: e584003c str r0, [r4, #60] ; 0x3c
/* 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;
46d0: e58410bc str r1, [r4, #188] ; 0xbc
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
46d4: e5c3200c strb r2, [r3, #12]
c = 'a';
46d8: 03a02061 moveq r2, #97 ; 0x61
46dc: 05c3200c strbeq r2, [r3, #12]
}
args->iop->data1 = tty;
if (!tty->refcount++) {
46e0: e5953008 ldr r3, [r5, #8]
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
46e4: e5982000 ldr r2, [r8]
if (!tty->refcount++) {
46e8: e3530000 cmp r3, #0
46ec: e2833001 add r3, r3, #1
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
46f0: e5825034 str r5, [r2, #52] ; 0x34
if (!tty->refcount++) {
46f4: e5853008 str r3, [r5, #8]
46f8: 1a000016 bne 4758 <rtems_termios_open+0x3bc>
if (tty->device.firstOpen)
46fc: e5953098 ldr r3, [r5, #152] ; 0x98
4700: e3530000 cmp r3, #0
(*tty->device.firstOpen)(major, minor, arg);
4704: 11a00009 movne r0, r9
4708: 11a0100a movne r1, sl
470c: 11a02008 movne r2, r8
4710: 11a0e00f movne lr, pc
4714: 112fff13 bxne r3
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
4718: e59530b4 ldr r3, [r5, #180] ; 0xb4
471c: e3530002 cmp r3, #2
4720: 1a00000c bne 4758 <rtems_termios_open+0x3bc>
sc = rtems_task_start(tty->rxTaskId,
4724: e59500c4 ldr r0, [r5, #196] ; 0xc4 <== NOT EXECUTED
4728: e59f1094 ldr r1, [pc, #148] ; 47c4 <rtems_termios_open+0x428><== NOT EXECUTED
472c: e1a02005 mov r2, r5 <== NOT EXECUTED
4730: eb0003ab bl 55e4 <rtems_task_start> <== NOT EXECUTED
rtems_termios_rxdaemon,
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
4734: e3500000 cmp r0, #0 <== NOT EXECUTED
4738: 1a000005 bne 4754 <rtems_termios_open+0x3b8> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(tty->txTaskId,
473c: e1a02005 mov r2, r5 <== NOT EXECUTED
4740: e59500c8 ldr r0, [r5, #200] ; 0xc8 <== NOT EXECUTED
4744: e59f107c ldr r1, [pc, #124] ; 47c8 <rtems_termios_open+0x42c><== NOT EXECUTED
4748: eb0003a5 bl 55e4 <rtems_task_start> <== NOT EXECUTED
rtems_termios_txdaemon,
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
474c: e3500000 cmp r0, #0 <== NOT EXECUTED
4750: 0a000000 beq 4758 <rtems_termios_open+0x3bc> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
4754: eb000413 bl 57a8 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
4758: e59f302c ldr r3, [pc, #44] ; 478c <rtems_termios_open+0x3f0>
475c: e5930000 ldr r0, [r3]
4760: eb0002d3 bl 52b4 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
4764: e1a00006 mov r0, r6
4768: e8bd8ffc pop {r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
476c: e3a00001 mov r0, #1
4770: e3a010e8 mov r1, #232 ; 0xe8
4774: ebfff54d bl 1cb0 <calloc>
if (tty == NULL) {
4778: e3500000 cmp r0, #0
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
477c: e1a05000 mov r5, r0
4780: e1a04000 mov r4, r0
if (tty == NULL) {
4784: 1affff1d bne 4400 <rtems_termios_open+0x64>
4788: eaffff26 b 4428 <rtems_termios_open+0x8c> <== NOT EXECUTED
00003344 <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) {
3344: e59230b4 ldr r3, [r2, #180] ; 0xb4
3348: e3530000 cmp r3, #0
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
334c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3350: e1a04002 mov r4, r2
3354: e1a0a000 mov sl, r0
3358: e1a06001 mov r6, r1
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
335c: 1a000005 bne 3378 <rtems_termios_puts+0x34>
(*tty->device.write)(tty->minor, (void *)buf, len);
3360: e1a01000 mov r1, r0
3364: e1a02006 mov r2, r6
3368: e5940010 ldr r0, [r4, #16]
336c: e1a0e00f mov lr, pc
3370: e594f0a4 ldr pc, [r4, #164] ; 0xa4
return;
3374: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
}
newHead = tty->rawOutBuf.Head;
3378: e5925080 ldr r5, [r2, #128] ; 0x80 <== NOT EXECUTED
337c: e3a07000 mov r7, #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;
3380: e3a09002 mov r9, #2 <== NOT EXECUTED
}
else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
}
tty->rawOutBufState = rob_busy;
3384: e3a0b001 mov fp, #1 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
3388: ea00002b b 343c <rtems_termios_puts+0xf8> <== NOT EXECUTED
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
338c: e2850001 add r0, r5, #1 <== NOT EXECUTED
3390: e5941088 ldr r1, [r4, #136] ; 0x88 <== NOT EXECUTED
3394: eb004e28 bl 16c3c <__umodsi3> <== NOT EXECUTED
3398: e1a05000 mov r5, r0 <== NOT EXECUTED
339c: ea000007 b 33c0 <rtems_termios_puts+0x7c> <== NOT EXECUTED
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
33a0: e5849094 str r9, [r4, #148] ; 0x94 <== NOT EXECUTED
33a4: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
33a8: e3a01000 mov r1, #0 <== NOT EXECUTED
33ac: e594008c ldr r0, [r4, #140] ; 0x8c <== NOT EXECUTED
33b0: e1a02001 mov r2, r1 <== NOT EXECUTED
33b4: eb000778 bl 519c <rtems_semaphore_obtain> <== NOT EXECUTED
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
33b8: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
33bc: 1b0008f9 blne 57a8 <rtems_fatal_error_occurred> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
33c0: e10f8000 mrs r8, CPSR <== NOT EXECUTED
33c4: e3883080 orr r3, r8, #128 ; 0x80 <== NOT EXECUTED
33c8: 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) {
33cc: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED
33d0: e1550003 cmp r5, r3 <== NOT EXECUTED
33d4: 0afffff1 beq 33a0 <rtems_termios_puts+0x5c> <== 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++;
33d8: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED
33dc: e7da1007 ldrb r1, [sl, r7] <== NOT EXECUTED
33e0: e594207c ldr r2, [r4, #124] ; 0x7c <== NOT EXECUTED
33e4: e7c21003 strb r1, [r2, r3] <== NOT EXECUTED
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
33e8: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
33ec: 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;
33f0: e5845080 str r5, [r4, #128] ; 0x80 <== NOT EXECUTED
if (tty->rawOutBufState == rob_idle) {
33f4: 1a00000d bne 3430 <rtems_termios_puts+0xec> <== NOT EXECUTED
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
33f8: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
33fc: e3130010 tst r3, #16 <== 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;
3400: 159430b8 ldrne r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
3404: 13833020 orrne r3, r3, #32 <== NOT EXECUTED
3408: 158430b8 strne r3, [r4, #184] ; 0xb8 <== 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)) {
340c: 1a000006 bne 342c <rtems_termios_puts+0xe8> <== NOT EXECUTED
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
3410: 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,
3414: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED
3418: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
341c: e0811003 add r1, r1, r3 <== NOT EXECUTED
3420: e3a02001 mov r2, #1 <== NOT EXECUTED
3424: e1a0e00f mov lr, pc <== NOT EXECUTED
3428: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
}
else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
}
tty->rawOutBufState = rob_busy;
342c: e584b094 str fp, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3430: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
}
rtems_interrupt_enable (level);
len--;
3434: e2466001 sub r6, r6, #1 <== NOT EXECUTED
3438: e2877001 add r7, r7, #1 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
343c: e3560000 cmp r6, #0 <== NOT EXECUTED
3440: 1affffd1 bne 338c <rtems_termios_puts+0x48> <== NOT EXECUTED
3444: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00003b0c <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
3b0c: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
3b10: e5903000 ldr r3, [r0]
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
3b14: e1a05000 mov r5, r0
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
3b18: 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);
3b1c: 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;
3b20: e595300c ldr r3, [r5, #12]
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3b24: e5940014 ldr r0, [r4, #20]
3b28: 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;
3b2c: e5957010 ldr r7, [r5, #16]
char *buffer = args->buffer;
3b30: e58d3000 str r3, [sp]
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3b34: eb000598 bl 519c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
3b38: e2506000 subs r6, r0, #0
3b3c: 1a0000c1 bne 3e48 <rtems_termios_read+0x33c>
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
3b40: e59420cc ldr r2, [r4, #204] ; 0xcc
3b44: e59f3304 ldr r3, [pc, #772] ; 3e50 <rtems_termios_read+0x344>
3b48: e0833282 add r3, r3, r2, lsl #5
3b4c: e5933008 ldr r3, [r3, #8]
3b50: e3530000 cmp r3, #0
3b54: 0a000005 beq 3b70 <rtems_termios_read+0x64>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
3b58: e1a01005 mov r1, r5 <== NOT EXECUTED
3b5c: e1a00004 mov r0, r4 <== NOT EXECUTED
3b60: e1a0e00f mov lr, pc <== NOT EXECUTED
3b64: e12fff13 bx r3 <== NOT EXECUTED
3b68: e1a06000 mov r6, r0 <== NOT EXECUTED
3b6c: ea0000b1 b 3e38 <rtems_termios_read+0x32c> <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
3b70: e5942024 ldr r2, [r4, #36] ; 0x24
3b74: e5943020 ldr r3, [r4, #32]
3b78: e1520003 cmp r2, r3
3b7c: 1a00009a bne 3dec <rtems_termios_read+0x2e0>
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL
3b80: e59420a0 ldr r2, [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;
3b84: e5943028 ldr r3, [r4, #40] ; 0x28
if (tty->device.pollRead != NULL
3b88: e3520000 cmp r2, #0
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
3b8c: e584302c str r3, [r4, #44] ; 0x2c
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
3b90: e5846020 str r6, [r4, #32]
3b94: e5846024 str r6, [r4, #36] ; 0x24
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL
3b98: 0a00003b beq 3c8c <rtems_termios_read+0x180>
&& tty->device.outputUsesInterrupts == TERMIOS_POLLED)
3b9c: e59430b4 ldr r3, [r4, #180] ; 0xb4
3ba0: e3530000 cmp r3, #0
3ba4: 1a000038 bne 3c8c <rtems_termios_read+0x180>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
3ba8: e594303c ldr r3, [r4, #60] ; 0x3c
3bac: e3130002 tst r3, #2
3bb0: 0a00000d beq 3bec <rtems_termios_read+0xe0>
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
3bb4: e5940010 ldr r0, [r4, #16]
3bb8: e1a0e00f mov lr, pc
3bbc: e594f0a0 ldr pc, [r4, #160] ; 0xa0
if (n < 0) {
3bc0: e3500000 cmp r0, #0
rtems_task_wake_after (1);
}
else {
if (siproc (n, tty))
3bc4: e1a01004 mov r1, r4
3bc8: e20000ff and r0, r0, #255 ; 0xff
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
3bcc: aa000002 bge 3bdc <rtems_termios_read+0xd0>
rtems_task_wake_after (1);
3bd0: e3a00001 mov r0, #1
3bd4: eb00069a bl 5644 <rtems_task_wake_after>
3bd8: eafffff5 b 3bb4 <rtems_termios_read+0xa8>
}
else {
if (siproc (n, tty))
3bdc: ebffff67 bl 3980 <siproc> <== NOT EXECUTED
3be0: e3500000 cmp r0, #0 <== NOT EXECUTED
3be4: 0afffff2 beq 3bb4 <rtems_termios_read+0xa8> <== NOT EXECUTED
3be8: ea00007f b 3dec <rtems_termios_read+0x2e0> <== NOT EXECUTED
}
}
}
else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
3bec: eb0003de bl 4b6c <rtems_clock_get_ticks_since_boot>
3bf0: e1a08000 mov r8, r0
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
3bf4: e5940010 ldr r0, [r4, #16]
3bf8: e1a0e00f mov lr, pc
3bfc: e594f0a0 ldr pc, [r4, #160] ; 0xa0
if (n < 0) {
3c00: e3500000 cmp r0, #0
3c04: aa000013 bge 3c58 <rtems_termios_read+0x14c>
if (tty->termios.c_cc[VMIN]) {
3c08: e5d43047 ldrb r3, [r4, #71] ; 0x47
3c0c: e3530000 cmp r3, #0
3c10: e5d43046 ldrb r3, [r4, #70] ; 0x46
3c14: 0a000005 beq 3c30 <rtems_termios_read+0x124>
if (tty->termios.c_cc[VTIME] && tty->ccount) {
3c18: e3530000 cmp r3, #0
3c1c: 0a00000a beq 3c4c <rtems_termios_read+0x140>
3c20: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED
3c24: e3530000 cmp r3, #0 <== NOT EXECUTED
3c28: 0a000007 beq 3c4c <rtems_termios_read+0x140> <== NOT EXECUTED
3c2c: ea000001 b 3c38 <rtems_termios_read+0x12c> <== NOT EXECUTED
break;
}
}
}
else {
if (!tty->termios.c_cc[VTIME])
3c30: e3530000 cmp r3, #0 <== NOT EXECUTED
3c34: 0a00006c beq 3dec <rtems_termios_read+0x2e0> <== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
3c38: eb0003cb bl 4b6c <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED
if ((now - then) > tty->vtimeTicks) {
3c3c: e5943054 ldr r3, [r4, #84] ; 0x54 <== NOT EXECUTED
3c40: e0680000 rsb r0, r8, r0 <== NOT EXECUTED
3c44: e1500003 cmp r0, r3 <== NOT EXECUTED
3c48: 8a000067 bhi 3dec <rtems_termios_read+0x2e0> <== NOT EXECUTED
break;
}
}
rtems_task_wake_after (1);
3c4c: e3a00001 mov r0, #1
3c50: eb00067b bl 5644 <rtems_task_wake_after>
3c54: eaffffe6 b 3bf4 <rtems_termios_read+0xe8>
}
else {
siproc (n, tty);
3c58: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED
3c5c: e1a01004 mov r1, r4 <== NOT EXECUTED
3c60: ebffff46 bl 3980 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
3c64: e5d43047 ldrb r3, [r4, #71] ; 0x47 <== NOT EXECUTED
3c68: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
3c6c: e1520003 cmp r2, r3 <== NOT EXECUTED
3c70: aa00005d bge 3dec <rtems_termios_read+0x2e0> <== NOT EXECUTED
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
3c74: e3530000 cmp r3, #0 <== NOT EXECUTED
3c78: 0affffdd beq 3bf4 <rtems_termios_read+0xe8> <== NOT EXECUTED
3c7c: e5d43046 ldrb r3, [r4, #70] ; 0x46 <== NOT EXECUTED
3c80: e3530000 cmp r3, #0 <== NOT EXECUTED
3c84: 0affffda beq 3bf4 <rtems_termios_read+0xe8> <== NOT EXECUTED
3c88: eaffffd7 b 3bec <rtems_termios_read+0xe0> <== 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;
3c8c: e5948074 ldr r8, [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,
3c90: e284b049 add fp, r4, #73 ; 0x49 <== NOT EXECUTED
3c94: e3a0a001 mov sl, #1 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
3c98: e59f91b4 ldr r9, [pc, #436] ; 3e54 <rtems_termios_read+0x348><== NOT EXECUTED
3c9c: ea000041 b 3da8 <rtems_termios_read+0x29c> <== NOT EXECUTED
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
3ca0: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED
3ca4: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED
3ca8: e2800001 add r0, r0, #1 <== NOT EXECUTED
3cac: eb004be2 bl 16c3c <__umodsi3> <== NOT EXECUTED
c = tty->rawInBuf.theBuf[newHead];
3cb0: e5943058 ldr r3, [r4, #88] ; 0x58 <== NOT EXECUTED
3cb4: e7d38000 ldrb r8, [r3, r0] <== NOT EXECUTED
tty->rawInBuf.Head = newHead;
3cb8: e584005c str r0, [r4, #92] ; 0x5c <== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
3cbc: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED
3cc0: e5942064 ldr r2, [r4, #100] ; 0x64 <== NOT EXECUTED
3cc4: e0823003 add r3, r2, r3 <== NOT EXECUTED
3cc8: e0600003 rsb r0, r0, r3 <== NOT EXECUTED
3ccc: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED
3cd0: eb004bd9 bl 16c3c <__umodsi3> <== NOT EXECUTED
3cd4: e59430bc ldr r3, [r4, #188] ; 0xbc <== NOT EXECUTED
3cd8: e1500003 cmp r0, r3 <== NOT EXECUTED
3cdc: 2a00001f bcs 3d60 <rtems_termios_read+0x254> <== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
3ce0: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
3ce4: e3c33001 bic r3, r3, #1 <== NOT EXECUTED
3ce8: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
3cec: e59f3164 ldr r3, [pc, #356] ; 3e58 <rtems_termios_read+0x34c><== NOT EXECUTED
3cf0: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
3cf4: e59f015c ldr r0, [pc, #348] ; 3e58 <rtems_termios_read+0x34c><== NOT EXECUTED
3cf8: e0023003 and r3, r2, r3 <== NOT EXECUTED
3cfc: e1530000 cmp r3, r0 <== NOT EXECUTED
3d00: 1a00000b bne 3d34 <rtems_termios_read+0x228> <== NOT EXECUTED
3d04: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
3d08: e3530000 cmp r3, #0 <== NOT EXECUTED
3d0c: 0a000002 beq 3d1c <rtems_termios_read+0x210> <== NOT EXECUTED
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
3d10: 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))
3d14: e3130020 tst r3, #32 <== NOT EXECUTED
3d18: 0a000005 beq 3d34 <rtems_termios_read+0x228> <== 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,
3d1c: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
3d20: e1a0100b mov r1, fp <== NOT EXECUTED
3d24: e3a02001 mov r2, #1 <== NOT EXECUTED
3d28: e1a0e00f mov lr, pc <== NOT EXECUTED
3d2c: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
3d30: ea00000a b 3d60 <rtems_termios_read+0x254> <== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTART]),
1);
}
else if (tty->flow_ctrl & FL_MDRTS) {
3d34: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
3d38: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED
3d3c: 0a000007 beq 3d60 <rtems_termios_read+0x254> <== NOT EXECUTED
tty->flow_ctrl &= ~FL_IRTSOFF;
3d40: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
3d44: 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;
3d48: e3c22004 bic r2, r2, #4 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
3d4c: 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;
3d50: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
tty->device.startRemoteTx(tty->minor);
3d54: 15940010 ldrne r0, [r4, #16] <== NOT EXECUTED
3d58: 11a0e00f movne lr, pc <== NOT EXECUTED
3d5c: 112fff13 bxne r3 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
3d60: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
3d64: e3130002 tst r3, #2 <== NOT EXECUTED
3d68: 0a000005 beq 3d84 <rtems_termios_read+0x278> <== NOT EXECUTED
if (siproc (c, tty))
3d6c: e1a00008 mov r0, r8 <== NOT EXECUTED
3d70: e1a01004 mov r1, r4 <== NOT EXECUTED
3d74: ebffff01 bl 3980 <siproc> <== NOT EXECUTED
3d78: e3500000 cmp r0, #0 <== NOT EXECUTED
3d7c: 1a000007 bne 3da0 <rtems_termios_read+0x294> <== NOT EXECUTED
3d80: ea000007 b 3da4 <rtems_termios_read+0x298> <== NOT EXECUTED
wait = 0;
}
else {
siproc (c, tty);
3d84: e1a00008 mov r0, r8 <== NOT EXECUTED
3d88: e1a01004 mov r1, r4 <== NOT EXECUTED
3d8c: ebfffefb bl 3980 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
3d90: e5d43047 ldrb r3, [r4, #71] ; 0x47 <== NOT EXECUTED
3d94: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
3d98: e1520003 cmp r2, r3 <== NOT EXECUTED
3d9c: ba000000 blt 3da4 <rtems_termios_read+0x298> <== NOT EXECUTED
3da0: e3a0a000 mov sl, #0 <== NOT EXECUTED
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
3da4: e5948070 ldr r8, [r4, #112] ; 0x70 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
3da8: e594205c ldr r2, [r4, #92] ; 0x5c <== NOT EXECUTED
3dac: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED
3db0: e1520003 cmp r2, r3 <== NOT EXECUTED
3db4: 0a000004 beq 3dcc <rtems_termios_read+0x2c0> <== NOT EXECUTED
3db8: e5993000 ldr r3, [r9] <== NOT EXECUTED
3dbc: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
3dc0: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3dc4: e1520003 cmp r2, r3 <== NOT EXECUTED
3dc8: baffffb4 blt 3ca0 <rtems_termios_read+0x194> <== NOT EXECUTED
}
/*
* Wait for characters
*/
if ( wait ) {
3dcc: e35a0000 cmp sl, #0 <== NOT EXECUTED
3dd0: 0a000005 beq 3dec <rtems_termios_read+0x2e0> <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->rawInBuf.Semaphore,
3dd4: e2840068 add r0, r4, #104 ; 0x68 <== NOT EXECUTED
3dd8: e8900003 ldm r0, {r0, r1} <== NOT EXECUTED
3ddc: e1a02008 mov r2, r8 <== NOT EXECUTED
3de0: eb0004ed bl 519c <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawInBufSemaphoreOptions,
timeout);
if (sc != RTEMS_SUCCESSFUL)
3de4: e3500000 cmp r0, #0 <== NOT EXECUTED
3de8: 0affffee beq 3da8 <rtems_termios_read+0x29c> <== NOT EXECUTED
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
rtems_status_code sc;
int wait = (int)1;
while ( wait ) {
3dec: e3a03000 mov r3, #0 <== NOT EXECUTED
3df0: ea000007 b 3e14 <rtems_termios_read+0x308> <== NOT EXECUTED
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
3df4: e594101c ldr r1, [r4, #28] <== NOT EXECUTED
3df8: e59d0000 ldr r0, [sp] <== NOT EXECUTED
3dfc: e7d11002 ldrb r1, [r1, r2] <== NOT EXECUTED
3e00: e2822001 add r2, r2, #1 <== NOT EXECUTED
3e04: e7c01003 strb r1, [r0, r3] <== NOT EXECUTED
3e08: e5842024 str r2, [r4, #36] ; 0x24 <== NOT EXECUTED
count--;
3e0c: e2477001 sub r7, r7, #1 <== NOT EXECUTED
3e10: e2833001 add r3, r3, #1 <== NOT EXECUTED
else
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
3e14: e3570000 cmp r7, #0 <== NOT EXECUTED
3e18: 0a000003 beq 3e2c <rtems_termios_read+0x320> <== NOT EXECUTED
3e1c: e2841020 add r1, r4, #32 <== NOT EXECUTED
3e20: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
3e24: e1520001 cmp r2, r1 <== NOT EXECUTED
3e28: bafffff1 blt 3df4 <rtems_termios_read+0x2e8> <== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
3e2c: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
3e30: e0677003 rsb r7, r7, r3 <== NOT EXECUTED
3e34: e5857018 str r7, [r5, #24] <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
3e38: e3a03000 mov r3, #0 <== NOT EXECUTED
3e3c: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
rtems_semaphore_release (tty->isem);
3e40: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED
3e44: eb00051a bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
return sc;
}
3e48: e1a00006 mov r0, r6 <== NOT EXECUTED
3e4c: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00002e2c <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))
2e2c: e59020b8 ldr r2, [r0, #184] ; 0xb8 <== NOT EXECUTED
2e30: e59f31c8 ldr r3, [pc, #456] ; 3000 <rtems_termios_refill_transmitter+0x1d4><== NOT EXECUTED
2e34: e0023003 and r3, r2, r3 <== NOT EXECUTED
2e38: e59f21c4 ldr r2, [pc, #452] ; 3004 <rtems_termios_refill_transmitter+0x1d8><== NOT EXECUTED
2e3c: 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)
{
2e40: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
2e44: 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))
2e48: 1a00000c bne 2e80 <rtems_termios_refill_transmitter+0x54> <== NOT EXECUTED
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor,
2e4c: e284104a add r1, r4, #74 ; 0x4a <== NOT EXECUTED
2e50: e2422b01 sub r2, r2, #1024 ; 0x400 <== NOT EXECUTED
2e54: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
2e58: e1a0e00f mov lr, pc <== NOT EXECUTED
2e5c: 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 (
2e60: e10f3000 mrs r3, CPSR <== NOT EXECUTED
2e64: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
2e68: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
2e6c: e5942090 ldr r2, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
2e70: 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--;
2e74: e2422001 sub r2, r2, #1 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
2e78: e3811002 orr r1, r1, #2 <== NOT EXECUTED
2e7c: ea00000f b 2ec0 <rtems_termios_refill_transmitter+0x94> <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
}
else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF))
2e80: e59030b8 ldr r3, [r0, #184] ; 0xb8 <== NOT EXECUTED
2e84: e2033003 and r3, r3, #3 <== NOT EXECUTED
2e88: e3530002 cmp r3, #2 <== NOT EXECUTED
2e8c: 1a000010 bne 2ed4 <rtems_termios_refill_transmitter+0xa8> <== 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,
2e90: e2841049 add r1, r4, #73 ; 0x49 <== NOT EXECUTED
2e94: e3a02001 mov r2, #1 <== NOT EXECUTED
2e98: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
2e9c: e1a0e00f mov lr, pc <== NOT EXECUTED
2ea0: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
2ea4: e10f3000 mrs r3, CPSR <== NOT EXECUTED
2ea8: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
2eac: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
2eb0: e5942090 ldr r2, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
2eb4: 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--;
2eb8: e2422001 sub r2, r2, #1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
2ebc: e3c11002 bic r1, r1, #2 <== NOT EXECUTED
2ec0: 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--;
2ec4: e5842090 str r2, [r4, #144] ; 0x90 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
2ec8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
2ecc: e3a05001 mov r5, #1 <== NOT EXECUTED
2ed0: ea000048 b 2ff8 <rtems_termios_refill_transmitter+0x1cc> <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
}
else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
2ed4: e5902080 ldr r2, [r0, #128] ; 0x80 <== NOT EXECUTED
2ed8: e5903084 ldr r3, [r0, #132] ; 0x84 <== NOT EXECUTED
2edc: e1520003 cmp r2, r3 <== NOT EXECUTED
2ee0: 1a000005 bne 2efc <rtems_termios_refill_transmitter+0xd0> <== NOT EXECUTED
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
2ee4: e5903094 ldr r3, [r0, #148] ; 0x94 <== NOT EXECUTED
2ee8: e3530002 cmp r3, #2 <== NOT EXECUTED
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
2eec: 0590008c ldreq r0, [r0, #140] ; 0x8c <== NOT EXECUTED
2ef0: 0b0008ef bleq 52b4 <rtems_semaphore_release> <== NOT EXECUTED
2ef4: e3a05000 mov r5, #0 <== NOT EXECUTED
2ef8: ea00003e b 2ff8 <rtems_termios_refill_transmitter+0x1cc> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
2efc: e10f3000 mrs r3, CPSR <== NOT EXECUTED
2f00: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
2f04: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
tty->t_dqlen = 0;
2f08: e3a02000 mov r2, #0 <== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
2f0c: e5900090 ldr r0, [r0, #144] ; 0x90 <== NOT EXECUTED
tty->t_dqlen = 0;
2f10: e5842090 str r2, [r4, #144] ; 0x90 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
2f14: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
2f18: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED
2f1c: e5941088 ldr r1, [r4, #136] ; 0x88 <== NOT EXECUTED
2f20: e0800003 add r0, r0, r3 <== NOT EXECUTED
2f24: eb004f44 bl 16c3c <__umodsi3> <== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
2f28: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
2f2c: 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;
2f30: e1a06000 mov r6, r0 <== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
2f34: e5840084 str r0, [r4, #132] ; 0x84 <== NOT EXECUTED
if (tty->rawOutBufState == rob_wait) {
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
2f38: 0594008c ldreq r0, [r4, #140] ; 0x8c <== NOT EXECUTED
2f3c: 0b0008dc bleq 52b4 <rtems_semaphore_release> <== NOT EXECUTED
}
if (newTail == tty->rawOutBuf.Head) {
2f40: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED
2f44: e1560003 cmp r6, r3 <== NOT EXECUTED
2f48: 1a00000a bne 2f78 <rtems_termios_refill_transmitter+0x14c> <== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
2f4c: e59430d4 ldr r3, [r4, #212] ; 0xd4 <== NOT EXECUTED
}
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
2f50: e3a05000 mov r5, #0 <== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
2f54: e3530000 cmp r3, #0 <== NOT EXECUTED
}
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
2f58: e5845094 str r5, [r4, #148] ; 0x94 <== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
2f5c: 01a05003 moveq r5, r3 <== NOT EXECUTED
2f60: 0a000023 beq 2ff4 <rtems_termios_refill_transmitter+0x1c8> <== NOT EXECUTED
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
2f64: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED
2f68: e59410d8 ldr r1, [r4, #216] ; 0xd8 <== NOT EXECUTED
2f6c: e1a0e00f mov lr, pc <== NOT EXECUTED
2f70: e12fff13 bx r3 <== NOT EXECUTED
2f74: ea00001e b 2ff4 <rtems_termios_refill_transmitter+0x1c8> <== NOT EXECUTED
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
2f78: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
2f7c: e2033e21 and r3, r3, #528 ; 0x210 <== NOT EXECUTED
2f80: e3530e21 cmp r3, #528 ; 0x210 <== NOT EXECUTED
2f84: 1a00000a bne 2fb4 <rtems_termios_refill_transmitter+0x188> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
2f88: e10f3000 mrs r3, CPSR <== NOT EXECUTED
2f8c: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
2f90: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
== (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;
2f94: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
2f98: e3822020 orr r2, r2, #32 <== NOT EXECUTED
2f9c: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
2fa0: e3a02001 mov r2, #1 <== NOT EXECUTED
2fa4: e5842094 str r2, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
2fa8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
2fac: e3a05000 mov r5, #0 <== NOT EXECUTED
2fb0: ea00000f b 2ff4 <rtems_termios_refill_transmitter+0x1c8> <== NOT EXECUTED
}
else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
2fb4: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED
2fb8: e1560003 cmp r6, r3 <== NOT EXECUTED
nToSend = tty->rawOutBuf.Size - newTail;
2fbc: 85945088 ldrhi r5, [r4, #136] ; 0x88 <== NOT EXECUTED
else
nToSend = tty->rawOutBuf.Head - newTail;
2fc0: 95945080 ldrls r5, [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)) {
2fc4: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
2fc8: e0665005 rsb r5, r6, r5 <== 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)) {
2fcc: e3130c06 tst r3, #1536 ; 0x600 <== NOT EXECUTED
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(tty->minor,
2fd0: 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)) {
2fd4: 13a05001 movne r5, #1 <== NOT EXECUTED
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
2fd8: e3a03001 mov r3, #1 <== NOT EXECUTED
2fdc: e5843094 str r3, [r4, #148] ; 0x94 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
2fe0: e0811006 add r1, r1, r6 <== NOT EXECUTED
2fe4: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
2fe8: e1a02005 mov r2, r5 <== NOT EXECUTED
2fec: e1a0e00f mov lr, pc <== NOT EXECUTED
2ff0: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
&tty->rawOutBuf.theBuf[newTail],
nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
2ff4: e5846084 str r6, [r4, #132] ; 0x84 <== NOT EXECUTED
}
return nToSend;
}
2ff8: e1a00005 mov r0, r5 <== NOT EXECUTED
2ffc: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00004838 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
4838: e92d40f3 push {r0, r1, r4, r5, r6, r7, lr} <== NOT EXECUTED
483c: e1a04000 mov r4, r0 <== NOT EXECUTED
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_RX_PROC_EVENT |
4840: e3a05000 mov r5, #0 <== NOT EXECUTED
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters (
4844: e28d6007 add r6, sp, #7 <== NOT EXECUTED
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_RX_PROC_EVENT |
4848: e1a0300d mov r3, sp <== NOT EXECUTED
484c: e3a01002 mov r1, #2 <== NOT EXECUTED
4850: e3a02000 mov r2, #0 <== NOT EXECUTED
4854: e3a00003 mov r0, #3 <== NOT EXECUTED
4858: eb0000e0 bl 4be0 <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) {
485c: e59d3000 ldr r3, [sp] <== NOT EXECUTED
4860: e3130001 tst r3, #1 <== NOT EXECUTED
4864: 0a000003 beq 4878 <rtems_termios_rxdaemon+0x40> <== NOT EXECUTED
tty->rxTaskId = 0;
4868: e58450c4 str r5, [r4, #196] ; 0xc4 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
486c: e1a00005 mov r0, r5 <== NOT EXECUTED
4870: eb000308 bl 5498 <rtems_task_delete> <== NOT EXECUTED
4874: eafffff3 b 4848 <rtems_termios_rxdaemon+0x10> <== NOT EXECUTED
}
else {
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
4878: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
487c: e1a0e00f mov lr, pc <== NOT EXECUTED
4880: e594f0a0 ldr pc, [r4, #160] ; 0xa0 <== NOT EXECUTED
if (c != EOF) {
4884: e3700001 cmn r0, #1 <== NOT EXECUTED
}
else {
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
4888: e1a03000 mov r3, r0 <== NOT EXECUTED
if (c != EOF) {
488c: 0affffed beq 4848 <rtems_termios_rxdaemon+0x10> <== NOT EXECUTED
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters (
4890: e1a00004 mov r0, r4 <== NOT EXECUTED
4894: e1a01006 mov r1, r6 <== NOT EXECUTED
4898: e3a02001 mov r2, #1 <== NOT EXECUTED
c = tty->device.pollRead(tty->minor);
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
489c: e5cd3007 strb r3, [sp, #7] <== NOT EXECUTED
rtems_termios_enqueue_raw_characters (
48a0: ebfff9f4 bl 3078 <rtems_termios_enqueue_raw_characters> <== NOT EXECUTED
48a4: eaffffe7 b 4848 <rtems_termios_rxdaemon+0x10> <== NOT EXECUTED
00002e20 <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);
2e20: e59000c4 ldr r0, [r0, #196] ; 0xc4 <== NOT EXECUTED
2e24: e3a01002 mov r1, #2 <== NOT EXECUTED
2e28: ea0007c8 b 4d50 <rtems_event_send> <== NOT EXECUTED
000047cc <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
47cc: e92d40f1 push {r0, r4, r5, r6, r7, lr} <== NOT EXECUTED
}
else {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
47d0: e59f705c ldr r7, [pc, #92] ; 4834 <rtems_termios_txdaemon+0x68><== NOT EXECUTED
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
47d4: e1a04000 mov r4, r0 <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_TX_START_EVENT |
47d8: e3a05000 mov r5, #0 <== NOT EXECUTED
47dc: e1a0300d mov r3, sp <== NOT EXECUTED
47e0: e3a01002 mov r1, #2 <== NOT EXECUTED
47e4: e3a02000 mov r2, #0 <== NOT EXECUTED
47e8: e3a00003 mov r0, #3 <== NOT EXECUTED
47ec: eb0000fb bl 4be0 <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) {
47f0: e59d3000 ldr r3, [sp] <== NOT EXECUTED
47f4: 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);
47f8: 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) {
47fc: 0a000003 beq 4810 <rtems_termios_txdaemon+0x44> <== NOT EXECUTED
tty->txTaskId = 0;
4800: e58450c8 str r5, [r4, #200] ; 0xc8 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
4804: e1a00005 mov r0, r5 <== NOT EXECUTED
4808: eb000322 bl 5498 <rtems_task_delete> <== NOT EXECUTED
480c: eafffff2 b 47dc <rtems_termios_txdaemon+0x10> <== NOT EXECUTED
}
else {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
4810: e59430cc ldr r3, [r4, #204] ; 0xcc <== NOT EXECUTED
4814: e0873283 add r3, r7, r3, lsl #5 <== NOT EXECUTED
4818: e5933014 ldr r3, [r3, #20] <== NOT EXECUTED
481c: e3530000 cmp r3, #0 <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
4820: 11a0e00f movne lr, pc <== NOT EXECUTED
4824: 112fff13 bxne r3 <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
4828: e1a00004 mov r0, r4 <== NOT EXECUTED
482c: ebfff97e bl 2e2c <rtems_termios_refill_transmitter> <== NOT EXECUTED
4830: eaffffe9 b 47dc <rtems_termios_txdaemon+0x10> <== NOT EXECUTED
000039e0 <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;
39e0: e5903000 ldr r3, [r0]
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
39e4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
39e8: e5935034 ldr r5, [r3, #52] ; 0x34
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
39ec: e3a01000 mov r1, #0
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
39f0: e1a04000 mov r4, 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);
39f4: e1a02001 mov r2, r1
39f8: e5950018 ldr r0, [r5, #24]
39fc: eb0005e6 bl 519c <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
3a00: e2506000 subs r6, r0, #0
3a04: 1a000022 bne 3a94 <rtems_termios_write+0xb4>
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
3a08: e59520cc ldr r2, [r5, #204] ; 0xcc
3a0c: e59f3088 ldr r3, [pc, #136] ; 3a9c <rtems_termios_write+0xbc>
3a10: e0833282 add r3, r3, r2, lsl #5
3a14: e593300c ldr r3, [r3, #12]
3a18: e3530000 cmp r3, #0
3a1c: 0a000005 beq 3a38 <rtems_termios_write+0x58>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
3a20: e1a01004 mov r1, r4 <== NOT EXECUTED
3a24: e1a00005 mov r0, r5 <== NOT EXECUTED
3a28: e1a0e00f mov lr, pc <== NOT EXECUTED
3a2c: e12fff13 bx r3 <== NOT EXECUTED
3a30: e1a06000 mov r6, r0 <== NOT EXECUTED
3a34: ea000014 b 3a8c <rtems_termios_write+0xac> <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
3a38: e5953034 ldr r3, [r5, #52] ; 0x34
3a3c: e3130001 tst r3, #1
uint32_t count = args->count;
3a40: 15948010 ldrne r8, [r4, #16]
char *buffer = args->buffer;
3a44: 1594a00c ldrne sl, [r4, #12]
3a48: 11a07006 movne r7, r6
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) {
3a4c: 1a000004 bne 3a64 <rtems_termios_write+0x84>
3a50: ea000007 b 3a74 <rtems_termios_write+0x94> <== NOT EXECUTED
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
3a54: e7da0007 ldrb r0, [sl, r7]
3a58: ebfffe7a bl 3448 <oproc>
3a5c: e2877001 add r7, r7, #1
3a60: e2488001 sub r8, r8, #1
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
3a64: e3580000 cmp r8, #0
oproc (*buffer++, tty);
3a68: e1a01005 mov r1, r5
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
3a6c: 1afffff8 bne 3a54 <rtems_termios_write+0x74>
3a70: ea000003 b 3a84 <rtems_termios_write+0xa4>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
}
else {
rtems_termios_puts (args->buffer, args->count, tty);
3a74: e284000c add r0, r4, #12 <== NOT EXECUTED
3a78: e8900003 ldm r0, {r0, r1} <== NOT EXECUTED
3a7c: e1a02005 mov r2, r5 <== NOT EXECUTED
3a80: ebfffe2f bl 3344 <rtems_termios_puts> <== NOT EXECUTED
args->bytes_moved = args->count;
3a84: e5943010 ldr r3, [r4, #16]
3a88: e5843018 str r3, [r4, #24]
}
rtems_semaphore_release (tty->osem);
3a8c: e5950018 ldr r0, [r5, #24]
3a90: eb000607 bl 52b4 <rtems_semaphore_release>
return sc;
}
3a94: e1a00006 mov r0, r6
3a98: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
000064b0 <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
64b0: 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)
64b4: e2107202 ands r7, r0, #536870912 ; 0x20000000 <== NOT EXECUTED
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
64b8: e1a06000 mov r6, r0 <== NOT EXECUTED
64bc: e1a09001 mov r9, r1 <== NOT EXECUTED
64c0: e1a04002 mov r4, r2 <== NOT EXECUTED
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC)
64c4: 0a00000d beq 6500 <rtems_verror+0x50> <== NOT EXECUTED
{
if (rtems_panic_in_progress++)
64c8: e59f3160 ldr r3, [pc, #352] ; 6630 <rtems_verror+0x180> <== NOT EXECUTED
64cc: e5932000 ldr r2, [r3] <== NOT EXECUTED
64d0: e3520000 cmp r2, #0 <== NOT EXECUTED
64d4: e2822001 add r2, r2, #1 <== NOT EXECUTED
64d8: e5832000 str r2, [r3] <== NOT EXECUTED
64dc: 0a000003 beq 64f0 <rtems_verror+0x40> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
64e0: e59f314c ldr r3, [pc, #332] ; 6634 <rtems_verror+0x184> <== NOT EXECUTED
64e4: e5932000 ldr r2, [r3] <== NOT EXECUTED
64e8: e2822001 add r2, r2, #1 <== NOT EXECUTED
64ec: e5832000 str r2, [r3] <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
64f0: e59f3138 ldr r3, [pc, #312] ; 6630 <rtems_verror+0x180> <== NOT EXECUTED
64f4: e5933000 ldr r3, [r3] <== NOT EXECUTED
64f8: e3530002 cmp r3, #2 <== NOT EXECUTED
64fc: ca000049 bgt 6628 <rtems_verror+0x178> <== NOT EXECUTED
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
6500: e59f3130 ldr r3, [pc, #304] ; 6638 <rtems_verror+0x188> <== NOT EXECUTED
6504: e5933000 ldr r3, [r3] <== NOT EXECUTED
6508: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
650c: eb0030d6 bl 1286c <fflush> <== NOT EXECUTED
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
6510: e2165101 ands r5, r6, #1073741824 ; 0x40000000 <== NOT EXECUTED
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
6514: e3c68207 bic r8, r6, #1879048192 ; 0x70000000 <== NOT EXECUTED
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
6518: 0a000001 beq 6524 <rtems_verror+0x74> <== NOT EXECUTED
local_errno = errno;
651c: eb002fdf bl 124a0 <__errno> <== NOT EXECUTED
6520: e5905000 ldr r5, [r0] <== 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);
6524: e59fa10c ldr sl, [pc, #268] ; 6638 <rtems_verror+0x188> <== NOT EXECUTED
6528: e59a3000 ldr r3, [sl] <== NOT EXECUTED
652c: e1a02004 mov r2, r4 <== NOT EXECUTED
6530: e1a01009 mov r1, r9 <== NOT EXECUTED
6534: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
6538: eb0048f1 bl 18904 <vfprintf> <== NOT EXECUTED
if (status)
653c: e3580000 cmp r8, #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);
6540: e1a04000 mov r4, r0 <== NOT EXECUTED
if (status)
6544: 0a000008 beq 656c <rtems_verror+0xbc> <== NOT EXECUTED
chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status));
6548: e59a3000 ldr r3, [sl] <== NOT EXECUTED
654c: e1a00008 mov r0, r8 <== NOT EXECUTED
6550: e593800c ldr r8, [r3, #12] <== NOT EXECUTED
6554: ebffffd1 bl 64a0 <rtems_status_text> <== NOT EXECUTED
6558: e59f10dc ldr r1, [pc, #220] ; 663c <rtems_verror+0x18c> <== NOT EXECUTED
655c: e1a02000 mov r2, r0 <== NOT EXECUTED
6560: e1a00008 mov r0, r8 <== NOT EXECUTED
6564: eb00317e bl 12b64 <fprintf> <== NOT EXECUTED
6568: e0844000 add r4, r4, r0 <== NOT EXECUTED
if (local_errno)
656c: e3550000 cmp r5, #0 <== NOT EXECUTED
6570: 0a000015 beq 65cc <rtems_verror+0x11c> <== NOT EXECUTED
{
if ((local_errno > 0) && *strerror(local_errno))
6574: da00000d ble 65b0 <rtems_verror+0x100> <== NOT EXECUTED
6578: e1a00005 mov r0, r5 <== NOT EXECUTED
657c: eb00348b bl 137b0 <strerror> <== NOT EXECUTED
6580: e5d03000 ldrb r3, [r0] <== NOT EXECUTED
6584: e3530000 cmp r3, #0 <== NOT EXECUTED
6588: 0a000008 beq 65b0 <rtems_verror+0x100> <== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
658c: e59f30a4 ldr r3, [pc, #164] ; 6638 <rtems_verror+0x188> <== NOT EXECUTED
6590: e5933000 ldr r3, [r3] <== NOT EXECUTED
6594: e1a00005 mov r0, r5 <== NOT EXECUTED
6598: e593800c ldr r8, [r3, #12] <== NOT EXECUTED
659c: eb003483 bl 137b0 <strerror> <== NOT EXECUTED
65a0: e59f1098 ldr r1, [pc, #152] ; 6640 <rtems_verror+0x190> <== NOT EXECUTED
65a4: e1a02000 mov r2, r0 <== NOT EXECUTED
65a8: e1a00008 mov r0, r8 <== NOT EXECUTED
65ac: ea000004 b 65c4 <rtems_verror+0x114> <== NOT EXECUTED
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
65b0: e59f3080 ldr r3, [pc, #128] ; 6638 <rtems_verror+0x188> <== NOT EXECUTED
65b4: e5933000 ldr r3, [r3] <== NOT EXECUTED
65b8: e59f1084 ldr r1, [pc, #132] ; 6644 <rtems_verror+0x194> <== NOT EXECUTED
65bc: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
65c0: e1a02005 mov r2, r5 <== NOT EXECUTED
65c4: eb003166 bl 12b64 <fprintf> <== NOT EXECUTED
65c8: e0844000 add r4, r4, r0 <== NOT EXECUTED
}
chars_written += fprintf(stderr, "\n");
65cc: e59f8064 ldr r8, [pc, #100] ; 6638 <rtems_verror+0x188> <== NOT EXECUTED
65d0: e5983000 ldr r3, [r8] <== NOT EXECUTED
65d4: e59f106c ldr r1, [pc, #108] ; 6648 <rtems_verror+0x198> <== NOT EXECUTED
65d8: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
65dc: eb003160 bl 12b64 <fprintf> <== NOT EXECUTED
(void) fflush(stderr);
65e0: e5983000 ldr r3, [r8] <== 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");
65e4: e1a0a000 mov sl, r0 <== NOT EXECUTED
(void) fflush(stderr);
65e8: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
65ec: eb00309e bl 1286c <fflush> <== NOT EXECUTED
if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT))
65f0: e3160203 tst r6, #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");
65f4: 008a0004 addeq r0, sl, r4 <== NOT EXECUTED
(void) fflush(stderr);
if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT))
65f8: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
{
if (error_flag & RTEMS_ERROR_PANIC)
65fc: e3570000 cmp r7, #0 <== NOT EXECUTED
6600: 0a000004 beq 6618 <rtems_verror+0x168> <== NOT EXECUTED
{
rtems_error(0, "fatal error, exiting");
6604: e3a00000 mov r0, #0 <== NOT EXECUTED
6608: e59f103c ldr r1, [pc, #60] ; 664c <rtems_verror+0x19c> <== NOT EXECUTED
660c: eb00001b bl 6680 <rtems_error> <== NOT EXECUTED
_exit(local_errno);
6610: e1a00005 mov r0, r5 <== NOT EXECUTED
6614: eb0002f2 bl 71e4 <_exit> <== NOT EXECUTED
}
else
{
rtems_error(0, "fatal error, aborting");
6618: e59f1030 ldr r1, [pc, #48] ; 6650 <rtems_verror+0x1a0> <== NOT EXECUTED
661c: e1a00007 mov r0, r7 <== NOT EXECUTED
6620: eb000016 bl 6680 <rtems_error> <== NOT EXECUTED
abort();
6624: eb002f94 bl 1247c <abort> <== NOT EXECUTED
6628: e3a00000 mov r0, #0 <== NOT EXECUTED
}
}
return chars_written;
}
662c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
00025434 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
25434: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
25438: e3a04000 mov r4, #0
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2543c: e59fb0d4 ldr fp, [pc, #212] ; 25518 <scanInt+0xe4>
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
25440: e59f90d4 ldr r9, [pc, #212] ; 2551c <scanInt+0xe8>
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
25444: e58d1000 str r1, [sp]
25448: e1a05000 mov r5, r0
2544c: e3e08102 mvn r8, #-2147483648 ; 0x80000000
25450: e1a07004 mov r7, r4
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
25454: e3a0a00a mov sl, #10
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
25458: e5953004 ldr r3, [r5, #4]
2545c: e2433001 sub r3, r3, #1
25460: e3530000 cmp r3, #0
25464: e5853004 str r3, [r5, #4]
25468: a5953000 ldrge r3, [r5]
2546c: a4d36001 ldrbge r6, [r3], #1
25470: a5853000 strge r3, [r5]
25474: aa000003 bge 25488 <scanInt+0x54>
25478: e59b0000 ldr r0, [fp] <== NOT EXECUTED
2547c: e1a01005 mov r1, r5 <== NOT EXECUTED
25480: eb007420 bl 42508 <__srget_r> <== NOT EXECUTED
25484: e1a06000 mov r6, r0 <== NOT EXECUTED
if (c == ':')
25488: e356003a cmp r6, #58 ; 0x3a
2548c: 0a000019 beq 254f8 <scanInt+0xc4>
break;
if (sign == 0) {
25490: e3540000 cmp r4, #0
25494: 1a000004 bne 254ac <scanInt+0x78>
if (c == '-') {
25498: e356002d cmp r6, #45 ; 0x2d
sign = -1;
limit++;
2549c: 02888001 addeq r8, r8, #1
254a0: 03e04000 mvneq r4, #0
for (;;) {
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
254a4: 0affffeb beq 25458 <scanInt+0x24>
sign = -1;
limit++;
continue;
254a8: e3a04001 mov r4, #1
}
sign = 1;
}
if (!isdigit(c))
254ac: e5993000 ldr r3, [r9]
254b0: e0833006 add r3, r3, r6
254b4: e5d33001 ldrb r3, [r3, #1]
254b8: e3130004 tst r3, #4
254bc: 0a000013 beq 25510 <scanInt+0xdc>
return 0;
d = c - '0';
if ((i > (limit / 10))
254c0: e1a00008 mov r0, r8
254c4: e3a0100a mov r1, #10
254c8: eb00be4a bl 54df8 <__aeabi_uidiv>
254cc: e1570000 cmp r7, r0
254d0: 8a00000e bhi 25510 <scanInt+0xdc>
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
254d4: e2466030 sub r6, r6, #48 ; 0x30
if ((i > (limit / 10))
254d8: 1a000004 bne 254f0 <scanInt+0xbc>
254dc: e1a00008 mov r0, r8 <== NOT EXECUTED
254e0: e3a0100a mov r1, #10 <== NOT EXECUTED
254e4: eb00bed7 bl 55048 <__umodsi3> <== NOT EXECUTED
254e8: e1560000 cmp r6, r0 <== NOT EXECUTED
254ec: 8a000007 bhi 25510 <scanInt+0xdc> <== NOT EXECUTED
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
254f0: e027679a mla r7, sl, r7, r6
254f4: eaffffd7 b 25458 <scanInt+0x24>
}
if (sign == 0)
254f8: e3540000 cmp r4, #0
return 0;
*val = i * sign;
254fc: 10030497 mulne r3, r7, r4
25500: 159d2000 ldrne r2, [sp]
25504: 13a00001 movne r0, #1
25508: 15823000 strne r3, [r2]
return 1;
2550c: 1a000000 bne 25514 <scanInt+0xe0>
25510: e3a00000 mov r0, #0 <== NOT EXECUTED
}
25514: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
00025520 <scanString>:
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
25520: e92d41f0 push {r4, r5, r6, r7, r8, lr}
25524: e1a04002 mov r4, r2
int c;
*name = *bufp;
25528: 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)
{
2552c: e59d6018 ldr r6, [sp, #24]
int c;
*name = *bufp;
25530: e5812000 str r2, [r1]
for (;;) {
c = getc(fp);
25534: e59f70c0 ldr r7, [pc, #192] ; 255fc <scanString+0xdc>
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
25538: e1a05000 mov r5, r0
2553c: e1a08003 mov r8, r3
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
25540: e5953004 ldr r3, [r5, #4]
25544: e2433001 sub r3, r3, #1
25548: e3530000 cmp r3, #0
2554c: e5853004 str r3, [r5, #4]
25550: a5953000 ldrge r3, [r5]
25554: a4d30001 ldrbge r0, [r3], #1
25558: a5853000 strge r3, [r5]
2555c: b5970000 ldrlt r0, [r7]
25560: b1a01005 movlt r1, r5
25564: bb0073e7 bllt 42508 <__srget_r>
if (c == ':') {
25568: e350003a cmp r0, #58 ; 0x3a
2556c: 1a000002 bne 2557c <scanString+0x5c>
if (nlFlag)
25570: e3560000 cmp r6, #0
25574: 0a000013 beq 255c8 <scanString+0xa8>
25578: ea00001d b 255f4 <scanString+0xd4> <== NOT EXECUTED
return 0;
break;
}
if (c == '\n') {
2557c: e350000a cmp r0, #10
25580: 1a000002 bne 25590 <scanString+0x70>
if (!nlFlag)
25584: e3560000 cmp r6, #0
25588: 1a00000e bne 255c8 <scanString+0xa8>
2558c: ea000018 b 255f4 <scanString+0xd4> <== NOT EXECUTED
return 0;
break;
}
if (c == EOF)
25590: e3700001 cmn r0, #1
25594: 0a000016 beq 255f4 <scanString+0xd4>
return 0;
if (*nleft < 2)
25598: e5983000 ldr r3, [r8]
2559c: e3530001 cmp r3, #1
255a0: 9a000013 bls 255f4 <scanString+0xd4>
return 0;
**bufp = c;
255a4: e5943000 ldr r3, [r4]
255a8: e5c30000 strb r0, [r3]
++(*bufp);
255ac: e5942000 ldr r2, [r4]
--(*nleft);
255b0: e5983000 ldr r3, [r8]
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
**bufp = c;
++(*bufp);
255b4: e2822001 add r2, r2, #1
--(*nleft);
255b8: e2433001 sub r3, r3, #1
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
**bufp = c;
++(*bufp);
255bc: e5842000 str r2, [r4]
--(*nleft);
255c0: e5883000 str r3, [r8]
}
255c4: eaffffdd b 25540 <scanString+0x20>
**bufp = '\0';
255c8: e5943000 ldr r3, [r4]
255cc: e3a02000 mov r2, #0
255d0: e5c32000 strb r2, [r3]
++(*bufp);
255d4: e5942000 ldr r2, [r4]
--(*nleft);
255d8: e5983000 ldr r3, [r8]
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
255dc: e2822001 add r2, r2, #1
--(*nleft);
255e0: e2433001 sub r3, r3, #1
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
255e4: e5842000 str r2, [r4]
--(*nleft);
255e8: e5883000 str r3, [r8]
255ec: e3a00001 mov r0, #1
return 1;
255f0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
255f4: e3a00000 mov r0, #0 <== NOT EXECUTED
}
255f8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00025600 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
25600: e92d41f0 push {r4, r5, r6, r7, r8, lr}
25604: e24dd014 sub sp, sp, #20
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
25608: e28d6008 add r6, sp, #8
2560c: e28d5004 add r5, sp, #4
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
25610: e58d2008 str r2, [sp, #8]
25614: e58d3004 str r3, [sp, #4]
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
25618: e3a08000 mov r8, #0
2561c: e1a02006 mov r2, r6
25620: e1a03005 mov r3, r5
25624: e58d8000 str r8, [sp]
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
25628: e1a07000 mov r7, r0
2562c: e1a04001 mov r4, r1
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
25630: ebffffba bl 25520 <scanString>
25634: e1500008 cmp r0, r8
25638: 0a00003b beq 2572c <scangr+0x12c>
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
2563c: e1a00007 mov r0, r7
25640: e2841004 add r1, r4, #4
25644: e1a02006 mov r2, r6
25648: e1a03005 mov r3, r5
2564c: e58d8000 str r8, [sp]
25650: ebffffb2 bl 25520 <scanString>
{
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
25654: e1500008 cmp r0, r8
25658: 0a000033 beq 2572c <scangr+0x12c>
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
2565c: e1a00007 mov r0, r7
25660: e28d1010 add r1, sp, #16
25664: ebffff72 bl 25434 <scanInt>
{
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
25668: e1500008 cmp r0, r8
2566c: 0a00002e beq 2572c <scangr+0x12c>
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
25670: e1a03005 mov r3, r5
25674: e28d100c add r1, sp, #12
25678: e1a00007 mov r0, r7
2567c: e1a02006 mov r2, r6
25680: e3a05001 mov r5, #1
25684: e58d5000 str r5, [sp]
25688: ebffffa4 bl 25520 <scanString>
{
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
2568c: e1500008 cmp r0, r8
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
grp->gr_gid = grgid;
25690: 11dd31b0 ldrhne r3, [sp, #16]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
25694: 159d100c ldrne 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;
25698: 11c430b8 strhne r3, [r4, #8]
{
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
2569c: 1a000003 bne 256b0 <scangr+0xb0>
256a0: ea000021 b 2572c <scangr+0x12c> <== NOT EXECUTED
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
if(*cp == ',')
256a4: e352002c cmp r2, #44 ; 0x2c
memcount++;
256a8: 02855001 addeq r5, r5, #1
256ac: e2888001 add r8, r8, #1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
256b0: e7d12008 ldrb r2, [r1, r8]
256b4: e3520000 cmp r2, #0
256b8: 1afffff9 bne 256a4 <scangr+0xa4>
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
256bc: e1a05105 lsl r5, r5, #2
256c0: e59d3004 ldr r3, [sp, #4]
256c4: e2855013 add r5, r5, #19
256c8: e1530005 cmp r3, r5
256cc: 3a000016 bcc 2572c <scangr+0x12c>
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
256d0: e59d3008 ldr r3, [sp, #8]
256d4: e283300f add r3, r3, #15
256d8: e3c3300f bic r3, r3, #15
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
256dc: 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);
256e0: e584300c str r3, [r4, #12]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
256e4: e59d300c ldr r3, [sp, #12]
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
if(*cp == ',') {
*cp = '\0';
256e8: e1a00002 mov r0, r2
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
256ec: e2833001 add r3, r3, #1
256f0: e2822001 add r2, r2, #1
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
256f4: ea000005 b 25710 <scangr+0x110>
if(*cp == ',') {
256f8: e351002c cmp r1, #44 ; 0x2c
*cp = '\0';
256fc: 05430001 strbeq r0, [r3, #-1]
grp->gr_mem[memcount++] = cp + 1;
25700: 0594100c ldreq r1, [r4, #12]
25704: 07813102 streq r3, [r1, r2, lsl #2]
25708: 02822001 addeq r2, r2, #1
2570c: e2833001 add r3, r3, #1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
25710: e5531001 ldrb r1, [r3, #-1]
25714: e3510000 cmp r1, #0
25718: 1afffff6 bne 256f8 <scangr+0xf8>
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
2571c: e594300c ldr r3, [r4, #12]
25720: e3a00001 mov r0, #1
25724: e7831102 str r1, [r3, r2, lsl #2]
return 1;
25728: ea000000 b 25730 <scangr+0x130>
2572c: e3a00000 mov r0, #0 <== NOT EXECUTED
}
25730: e28dd014 add sp, sp, #20
25734: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
00025774 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
25774: e92d41f0 push {r4, r5, r6, r7, r8, lr}
25778: e24dd014 sub sp, sp, #20
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
2577c: e28d7008 add r7, sp, #8
25780: e28d6004 add r6, sp, #4
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
25784: e58d2008 str r2, [sp, #8]
25788: e58d3004 str r3, [sp, #4]
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
2578c: e3a08000 mov r8, #0
25790: e1a02007 mov r2, r7
25794: e1a03006 mov r3, r6
25798: e58d8000 str r8, [sp]
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
2579c: e1a05000 mov r5, r0
257a0: e1a04001 mov r4, r1
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
257a4: ebffff5d bl 25520 <scanString>
257a8: e1500008 cmp r0, r8
257ac: 0a000038 beq 25894 <scanpw+0x120>
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
257b0: e1a00005 mov r0, r5
257b4: e2841004 add r1, r4, #4
257b8: e1a02007 mov r2, r7
257bc: e1a03006 mov r3, r6
257c0: e58d8000 str r8, [sp]
257c4: ebffff55 bl 25520 <scanString>
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
257c8: e1500008 cmp r0, r8
257cc: 0a000030 beq 25894 <scanpw+0x120>
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &pwuid)
257d0: e1a00005 mov r0, r5
257d4: e28d1010 add r1, sp, #16
257d8: ebffff15 bl 25434 <scanInt>
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
257dc: e1500008 cmp r0, r8
257e0: 0a00002b beq 25894 <scanpw+0x120>
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &pwuid)
|| !scanInt(fp, &pwgid)
257e4: e1a00005 mov r0, r5
257e8: e28d100c add r1, sp, #12
257ec: ebffff10 bl 25434 <scanInt>
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
257f0: e1500008 cmp r0, r8
257f4: 0a000026 beq 25894 <scanpw+0x120>
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &pwuid)
|| !scanInt(fp, &pwgid)
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
257f8: e1a00005 mov r0, r5
257fc: e284100c add r1, r4, #12
25800: e1a02007 mov r2, r7
25804: e1a03006 mov r3, r6
25808: e58d8000 str r8, [sp]
2580c: ebffff43 bl 25520 <scanString>
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
25810: e1500008 cmp r0, r8
25814: 0a00001e beq 25894 <scanpw+0x120>
|| !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)
25818: e1a00005 mov r0, r5
2581c: e2841010 add r1, r4, #16
25820: e1a02007 mov r2, r7
25824: e1a03006 mov r3, r6
25828: e58d8000 str r8, [sp]
2582c: ebffff3b bl 25520 <scanString>
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
25830: e1500008 cmp r0, r8
25834: 0a000016 beq 25894 <scanpw+0x120>
|| !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)
25838: e1a00005 mov r0, r5
2583c: e2841014 add r1, r4, #20
25840: e1a02007 mov r2, r7
25844: e1a03006 mov r3, r6
25848: e58d8000 str r8, [sp]
2584c: ebffff33 bl 25520 <scanString>
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
25850: e1500008 cmp r0, r8
25854: 0a00000e beq 25894 <scanpw+0x120>
|| !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))
25858: e1a00005 mov r0, r5
2585c: e1a02007 mov r2, r7
25860: e1a03006 mov r3, r6
25864: e3a05001 mov r5, #1
25868: e2841018 add r1, r4, #24
2586c: e58d5000 str r5, [sp]
25870: ebffff2a bl 25520 <scanString>
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
25874: e1500008 cmp r0, r8
25878: 0a000005 beq 25894 <scanpw+0x120>
|| !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;
2587c: e1dd30bc ldrh r3, [sp, #12]
25880: e1c430ba strh r3, [r4, #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;
25884: e1dd31b0 ldrh r3, [sp, #16]
pwd->pw_gid = pwgid;
25888: e1a00005 mov r0, r5
|| !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;
2588c: e1c430b8 strh r3, [r4, #8]
pwd->pw_gid = pwgid;
return 1;
25890: ea000000 b 25898 <scanpw+0x124>
25894: e3a00000 mov r0, #0 <== NOT EXECUTED
}
25898: e28dd014 add sp, sp, #20
2589c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
000253ec <setgid>:
int setgid(
gid_t gid
)
{
_POSIX_types_Gid = gid;
253ec: e59f300c ldr r3, [pc, #12] ; 25400 <setgid+0x14> <== NOT EXECUTED
253f0: e5933000 ldr r3, [r3] <== NOT EXECUTED
253f4: e1c303b4 strh r0, [r3, #52] ; 0x34 <== NOT EXECUTED
return 0;
}
253f8: e3a00000 mov r0, #0 <== NOT EXECUTED
253fc: e12fff1e bx lr <== NOT EXECUTED
000259a4 <setgrent>:
return NULL;
return &grent;
}
void setgrent(void)
{
259a4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
init_etc_passwd_group();
259a8: ebffffcb bl 258dc <init_etc_passwd_group> <== NOT EXECUTED
if (group_fp != NULL)
259ac: e59f3020 ldr r3, [pc, #32] ; 259d4 <setgrent+0x30> <== NOT EXECUTED
259b0: e5930000 ldr r0, [r3] <== NOT EXECUTED
259b4: e3500000 cmp r0, #0 <== NOT EXECUTED
fclose(group_fp);
259b8: 1b005d9d blne 3d034 <fclose> <== NOT EXECUTED
group_fp = fopen("/etc/group", "r");
259bc: e59f0014 ldr r0, [pc, #20] ; 259d8 <setgrent+0x34> <== NOT EXECUTED
259c0: e59f1014 ldr r1, [pc, #20] ; 259dc <setgrent+0x38> <== NOT EXECUTED
259c4: eb005fbd bl 3d8c0 <fopen> <== NOT EXECUTED
259c8: e59f3004 ldr r3, [pc, #4] ; 259d4 <setgrent+0x30> <== NOT EXECUTED
259cc: e5830000 str r0, [r3] <== NOT EXECUTED
}
259d0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00025b74 <setpwent>:
return NULL;
return &pwent;
}
void setpwent(void)
{
25b74: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
init_etc_passwd_group();
25b78: ebffff57 bl 258dc <init_etc_passwd_group> <== NOT EXECUTED
if (passwd_fp != NULL)
25b7c: e59f3020 ldr r3, [pc, #32] ; 25ba4 <setpwent+0x30> <== NOT EXECUTED
25b80: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED
25b84: e3500000 cmp r0, #0 <== NOT EXECUTED
fclose(passwd_fp);
25b88: 1b005d29 blne 3d034 <fclose> <== NOT EXECUTED
passwd_fp = fopen("/etc/passwd", "r");
25b8c: e59f0014 ldr r0, [pc, #20] ; 25ba8 <setpwent+0x34> <== NOT EXECUTED
25b90: e59f1014 ldr r1, [pc, #20] ; 25bac <setpwent+0x38> <== NOT EXECUTED
25b94: eb005f49 bl 3d8c0 <fopen> <== NOT EXECUTED
25b98: e59f3004 ldr r3, [pc, #4] ; 25ba4 <setpwent+0x30> <== NOT EXECUTED
25b9c: e5830004 str r0, [r3, #4] <== NOT EXECUTED
}
25ba0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
000077d4 <setuid>:
int setuid(
uid_t uid
)
{
_POSIX_types_Uid = uid;
77d4: e59f300c ldr r3, [pc, #12] ; 77e8 <setuid+0x14> <== NOT EXECUTED
77d8: e5933000 ldr r3, [r3] <== NOT EXECUTED
77dc: e1c303b2 strh r0, [r3, #50] ; 0x32 <== NOT EXECUTED
return 0;
}
77e0: e3a00000 mov r0, #0 <== NOT EXECUTED
77e4: e12fff1e bx lr <== NOT EXECUTED
00003980 <siproc>:
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
3980: e591203c ldr r2, [r1, #60] ; 0x3c <== NOT EXECUTED
3984: e59f3050 ldr r3, [pc, #80] ; 39dc <siproc+0x5c> <== NOT EXECUTED
3988: e0023003 and r3, r2, r3 <== NOT EXECUTED
398c: e3530000 cmp r3, #0 <== NOT EXECUTED
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
3990: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3994: e1a04001 mov r4, r1 <== NOT EXECUTED
3998: 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)) {
399c: 0a00000b beq 39d0 <siproc+0x50> <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
39a0: e3a01000 mov r1, #0 <== NOT EXECUTED
39a4: e1a02001 mov r2, r1 <== NOT EXECUTED
39a8: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED
39ac: eb0005fa bl 519c <rtems_semaphore_obtain> <== NOT EXECUTED
i = iproc (c, tty);
39b0: e1a01004 mov r1, r4 <== NOT EXECUTED
39b4: e1a00005 mov r0, r5 <== NOT EXECUTED
39b8: ebffff8b bl 37ec <iproc> <== NOT EXECUTED
39bc: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
39c0: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED
39c4: eb00063a bl 52b4 <rtems_semaphore_release> <== NOT EXECUTED
}
else {
i = iproc (c, tty);
}
return i;
}
39c8: e1a00005 mov r0, r5 <== NOT EXECUTED
39cc: e8bd8030 pop {r4, r5, pc} <== 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);
39d0: e1a00005 mov r0, r5 <== NOT EXECUTED
}
return i;
}
39d4: 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);
39d8: eaffff83 b 37ec <iproc> <== NOT EXECUTED
00008e34 <stat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
8e34: e92d4070 push {r4, r5, r6, lr}
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
8e38: e2515000 subs r5, r1, #0
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
8e3c: e24dd018 sub sp, sp, #24
8e40: e1a06000 mov r6, r0
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
8e44: 1a000002 bne 8e54 <stat+0x20>
rtems_set_errno_and_return_minus_one( EFAULT );
8e48: eb00d02c bl 3cf00 <__errno>
8e4c: e3a0300e mov r3, #14
8e50: ea000018 b 8eb8 <stat+0x84>
status = rtems_filesystem_evaluate_path( path, strlen( path ),
8e54: eb00eb26 bl 43af4 <strlen>
8e58: e28d4004 add r4, sp, #4
8e5c: e1a01000 mov r1, r0
8e60: e3a0c001 mov ip, #1
8e64: e1a00006 mov r0, r6
8e68: e3a02000 mov r2, #0
8e6c: e1a03004 mov r3, r4
8e70: e58dc000 str ip, [sp]
8e74: ebfff9f0 bl 763c <rtems_filesystem_evaluate_path>
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
8e78: e2501000 subs r1, r0, #0
8e7c: 1a00000e bne 8ebc <stat+0x88>
return -1;
if ( !loc.handlers->fstat_h ){
8e80: e59d300c ldr r3, [sp, #12]
8e84: e5933018 ldr r3, [r3, #24]
8e88: e3530000 cmp r3, #0
8e8c: 1a00000c bne 8ec4 <stat+0x90>
rtems_filesystem_freenode( &loc );
8e90: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
8e94: e3530000 cmp r3, #0 <== NOT EXECUTED
8e98: 0a000004 beq 8eb0 <stat+0x7c> <== NOT EXECUTED
8e9c: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
8ea0: e3530000 cmp r3, #0 <== NOT EXECUTED
8ea4: 11a00004 movne r0, r4 <== NOT EXECUTED
8ea8: 11a0e00f movne lr, pc <== NOT EXECUTED
8eac: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
8eb0: eb00d012 bl 3cf00 <__errno> <== NOT EXECUTED
8eb4: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
8eb8: e5803000 str r3, [r0]
8ebc: e3e05000 mvn r5, #0
8ec0: ea000010 b 8f08 <stat+0xd4>
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
8ec4: e3a02048 mov r2, #72 ; 0x48
8ec8: e1a00005 mov r0, r5
8ecc: eb00dd42 bl 403dc <memset>
status = (*loc.handlers->fstat_h)( &loc, buf );
8ed0: e1a01005 mov r1, r5
8ed4: e59d300c ldr r3, [sp, #12]
8ed8: e1a00004 mov r0, r4
8edc: e1a0e00f mov lr, pc
8ee0: e593f018 ldr pc, [r3, #24]
rtems_filesystem_freenode( &loc );
8ee4: e59d3010 ldr r3, [sp, #16]
8ee8: e3530000 cmp r3, #0
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
status = (*loc.handlers->fstat_h)( &loc, buf );
8eec: e1a05000 mov r5, r0
rtems_filesystem_freenode( &loc );
8ef0: 0a000004 beq 8f08 <stat+0xd4>
8ef4: e593301c ldr r3, [r3, #28]
8ef8: e3530000 cmp r3, #0
8efc: 11a00004 movne r0, r4
8f00: 11a0e00f movne lr, pc
8f04: 112fff13 bxne r3
return status;
}
8f08: e1a00005 mov r0, r5
8f0c: e28dd018 add sp, sp, #24
8f10: e8bd8070 pop {r4, r5, r6, pc}
00026a68 <statvfs>:
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
26a68: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
26a6c: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
26a70: e1a05001 mov r5, r1 <== NOT EXECUTED
26a74: 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 ) )
26a78: eb00741d bl 43af4 <strlen> <== NOT EXECUTED
26a7c: e28d4004 add r4, sp, #4 <== NOT EXECUTED
26a80: e1a01000 mov r1, r0 <== NOT EXECUTED
26a84: e3a0c001 mov ip, #1 <== NOT EXECUTED
26a88: e1a00006 mov r0, r6 <== NOT EXECUTED
26a8c: e3a02000 mov r2, #0 <== NOT EXECUTED
26a90: e1a03004 mov r3, r4 <== NOT EXECUTED
26a94: e58dc000 str ip, [sp] <== NOT EXECUTED
26a98: ebff82e7 bl 763c <rtems_filesystem_evaluate_path> <== NOT EXECUTED
26a9c: e2501000 subs r1, r0, #0 <== NOT EXECUTED
26aa0: 1a000007 bne 26ac4 <statvfs+0x5c> <== NOT EXECUTED
return -1;
mt_entry = loc.mt_entry;
26aa4: e59d6014 ldr r6, [sp, #20] <== NOT EXECUTED
fs_mount_root = &mt_entry->mt_fs_root;
26aa8: e5963028 ldr r3, [r6, #40] ; 0x28 <== NOT EXECUTED
26aac: e5933044 ldr r3, [r3, #68] ; 0x44 <== NOT EXECUTED
26ab0: e3530000 cmp r3, #0 <== NOT EXECUTED
26ab4: 1a000004 bne 26acc <statvfs+0x64> <== NOT EXECUTED
if ( !fs_mount_root->ops->statvfs_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
26ab8: eb005910 bl 3cf00 <__errno> <== NOT EXECUTED
26abc: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
26ac0: e5803000 str r3, [r0] <== NOT EXECUTED
26ac4: e3e05000 mvn r5, #0 <== NOT EXECUTED
26ac8: ea000010 b 26b10 <statvfs+0xa8> <== NOT EXECUTED
memset (sb, 0, sizeof (struct statvfs));
26acc: e3a02038 mov r2, #56 ; 0x38 <== NOT EXECUTED
26ad0: e1a00005 mov r0, r5 <== NOT EXECUTED
26ad4: eb006640 bl 403dc <memset> <== NOT EXECUTED
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
26ad8: e1a01005 mov r1, r5 <== NOT EXECUTED
26adc: e5963028 ldr r3, [r6, #40] ; 0x28 <== NOT EXECUTED
26ae0: e286001c add r0, r6, #28 <== NOT EXECUTED
26ae4: e1a0e00f mov lr, pc <== NOT EXECUTED
26ae8: e593f044 ldr pc, [r3, #68] ; 0x44 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
26aec: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
26af0: 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 );
26af4: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
26af8: 0a000004 beq 26b10 <statvfs+0xa8> <== NOT EXECUTED
26afc: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
26b00: e3530000 cmp r3, #0 <== NOT EXECUTED
26b04: 11a00004 movne r0, r4 <== NOT EXECUTED
26b08: 11a0e00f movne lr, pc <== NOT EXECUTED
26b0c: 112fff13 bxne r3 <== NOT EXECUTED
return result;
}
26b10: e1a00005 mov r0, r5 <== NOT EXECUTED
26b14: e28dd018 add sp, sp, #24 <== NOT EXECUTED
26b18: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00026b68 <symlink>:
int symlink(
const char *actualpath,
const char *sympath
)
{
26b68: e92d4070 push {r4, r5, r6, lr}
26b6c: e1a05001 mov r5, r1
26b70: e24dd01c sub sp, sp, #28
26b74: 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 );
26b78: e28d1018 add r1, sp, #24
26b7c: e1a00005 mov r0, r5
26b80: e1a0200d mov r2, sp
26b84: ebff88e5 bl 8f20 <rtems_filesystem_get_start_loc>
if ( !loc.ops->evalformake_h ) {
26b88: e59d300c ldr r3, [sp, #12]
26b8c: e5933004 ldr r3, [r3, #4]
26b90: 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 );
26b94: e1a0400d mov r4, sp
if ( !loc.ops->evalformake_h ) {
26b98: 0a000010 beq 26be0 <symlink+0x78>
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start );
26b9c: e59d0018 ldr r0, [sp, #24]
26ba0: e1a0100d mov r1, sp
26ba4: e0850000 add r0, r5, r0
26ba8: e28d2014 add r2, sp, #20
26bac: e1a0e00f mov lr, pc
26bb0: e12fff13 bx r3
if ( result != 0 )
26bb4: e3500000 cmp r0, #0
26bb8: 1a00000b bne 26bec <symlink+0x84>
return -1;
if ( !loc.ops->symlink_h ) {
26bbc: e59d200c ldr r2, [sp, #12]
26bc0: e5923038 ldr r3, [r2, #56] ; 0x38
26bc4: e3530000 cmp r3, #0
26bc8: 1a000009 bne 26bf4 <symlink+0x8c>
rtems_filesystem_freenode( &loc );
26bcc: e592301c ldr r3, [r2, #28] <== NOT EXECUTED
26bd0: e3530000 cmp r3, #0 <== NOT EXECUTED
26bd4: 11a0000d movne r0, sp <== NOT EXECUTED
26bd8: 11a0e00f movne lr, pc <== NOT EXECUTED
26bdc: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
26be0: eb0058c6 bl 3cf00 <__errno> <== NOT EXECUTED
26be4: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
26be8: e5803000 str r3, [r0] <== NOT EXECUTED
26bec: e3e05000 mvn r5, #0
26bf0: ea00000d b 26c2c <symlink+0xc4>
}
result = (*loc.ops->symlink_h)( &loc, actualpath, name_start);
26bf4: e1a01006 mov r1, r6
26bf8: e1a0000d mov r0, sp
26bfc: e59d2014 ldr r2, [sp, #20]
26c00: e1a0e00f mov lr, pc
26c04: e12fff13 bx r3
rtems_filesystem_freenode( &loc );
26c08: e59d300c ldr r3, [sp, #12]
26c0c: 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);
26c10: e1a05000 mov r5, r0
rtems_filesystem_freenode( &loc );
26c14: 0a000004 beq 26c2c <symlink+0xc4>
26c18: e593301c ldr r3, [r3, #28]
26c1c: e3530000 cmp r3, #0
26c20: 11a0000d movne r0, sp
26c24: 11a0e00f movne lr, pc
26c28: 112fff13 bxne r3
return result;
}
26c2c: e1a00005 mov r0, r5
26c30: e28dd01c add sp, sp, #28
26c34: e8bd8070 pop {r4, r5, r6, pc}
00010f34 <tcsetattr>:
int fd,
int opt,
struct termios *tp
)
{
switch (opt) {
10f34: e3510000 cmp r1, #0
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
10f38: e92d4030 push {r4, r5, lr}
10f3c: e1a04002 mov r4, r2
10f40: e1a05000 mov r5, r0
switch (opt) {
10f44: 0a00000a beq 10f74 <tcsetattr+0x40>
10f48: e3510001 cmp r1, #1 <== NOT EXECUTED
10f4c: 0a000003 beq 10f60 <tcsetattr+0x2c> <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
10f50: eb001052 bl 150a0 <__errno> <== NOT EXECUTED
10f54: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
10f58: e5803000 str r3, [r0] <== NOT EXECUTED
10f5c: ea000009 b 10f88 <tcsetattr+0x54> <== NOT EXECUTED
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
10f60: e3a01003 mov r1, #3 <== NOT EXECUTED
10f64: e3a02000 mov r2, #0 <== NOT EXECUTED
10f68: eb000e29 bl 14814 <ioctl> <== NOT EXECUTED
10f6c: e3500000 cmp r0, #0 <== NOT EXECUTED
10f70: ba000004 blt 10f88 <tcsetattr+0x54> <== NOT EXECUTED
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
10f74: e1a00005 mov r0, r5
10f78: e1a02004 mov r2, r4
10f7c: e3a01002 mov r1, #2
}
}
10f80: e8bd4030 pop {r4, r5, lr}
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
10f84: ea000e22 b 14814 <ioctl>
}
}
10f88: e3e00000 mvn r0, #0 <== NOT EXECUTED
10f8c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
0000cca0 <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
cca0: e92d4070 push {r4, r5, r6, lr}
cca4: e24dd030 sub sp, sp, #48 ; 0x30
cca8: e1a06000 mov r6, r0
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
ccac: ebffd422 bl 1d3c <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
ccb0: e2504000 subs r4, r0, #0
ccb4: e28d3018 add r3, sp, #24
ccb8: 1a000005 bne ccd4 <unlink+0x34>
rtems_filesystem_get_start_loc( path, &i, &parentloc );
ccbc: e1a02003 mov r2, r3
ccc0: e1a00006 mov r0, r6
ccc4: e28d102c add r1, sp, #44 ; 0x2c
ccc8: ebffd81e bl 2d48 <rtems_filesystem_get_start_loc>
cccc: e1a05004 mov r5, r4
ccd0: ea000008 b ccf8 <unlink+0x58>
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
ccd4: e3a0c000 mov ip, #0
ccd8: e1a00006 mov r0, r6
ccdc: e1a01004 mov r1, r4
cce0: e3a02002 mov r2, #2
cce4: e58dc000 str ip, [sp]
cce8: ebffd45a bl 1e58 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
ccec: e3500000 cmp r0, #0
ccf0: 1a000072 bne cec0 <unlink+0x220>
ccf4: e3a05001 mov r5, #1
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
ccf8: e28de018 add lr, sp, #24
ccfc: e8be000f ldm lr!, {r0, r1, r2, r3}
cd00: e28dc004 add ip, sp, #4
cd04: e8ac000f stmia ip!, {r0, r1, r2, r3}
cd08: e59e3000 ldr r3, [lr]
name = path + parentpathlen;
cd0c: e0864004 add r4, r6, r4
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
cd10: e58c3000 str r3, [ip]
name = path + parentpathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
cd14: e1a00004 mov r0, r4
cd18: eb0005ae bl e3d8 <strlen>
cd1c: e1a01000 mov r1, r0
cd20: e1a00004 mov r0, r4
cd24: ebffd3f4 bl 1cfc <rtems_filesystem_prefix_separators>
cd28: e0846000 add r6, r4, r0
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
cd2c: e1a00006 mov r0, r6
cd30: eb0005a8 bl e3d8 <strlen>
cd34: e28d4004 add r4, sp, #4
cd38: e3a0c000 mov ip, #0
cd3c: e1a01000 mov r1, r0
cd40: e1a0200c mov r2, ip
cd44: e1a00006 mov r0, r6
cd48: e1a03004 mov r3, r4
cd4c: e58dc000 str ip, [sp]
cd50: ebffd408 bl 1d78 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
cd54: e3500000 cmp r0, #0
cd58: 0a00000b beq cd8c <unlink+0xec>
if ( free_parentloc )
cd5c: e3550000 cmp r5, #0
cd60: 0a000056 beq cec0 <unlink+0x220>
rtems_filesystem_freenode( &parentloc );
cd64: e59d3024 ldr r3, [sp, #36] ; 0x24
cd68: e3530000 cmp r3, #0
cd6c: 0a000053 beq cec0 <unlink+0x220>
cd70: e593301c ldr r3, [r3, #28]
cd74: e3530000 cmp r3, #0
cd78: 0a000050 beq cec0 <unlink+0x220>
cd7c: e28d0018 add r0, sp, #24
cd80: e1a0e00f mov lr, pc
cd84: e12fff13 bx r3
cd88: ea00004c b cec0 <unlink+0x220>
return -1;
}
if ( !loc.ops->node_type_h ) {
cd8c: e59d2010 ldr r2, [sp, #16]
cd90: e5923010 ldr r3, [r2, #16]
cd94: e3530000 cmp r3, #0
cd98: 0a00001c beq ce10 <unlink+0x170>
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 ) {
cd9c: e1a00004 mov r0, r4
cda0: e1a0e00f mov lr, pc
cda4: e12fff13 bx r3
cda8: e3500001 cmp r0, #1
cdac: e59d2010 ldr r2, [sp, #16]
cdb0: 1a000013 bne ce04 <unlink+0x164>
rtems_filesystem_freenode( &loc );
cdb4: e3520000 cmp r2, #0
cdb8: 0a000004 beq cdd0 <unlink+0x130>
cdbc: e592301c ldr r3, [r2, #28]
cdc0: e3530000 cmp r3, #0
cdc4: 11a00004 movne r0, r4
cdc8: 11a0e00f movne lr, pc
cdcc: 112fff13 bxne r3
if ( free_parentloc )
cdd0: e3550000 cmp r5, #0
cdd4: 0a000007 beq cdf8 <unlink+0x158>
rtems_filesystem_freenode( &parentloc );
cdd8: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
cddc: e3530000 cmp r3, #0 <== NOT EXECUTED
cde0: 0a000004 beq cdf8 <unlink+0x158> <== NOT EXECUTED
cde4: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
cde8: e3530000 cmp r3, #0 <== NOT EXECUTED
cdec: 128d0018 addne r0, sp, #24 <== NOT EXECUTED
cdf0: 11a0e00f movne lr, pc <== NOT EXECUTED
cdf4: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EISDIR );
cdf8: eb000171 bl d3c4 <__errno>
cdfc: e3a03015 mov r3, #21
ce00: ea000013 b ce54 <unlink+0x1b4>
}
if ( !loc.ops->unlink_h ) {
ce04: e592300c ldr r3, [r2, #12]
ce08: e3530000 cmp r3, #0
ce0c: 1a000012 bne ce5c <unlink+0x1bc>
rtems_filesystem_freenode( &loc );
ce10: e592301c ldr r3, [r2, #28] <== NOT EXECUTED
ce14: e3530000 cmp r3, #0 <== NOT EXECUTED
ce18: 11a00004 movne r0, r4 <== NOT EXECUTED
ce1c: 11a0e00f movne lr, pc <== NOT EXECUTED
ce20: 112fff13 bxne r3 <== NOT EXECUTED
if ( free_parentloc )
ce24: e3550000 cmp r5, #0 <== NOT EXECUTED
ce28: 0a000007 beq ce4c <unlink+0x1ac> <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
ce2c: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
ce30: e3530000 cmp r3, #0 <== NOT EXECUTED
ce34: 0a000004 beq ce4c <unlink+0x1ac> <== NOT EXECUTED
ce38: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
ce3c: e3530000 cmp r3, #0 <== NOT EXECUTED
ce40: 128d0018 addne r0, sp, #24 <== NOT EXECUTED
ce44: 11a0e00f movne lr, pc <== NOT EXECUTED
ce48: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
ce4c: eb00015c bl d3c4 <__errno> <== NOT EXECUTED
ce50: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
ce54: e5803000 str r3, [r0]
ce58: ea000018 b cec0 <unlink+0x220>
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
ce5c: e28d0018 add r0, sp, #24
ce60: e1a01004 mov r1, r4
ce64: e1a0e00f mov lr, pc
ce68: e12fff13 bx r3
rtems_filesystem_freenode( &loc );
ce6c: e59d3010 ldr r3, [sp, #16]
ce70: 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 );
ce74: e1a06000 mov r6, r0
rtems_filesystem_freenode( &loc );
ce78: 0a000004 beq ce90 <unlink+0x1f0>
ce7c: e593301c ldr r3, [r3, #28]
ce80: e3530000 cmp r3, #0
ce84: 11a00004 movne r0, r4
ce88: 11a0e00f movne lr, pc
ce8c: 112fff13 bxne r3
if ( free_parentloc )
ce90: e3550000 cmp r5, #0
ce94: 0a00000a beq cec4 <unlink+0x224>
rtems_filesystem_freenode( &parentloc );
ce98: e59d3024 ldr r3, [sp, #36] ; 0x24
ce9c: e3530000 cmp r3, #0
cea0: 0a000007 beq cec4 <unlink+0x224>
cea4: e593301c ldr r3, [r3, #28]
cea8: e3530000 cmp r3, #0
ceac: 0a000004 beq cec4 <unlink+0x224>
ceb0: e28d0018 add r0, sp, #24
ceb4: e1a0e00f mov lr, pc
ceb8: e12fff13 bx r3
cebc: ea000000 b cec4 <unlink+0x224>
cec0: e3e06000 mvn r6, #0
return result;
}
cec4: e1a00006 mov r0, r6
cec8: e28dd030 add sp, sp, #48 ; 0x30
cecc: e8bd8070 pop {r4, r5, r6, pc}
00026cc0 <unmount>:
*/
int unmount(
const char *path
)
{
26cc0: e92d4030 push {r4, r5, lr}
26cc4: e24dd018 sub sp, sp, #24
26cc8: 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 ) )
26ccc: eb007388 bl 43af4 <strlen>
26cd0: e28d4004 add r4, sp, #4
26cd4: e1a01000 mov r1, r0
26cd8: e3a0c001 mov ip, #1
26cdc: e1a00005 mov r0, r5
26ce0: e3a02000 mov r2, #0
26ce4: e1a03004 mov r3, r4
26ce8: e58dc000 str ip, [sp]
26cec: ebff8252 bl 763c <rtems_filesystem_evaluate_path>
26cf0: e3500000 cmp r0, #0
26cf4: 1a00005b bne 26e68 <unmount+0x1a8>
return -1;
mt_entry = loc.mt_entry;
26cf8: e59d5014 ldr r5, [sp, #20]
fs_mount_loc = &mt_entry->mt_point_node;
fs_root_loc = &mt_entry->mt_fs_root;
26cfc: e59d3004 ldr r3, [sp, #4]
26d00: e595201c ldr r2, [r5, #28]
26d04: e1520003 cmp r2, r3
26d08: e59d3010 ldr r3, [sp, #16]
26d0c: 0a000009 beq 26d38 <unmount+0x78>
/*
* 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 );
26d10: e3530000 cmp r3, #0
26d14: 0a000004 beq 26d2c <unmount+0x6c>
26d18: e593301c ldr r3, [r3, #28]
26d1c: e3530000 cmp r3, #0
26d20: 11a00004 movne r0, r4
26d24: 11a0e00f movne lr, pc
26d28: 112fff13 bxne r3
rtems_set_errno_and_return_minus_one( EACCES );
26d2c: eb005873 bl 3cf00 <__errno>
26d30: e3a0300d mov r3, #13
26d34: ea000021 b 26dc0 <unmount+0x100>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
26d38: e3530000 cmp r3, #0
26d3c: 0a000004 beq 26d54 <unmount+0x94>
26d40: e593301c ldr r3, [r3, #28]
26d44: e3530000 cmp r3, #0
26d48: 11a00004 movne r0, r4
26d4c: 11a0e00f movne lr, pc
26d50: 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;
26d54: e5953014 ldr r3, [r5, #20]
26d58: e5933028 ldr r3, [r3, #40] ; 0x28
26d5c: e3530000 cmp r3, #0
26d60: 0a000003 beq 26d74 <unmount+0xb4>
fs_root_loc = &mt_entry->mt_fs_root;
26d64: e5953028 ldr r3, [r5, #40] ; 0x28
26d68: e593302c ldr r3, [r3, #44] ; 0x2c
26d6c: e3530000 cmp r3, #0
26d70: 1a000002 bne 26d80 <unmount+0xc0>
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 );
26d74: eb005861 bl 3cf00 <__errno> <== NOT EXECUTED
26d78: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
26d7c: ea00000f b 26dc0 <unmount+0x100> <== NOT EXECUTED
* 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 )
26d80: e59f30ec ldr r3, [pc, #236] ; 26e74 <unmount+0x1b4>
26d84: e5933000 ldr r3, [r3]
26d88: e5933014 ldr r3, [r3, #20]
26d8c: e1530005 cmp r3, r5
26d90: 0a000008 beq 26db8 <unmount+0xf8>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
26d94: e59f00dc ldr r0, [pc, #220] ; 26e78 <unmount+0x1b8>
26d98: e595102c ldr r1, [r5, #44] ; 0x2c
26d9c: ebff84ad bl 8058 <rtems_filesystem_mount_iterate>
26da0: e3500000 cmp r0, #0
26da4: 1a000003 bne 26db8 <unmount+0xf8>
* 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 )
26da8: e1a00005 mov r0, r5
26dac: ebff8313 bl 7a00 <rtems_libio_is_open_files_in_fs>
26db0: e3500001 cmp r0, #1
26db4: 1a000003 bne 26dc8 <unmount+0x108>
rtems_set_errno_and_return_minus_one( EBUSY );
26db8: eb005850 bl 3cf00 <__errno>
26dbc: e3a03010 mov r3, #16
26dc0: e5803000 str r3, [r0]
26dc4: ea000027 b 26e68 <unmount+0x1a8>
* 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 )
26dc8: e5953014 ldr r3, [r5, #20]
26dcc: e1a00005 mov r0, r5
26dd0: e1a0e00f mov lr, pc
26dd4: e593f028 ldr pc, [r3, #40] ; 0x28
26dd8: e2504000 subs r4, r0, #0
26ddc: 1a000021 bne 26e68 <unmount+0x1a8>
* 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){
26de0: e5953028 ldr r3, [r5, #40] ; 0x28
26de4: e1a00005 mov r0, r5
26de8: e1a0e00f mov lr, pc
26dec: e593f02c ldr pc, [r3, #44] ; 0x2c
26df0: e2501000 subs r1, r0, #0
26df4: 0a000007 beq 26e18 <unmount+0x158>
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
26df8: e1a00005 mov r0, r5 <== NOT EXECUTED
26dfc: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED
26e00: e1a0e00f mov lr, pc <== NOT EXECUTED
26e04: e593f020 ldr pc, [r3, #32] <== NOT EXECUTED
26e08: e3500000 cmp r0, #0 <== NOT EXECUTED
26e0c: 0a000015 beq 26e68 <unmount+0x1a8> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
26e10: e1a00004 mov r0, r4 <== NOT EXECUTED
26e14: ebff9479 bl c000 <rtems_fatal_error_occurred> <== 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 );
26e18: e59f405c ldr r4, [pc, #92] ; 26e7c <unmount+0x1bc>
26e1c: e1a02001 mov r2, r1
26e20: e5940000 ldr r0, [r4]
26e24: ebff92a5 bl b8c0 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
26e28: e1a00005 mov r0, r5
26e2c: ebff9583 bl c440 <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
26e30: e5940000 ldr r0, [r4]
26e34: ebff92e7 bl b9d8 <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 );
26e38: e5953014 ldr r3, [r5, #20]
26e3c: e3530000 cmp r3, #0
26e40: 0a000004 beq 26e58 <unmount+0x198>
26e44: e593301c ldr r3, [r3, #28]
26e48: e3530000 cmp r3, #0
26e4c: 12850008 addne r0, r5, #8
26e50: 11a0e00f movne lr, pc
26e54: 112fff13 bxne r3
free( mt_entry );
26e58: e1a00005 mov r0, r5
26e5c: ebff8214 bl 76b4 <free>
26e60: e3a00000 mov r0, #0
return 0;
26e64: ea000000 b 26e6c <unmount+0x1ac>
26e68: e3e00000 mvn r0, #0
}
26e6c: e28dd018 add sp, sp, #24
26e70: e8bd8030 pop {r4, r5, pc}
00026e80 <utime>:
int utime(
const char *path,
const struct utimbuf *times
)
{
26e80: e92d4070 push {r4, r5, r6, lr}
26e84: e24dd018 sub sp, sp, #24
26e88: e1a05001 mov r5, r1
26e8c: 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 ) )
26e90: eb007317 bl 43af4 <strlen>
26e94: e28d4004 add r4, sp, #4
26e98: e1a01000 mov r1, r0
26e9c: e3a0c001 mov ip, #1
26ea0: e1a00006 mov r0, r6
26ea4: e3a02000 mov r2, #0
26ea8: e1a03004 mov r3, r4
26eac: e58dc000 str ip, [sp]
26eb0: ebff81e1 bl 763c <rtems_filesystem_evaluate_path>
26eb4: e3500000 cmp r0, #0
26eb8: 1a00000b bne 26eec <utime+0x6c>
return -1;
if ( !temp_loc.ops->utime_h ){
26ebc: e59d2010 ldr r2, [sp, #16]
26ec0: e5923030 ldr r3, [r2, #48] ; 0x30
26ec4: e3530000 cmp r3, #0
26ec8: 1a000009 bne 26ef4 <utime+0x74>
rtems_filesystem_freenode( &temp_loc );
26ecc: e592301c ldr r3, [r2, #28] <== NOT EXECUTED
26ed0: e3530000 cmp r3, #0 <== NOT EXECUTED
26ed4: 11a00004 movne r0, r4 <== NOT EXECUTED
26ed8: 11a0e00f movne lr, pc <== NOT EXECUTED
26edc: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
26ee0: eb005806 bl 3cf00 <__errno> <== NOT EXECUTED
26ee4: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
26ee8: e5803000 str r3, [r0] <== NOT EXECUTED
26eec: e3e05000 mvn r5, #0
26ef0: ea00000c b 26f28 <utime+0xa8>
}
result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime );
26ef4: e8950006 ldm r5, {r1, r2}
26ef8: e1a00004 mov r0, r4
26efc: e1a0e00f mov lr, pc
26f00: e12fff13 bx r3
rtems_filesystem_freenode( &temp_loc );
26f04: e59d3010 ldr r3, [sp, #16]
26f08: 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 );
26f0c: e1a05000 mov r5, r0
rtems_filesystem_freenode( &temp_loc );
26f10: 0a000004 beq 26f28 <utime+0xa8>
26f14: e593301c ldr r3, [r3, #28]
26f18: e3530000 cmp r3, #0
26f1c: 11a00004 movne r0, r4
26f20: 11a0e00f movne lr, pc
26f24: 112fff13 bxne r3
return result;
}
26f28: e1a00005 mov r0, r5
26f2c: e28dd018 add sp, sp, #24
26f30: e8bd8070 pop {r4, r5, r6, pc}
00019178 <write>:
)
{
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
19178: e59f30b0 ldr r3, [pc, #176] ; 19230 <write+0xb8>
1917c: e5933000 ldr r3, [r3]
19180: e1500003 cmp r0, r3
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
19184: e92d4070 push {r4, r5, r6, lr}
19188: e1a05001 mov r5, r1
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
1918c: 2a00000f bcs 191d0 <write+0x58>
iop = rtems_libio_iop( fd );
19190: e59f309c ldr r3, [pc, #156] ; 19234 <write+0xbc>
19194: e5934000 ldr r4, [r3]
19198: e0844300 add r4, r4, r0, lsl #6
rtems_libio_check_is_open( iop );
1919c: e5943014 ldr r3, [r4, #20]
191a0: e3130c01 tst r3, #256 ; 0x100
191a4: 0a000009 beq 191d0 <write+0x58>
rtems_libio_check_buffer( buffer );
191a8: e3510000 cmp r1, #0
191ac: 1a000002 bne 191bc <write+0x44>
191b0: ebffd083 bl d3c4 <__errno> <== NOT EXECUTED
191b4: e3a03016 mov r3, #22 <== NOT EXECUTED
191b8: ea00000d b 191f4 <write+0x7c> <== NOT EXECUTED
rtems_libio_check_count( count );
191bc: e3520000 cmp r2, #0
191c0: 01a00002 moveq r0, r2
191c4: 08bd8070 popeq {r4, r5, r6, pc}
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
191c8: e3130004 tst r3, #4
191cc: 1a000002 bne 191dc <write+0x64>
191d0: ebffd07b bl d3c4 <__errno> <== NOT EXECUTED
191d4: e3a03009 mov r3, #9 <== NOT EXECUTED
191d8: ea000005 b 191f4 <write+0x7c> <== NOT EXECUTED
/*
* Now process the write() request.
*/
if ( !iop->handlers->write_h )
191dc: e594303c ldr r3, [r4, #60] ; 0x3c
191e0: e593300c ldr r3, [r3, #12]
191e4: e3530000 cmp r3, #0
191e8: 1a000004 bne 19200 <write+0x88>
rtems_set_errno_and_return_minus_one( ENOTSUP );
191ec: ebffd074 bl d3c4 <__errno> <== NOT EXECUTED
191f0: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
191f4: e5803000 str r3, [r0] <== NOT EXECUTED
191f8: e3e00000 mvn r0, #0 <== NOT EXECUTED
191fc: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
rc = (*iop->handlers->write_h)( iop, buffer, count );
19200: e1a00004 mov r0, r4
19204: e1a0e00f mov lr, pc
19208: e12fff13 bx r3
if ( rc > 0 )
1920c: e3500000 cmp r0, #0
19210: d8bd8070 pople {r4, r5, r6, pc}
iop->offset += rc;
19214: e284600c add r6, r4, #12
19218: e8960060 ldm r6, {r5, r6}
1921c: e0952000 adds r2, r5, r0
19220: e0a63fc0 adc r3, r6, r0, asr #31
19224: e584200c str r2, [r4, #12]
19228: e5843010 str r3, [r4, #16]
return rc;
}
1922c: e8bd8070 pop {r4, r5, r6, pc}
00005b6c <writev>:
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
5b6c: e59f3158 ldr r3, [pc, #344] ; 5ccc <writev+0x160>
5b70: e5933000 ldr r3, [r3]
5b74: e1500003 cmp r0, r3
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
5b78: e92d49f0 push {r4, r5, r6, r7, r8, fp, lr}
5b7c: e1a08002 mov r8, r2
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
5b80: 2a000007 bcs 5ba4 <writev+0x38>
iop = rtems_libio_iop( fd );
5b84: e59f3144 ldr r3, [pc, #324] ; 5cd0 <writev+0x164>
5b88: e5936000 ldr r6, [r3]
5b8c: e0866300 add r6, r6, r0, lsl #6
rtems_libio_check_is_open( iop );
5b90: e5963014 ldr r3, [r6, #20]
5b94: e3130c01 tst r3, #256 ; 0x100
5b98: 0a000001 beq 5ba4 <writev+0x38>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
5b9c: e3130004 tst r3, #4
5ba0: 1a000002 bne 5bb0 <writev+0x44>
5ba4: eb00222c bl e45c <__errno>
5ba8: e3a03009 mov r3, #9
5bac: ea000020 b 5c34 <writev+0xc8>
/*
* Argument validation on IO vector
*/
if ( !iov )
5bb0: e3510000 cmp r1, #0
5bb4: 0a00001c beq 5c2c <writev+0xc0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
5bb8: e3520000 cmp r2, #0
5bbc: da00001a ble 5c2c <writev+0xc0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
5bc0: e3520b01 cmp r2, #1024 ; 0x400
5bc4: ca000018 bgt 5c2c <writev+0xc0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !iop->handlers->write_h )
5bc8: e596303c ldr r3, [r6, #60] ; 0x3c
5bcc: e593300c ldr r3, [r3, #12]
5bd0: e3530000 cmp r3, #0
5bd4: 1a000002 bne 5be4 <writev+0x78>
rtems_set_errno_and_return_minus_one( ENOTSUP );
5bd8: eb00221f bl e45c <__errno> <== NOT EXECUTED
5bdc: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
5be0: ea000013 b 5c34 <writev+0xc8> <== NOT EXECUTED
5be4: e3a03000 mov r3, #0
5be8: e1a05001 mov r5, r1
5bec: e1a02001 mov r2, r1
5bf0: e3a07001 mov r7, #1
5bf4: e1a04003 mov r4, r3
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
if ( !iov[v].iov_base )
5bf8: e5921000 ldr r1, [r2]
5bfc: e3510000 cmp r1, #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++ ) {
5c00: e2833001 add r3, r3, #1
if ( !iov[v].iov_base )
5c04: 0a000008 beq 5c2c <writev+0xc0>
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 )
5c08: e5920004 ldr r0, [r2, #4]
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
5c0c: e0841000 add r1, r4, r0
if ( total < old || total > SSIZE_MAX )
5c10: e1510004 cmp r1, r4
5c14: a3a04000 movge r4, #0
5c18: b3a04001 movlt r4, #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 )
5c1c: e3500000 cmp r0, #0
5c20: 13a07000 movne r7, #0
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
5c24: e1944fa1 orrs r4, r4, r1, lsr #31
5c28: 0a000003 beq 5c3c <writev+0xd0>
rtems_set_errno_and_return_minus_one( EINVAL );
5c2c: eb00220a bl e45c <__errno>
5c30: e3a03016 mov r3, #22
5c34: e5803000 str r3, [r0]
5c38: ea000011 b 5c84 <writev+0x118>
* 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++ ) {
5c3c: e1530008 cmp r3, r8
5c40: e2822008 add r2, r2, #8
5c44: b1a04001 movlt r4, r1
5c48: baffffea blt 5bf8 <writev+0x8c>
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
5c4c: e3570000 cmp r7, #0
5c50: 1a00001b bne 5cc4 <writev+0x158>
5c54: e1a04007 mov r4, r7
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
5c58: e5952004 ldr r2, [r5, #4]
5c5c: e3520000 cmp r2, #0
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
5c60: e2877001 add r7, r7, #1
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
5c64: 0a000013 beq 5cb8 <writev+0x14c>
continue;
bytes = (*iop->handlers->write_h)( iop, iov[v].iov_base, iov[v].iov_len );
5c68: e5951000 ldr r1, [r5]
5c6c: e596303c ldr r3, [r6, #60] ; 0x3c
5c70: e1a00006 mov r0, r6
5c74: e1a0e00f mov lr, pc
5c78: e593f00c ldr pc, [r3, #12]
if ( bytes < 0 )
5c7c: e3500000 cmp r0, #0
5c80: aa000001 bge 5c8c <writev+0x120>
5c84: e3e04000 mvn r4, #0
5c88: ea00000d b 5cc4 <writev+0x158>
return -1;
if ( bytes > 0 ) {
5c8c: 0a000006 beq 5cac <writev+0x140>
iop->offset += bytes;
5c90: e286c00c add ip, r6, #12
5c94: e89c1800 ldm ip, {fp, ip}
5c98: e09b2000 adds r2, fp, r0
5c9c: e0ac3fc0 adc r3, ip, r0, asr #31
5ca0: e586200c str r2, [r6, #12]
5ca4: e5863010 str r3, [r6, #16]
total += bytes;
5ca8: e0844000 add r4, r4, r0
}
if (bytes != iov[ v ].iov_len)
5cac: e5953004 ldr r3, [r5, #4]
5cb0: e1500003 cmp r0, r3
5cb4: 1a000002 bne 5cc4 <writev+0x158>
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
5cb8: e1570008 cmp r7, r8
5cbc: e2855008 add r5, r5, #8
5cc0: baffffe4 blt 5c58 <writev+0xec>
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
5cc4: e1a00004 mov r0, r4
5cc8: e8bd89f0 pop {r4, r5, r6, r7, r8, fp, pc}