00004318 <IMFS_dump_directory>:
*/
static void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
4318: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
431c: e59f513c ldr r5, [pc, #316] ; 4460 <IMFS_dump_directory+0x148>
4320: e1a06000 mov r6, r0
4324: e1a07001 mov r7, r1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
4328: e5904050 ldr r4, [r0, #80] ; 0x50
432c: e1a08005 mov r8, r5
IMFS_assert( level >= 0 );
IMFS_assert( IMFS_is_directory( the_directory ) );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
4330: ea000046 b 4450 <IMFS_dump_directory+0x138>
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
4334: e5953000 ldr r3, [r5]
4338: e59f0124 ldr r0, [pc, #292] ; 4464 <IMFS_dump_directory+0x14c>
433c: e5931008 ldr r1, [r3, #8]
4340: eb003515 bl 1179c <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++ )
4344: e28aa001 add sl, sl, #1
4348: ea000000 b 4350 <IMFS_dump_directory+0x38>
IMFS_assert( level >= 0 );
IMFS_assert( IMFS_is_directory( the_directory ) );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
434c: e3a0a000 mov sl, #0
!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++ )
4350: e15a0007 cmp sl, r7
4354: dafffff6 ble 4334 <IMFS_dump_directory+0x1c>
IMFS_jnode_t *the_jnode
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
4358: e5983000 ldr r3, [r8]
435c: e284000c add r0, r4, #12
4360: e5931008 ldr r1, [r3, #8]
4364: eb00350c bl 1179c <fputs>
rtems_chain_extract_unprotected( &node->Node );
}
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{
return node->control->imfs_type;
4368: e594304c ldr r3, [r4, #76] ; 0x4c
436c: e5932000 ldr r2, [r3]
switch( IMFS_type( the_jnode ) ) {
4370: e3520006 cmp r2, #6
4374: 979ff102 ldrls pc, [pc, r2, lsl #2]
4378: ea000026 b 4418 <IMFS_dump_directory+0x100> <== NOT EXECUTED
437c: 00004398 .word 0x00004398 <== NOT EXECUTED
4380: 000043ac .word 0x000043ac <== NOT EXECUTED
4384: 000043f8 .word 0x000043f8 <== NOT EXECUTED
4388: 000043f8 .word 0x000043f8 <== NOT EXECUTED
438c: 000043e0 .word 0x000043e0 <== NOT EXECUTED
4390: 000043c4 .word 0x000043c4 <== NOT EXECUTED
4394: 00004404 .word 0x00004404 <== NOT EXECUTED
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
4398: e5953000 ldr r3, [r5]
439c: e3a0002f mov r0, #47 ; 0x2f
43a0: e5931008 ldr r1, [r3, #8]
43a4: eb0034c7 bl 116c8 <fputc>
43a8: ea00001f b 442c <IMFS_dump_directory+0x114>
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
43ac: e5953000 ldr r3, [r5]
43b0: e2842050 add r2, r4, #80 ; 0x50
43b4: e5930008 ldr r0, [r3, #8]
43b8: e59f10a8 ldr r1, [pc, #168] ; 4468 <IMFS_dump_directory+0x150>
43bc: e892000c ldm r2, {r2, r3}
43c0: ea000004 b 43d8 <IMFS_dump_directory+0xc0>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
43c4: e5953000 ldr r3, [r5]
43c8: e59f109c ldr r1, [pc, #156] ; 446c <IMFS_dump_directory+0x154>
43cc: e5930008 ldr r0, [r3, #8]
43d0: e5942050 ldr r2, [r4, #80] ; 0x50
43d4: e5943058 ldr r3, [r4, #88] ; 0x58
43d8: eb00349a bl 11648 <fprintf>
43dc: ea000012 b 442c <IMFS_dump_directory+0x114>
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
43e0: e5953000 ldr r3, [r5]
43e4: e59f1084 ldr r1, [pc, #132] ; 4470 <IMFS_dump_directory+0x158>
43e8: e5930008 ldr r0, [r3, #8]
43ec: e5942050 ldr r2, [r4, #80] ; 0x50
43f0: eb003494 bl 11648 <fprintf>
43f4: ea00000c b 442c <IMFS_dump_directory+0x114>
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
43f8: e5953000 ldr r3, [r5]
43fc: e59f0070 ldr r0, [pc, #112] ; 4474 <IMFS_dump_directory+0x15c>
4400: ea000001 b 440c <IMFS_dump_directory+0xf4>
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
4404: e5953000 ldr r3, [r5]
4408: e59f0068 ldr r0, [pc, #104] ; 4478 <IMFS_dump_directory+0x160>
440c: e5931008 ldr r1, [r3, #8]
4410: eb0034e1 bl 1179c <fputs>
4414: ea000006 b 4434 <IMFS_dump_directory+0x11c>
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
4418: e5953000 ldr r3, [r5] <== NOT EXECUTED
441c: e59f1058 ldr r1, [pc, #88] ; 447c <IMFS_dump_directory+0x164><== NOT EXECUTED
4420: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
4424: eb003487 bl 11648 <fprintf> <== NOT EXECUTED
4428: ea000001 b 4434 <IMFS_dump_directory+0x11c> <== NOT EXECUTED
return;
}
puts("");
442c: e59f004c ldr r0, [pc, #76] ; 4480 <IMFS_dump_directory+0x168>
4430: eb003b9e bl 132b0 <puts>
}
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )
{
return node->control->imfs_type == IMFS_DIRECTORY;
4434: e594304c ldr r3, [r4, #76] ; 0x4c
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( IMFS_is_directory( the_jnode ) )
4438: e5933000 ldr r3, [r3]
443c: e3530000 cmp r3, #0
IMFS_dump_directory( the_jnode, level + 1 );
4440: 01a00004 moveq r0, r4
4444: 02871001 addeq r1, r7, #1
4448: 0bffffb2 bleq 4318 <IMFS_dump_directory>
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
444c: e5944000 ldr r4, [r4]
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
4450: e2863054 add r3, r6, #84 ; 0x54
IMFS_assert( level >= 0 );
IMFS_assert( IMFS_is_directory( the_directory ) );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
4454: e1540003 cmp r4, r3
4458: 1affffbb bne 434c <IMFS_dump_directory+0x34>
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( IMFS_is_directory( the_jnode ) )
IMFS_dump_directory( the_jnode, level + 1 );
}
}
445c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
0000352c <IMFS_make_generic_node>:
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
352c: e92d40f0 push {r4, r5, r6, r7, lr}
3530: e1a07003 mov r7, r3
int rv = 0;
mode &= ~rtems_filesystem_umask;
3534: e59f3100 ldr r3, [pc, #256] ; 363c <IMFS_make_generic_node+0x110>
3538: e5933000 ldr r3, [r3]
353c: e5936008 ldr r6, [r3, #8]
3540: e1c16006 bic r6, r1, r6
switch (mode & S_IFMT) {
3544: e2063a0f and r3, r6, #61440 ; 0xf000
3548: e3530a02 cmp r3, #8192 ; 0x2000
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
354c: e24dd05c sub sp, sp, #92 ; 0x5c
3550: e1a0c000 mov ip, r0
3554: e1a05002 mov r5, r2
int rv = 0;
mode &= ~rtems_filesystem_umask;
switch (mode & S_IFMT) {
3558: 0a000006 beq 3578 <IMFS_make_generic_node+0x4c>
355c: 8a000001 bhi 3568 <IMFS_make_generic_node+0x3c>
3560: e3530a01 cmp r3, #4096 ; 0x1000 <== NOT EXECUTED
3564: ea000002 b 3574 <IMFS_make_generic_node+0x48> <== NOT EXECUTED
3568: e3530a06 cmp r3, #24576 ; 0x6000
356c: 0a000001 beq 3578 <IMFS_make_generic_node+0x4c>
3570: e3530902 cmp r3, #32768 ; 0x8000
3574: 1a000029 bne 3620 <IMFS_make_generic_node+0xf4>
rv = -1;
break;
}
if ( rv == 0 ) {
if ( node_control->imfs_type == IMFS_GENERIC ) {
3578: e5953000 ldr r3, [r5]
357c: e3530007 cmp r3, #7
3580: 1a000026 bne 3620 <IMFS_make_generic_node+0xf4>
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK
| RTEMS_FS_MAKE
| RTEMS_FS_EXCLUSIVE;
const rtems_filesystem_location_info_t *currentloc =
3584: e1a0100c mov r1, ip
3588: e3a02078 mov r2, #120 ; 0x78
358c: e28d0008 add r0, sp, #8
3590: eb0007b3 bl 5464 <rtems_filesystem_eval_path_start>
3594: e1a04000 mov r4, r0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
3598: ebffffd1 bl 34e4 <IMFS_is_imfs_instance>
359c: e3500000 cmp r0, #0
35a0: 0a000017 beq 3604 <IMFS_make_generic_node+0xd8>
IMFS_types_union info;
IMFS_jnode_t *new_node;
info.generic.context = context;
35a4: e28d305c add r3, sp, #92 ; 0x5c
35a8: e523701c str r7, [r3, #-28]!
new_node = IMFS_create_node_with_control(
35ac: e58d6000 str r6, [sp]
35b0: e58d3004 str r3, [sp, #4]
35b4: e28d2010 add r2, sp, #16
35b8: e1a00004 mov r0, r4
35bc: e1a01005 mov r1, r5
35c0: e892000c ldm r2, {r2, r3}
35c4: eb002a63 bl df58 <IMFS_create_node_with_control>
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
mode,
&info
);
if ( new_node != NULL ) {
35c8: e3500000 cmp r0, #0
35cc: 0a00000f beq 3610 <IMFS_make_generic_node+0xe4>
IMFS_jnode_t *parent = currentloc->node_access;
IMFS_update_ctime( parent );
35d0: e3a01000 mov r1, #0
35d4: e28d0054 add r0, sp, #84 ; 0x54
mode,
&info
);
if ( new_node != NULL ) {
IMFS_jnode_t *parent = currentloc->node_access;
35d8: e5944008 ldr r4, [r4, #8]
IMFS_update_ctime( parent );
35dc: eb00024d bl 3f18 <gettimeofday>
35e0: e59d3054 ldr r3, [sp, #84] ; 0x54
IMFS_update_mtime( parent );
35e4: e28d0054 add r0, sp, #84 ; 0x54
);
if ( new_node != NULL ) {
IMFS_jnode_t *parent = currentloc->node_access;
IMFS_update_ctime( parent );
35e8: e5843048 str r3, [r4, #72] ; 0x48
IMFS_update_mtime( parent );
35ec: e3a01000 mov r1, #0
35f0: eb000248 bl 3f18 <gettimeofday>
35f4: e59d3054 ldr r3, [sp, #84] ; 0x54
35f8: e5843044 str r3, [r4, #68] ; 0x44
35fc: e3a04000 mov r4, #0
3600: ea000003 b 3614 <IMFS_make_generic_node+0xe8>
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
3604: e28d0008 add r0, sp, #8
3608: e3a01086 mov r1, #134 ; 0x86
360c: eb0006df bl 5190 <rtems_filesystem_eval_path_error>
IMFS_jnode_t *parent = currentloc->node_access;
IMFS_update_ctime( parent );
IMFS_update_mtime( parent );
} else {
rv = -1;
3610: e3e04000 mvn r4, #0
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
3614: e28d0008 add r0, sp, #8
3618: eb000799 bl 5484 <rtems_filesystem_eval_path_cleanup>
361c: ea000003 b 3630 <IMFS_make_generic_node+0x104>
} else {
errno = EINVAL;
3620: eb003987 bl 11c44 <__errno>
3624: e3a03016 mov r3, #22
3628: e5803000 str r3, [r0]
rv = -1;
362c: e3e04000 mvn r4, #0
}
}
return rv;
}
3630: e1a00004 mov r0, r4
3634: e28dd05c add sp, sp, #92 ; 0x5c
3638: e8bd80f0 pop {r4, r5, r6, r7, pc}
0000c038 <IMFS_memfile_get_block_pointer>:
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
c038: e59f31e4 ldr r3, [pc, #484] ; c224 <IMFS_memfile_get_block_pointer+0x1ec>
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
c03c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
c040: e5935000 ldr r5, [r3]
c044: e1a05125 lsr r5, r5, #2
c048: e2453001 sub r3, r5, #1
c04c: e1510003 cmp r1, r3
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
c050: e1a04000 mov r4, r0
c054: e1a06001 mov r6, r1
c058: e1a08002 mov r8, r2
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
c05c: 8a00000e bhi c09c <IMFS_memfile_get_block_pointer+0x64>
p = info->indirect;
if ( malloc_it ) {
c060: e3520000 cmp r2, #0
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
p = info->indirect;
c064: e5900058 ldr r0, [r0, #88] ; 0x58
if ( malloc_it ) {
c068: 0a000007 beq c08c <IMFS_memfile_get_block_pointer+0x54>
if ( !p ) {
c06c: e3500000 cmp r0, #0
c070: 1a000003 bne c084 <IMFS_memfile_get_block_pointer+0x4c>
p = memfile_alloc_block();
c074: ebffffe2 bl c004 <memfile_alloc_block>
if ( !p )
c078: e3500000 cmp r0, #0
c07c: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
info->indirect = p;
c080: e5840058 str r0, [r4, #88] ; 0x58
}
return &info->indirect[ my_block ];
c084: e5940058 ldr r0, [r4, #88] ; 0x58
c088: ea000001 b c094 <IMFS_memfile_get_block_pointer+0x5c>
}
if ( !p )
c08c: e3500000 cmp r0, #0
c090: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
return &info->indirect[ my_block ];
c094: e0800106 add r0, r0, r6, lsl #2
c098: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
c09c: e2853001 add r3, r5, #1
c0a0: e0030395 mul r3, r5, r3
c0a4: e2432001 sub r2, r3, #1
c0a8: e1510002 cmp r1, r2
c0ac: 8a000021 bhi c138 <IMFS_memfile_get_block_pointer+0x100>
my_block -= FIRST_DOUBLY_INDIRECT;
c0b0: e0656001 rsb r6, r5, r1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
c0b4: e1a00006 mov r0, r6
c0b8: e1a01005 mov r1, r5
c0bc: eb0029d3 bl 16810 <__umodsi3>
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c0c0: e1a01005 mov r1, r5
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
c0c4: e1a07000 mov r7, r0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c0c8: e1a00006 mov r0, r6
c0cc: eb002989 bl 166f8 <__aeabi_uidiv>
p = info->doubly_indirect;
if ( malloc_it ) {
c0d0: e3580000 cmp r8, #0
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c0d4: e1a05000 mov r5, r0
p = info->doubly_indirect;
c0d8: e594005c ldr r0, [r4, #92] ; 0x5c
if ( malloc_it ) {
c0dc: 0a00000e beq c11c <IMFS_memfile_get_block_pointer+0xe4>
if ( !p ) {
c0e0: e3500000 cmp r0, #0
c0e4: 1a000003 bne c0f8 <IMFS_memfile_get_block_pointer+0xc0>
p = memfile_alloc_block();
c0e8: ebffffc5 bl c004 <memfile_alloc_block>
if ( !p )
c0ec: e3500000 cmp r0, #0
c0f0: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
info->doubly_indirect = p;
c0f4: e584005c str r0, [r4, #92] ; 0x5c
}
p1 = (block_p *)p[ doubly ];
c0f8: e0804105 add r4, r0, r5, lsl #2
c0fc: e7900105 ldr r0, [r0, r5, lsl #2]
if ( !p1 ) {
c100: e3500000 cmp r0, #0
c104: 1a000009 bne c130 <IMFS_memfile_get_block_pointer+0xf8>
p1 = memfile_alloc_block();
c108: ebffffbd bl c004 <memfile_alloc_block>
if ( !p1 )
c10c: e3500000 cmp r0, #0
return 0;
p[ doubly ] = (block_p) p1;
c110: 15840000 strne r0, [r4]
}
p1 = (block_p *)p[ doubly ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
c114: 1a000005 bne c130 <IMFS_memfile_get_block_pointer+0xf8>
c118: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
}
return (block_p *)&p1[ singly ];
}
if ( !p )
c11c: e3500000 cmp r0, #0
c120: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
p = (block_p *)p[ doubly ];
c124: e7900105 ldr r0, [r0, r5, lsl #2]
if ( !p )
c128: e3500000 cmp r0, #0
c12c: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
return (block_p *)&p[ singly ];
c130: e0800107 add r0, r0, r7, lsl #2
c134: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
c138: e2832001 add r2, r3, #1
c13c: e0020295 mul r2, r5, r2
c140: e2422001 sub r2, r2, #1
c144: e1510002 cmp r1, r2
c148: 8a000033 bhi c21c <IMFS_memfile_get_block_pointer+0x1e4>
my_block -= FIRST_TRIPLY_INDIRECT;
c14c: e0636001 rsb r6, r3, r1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
c150: e1a00006 mov r0, r6
c154: e1a01005 mov r1, r5
c158: eb0029ac bl 16810 <__umodsi3>
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c15c: e1a01005 mov r1, r5
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
c160: e1a0a000 mov sl, r0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c164: e1a00006 mov r0, r6
c168: eb002962 bl 166f8 <__aeabi_uidiv>
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
c16c: e1a01005 mov r1, r5
*/
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;
c170: e1a06000 mov r6, r0
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
c174: eb00295f bl 166f8 <__aeabi_uidiv>
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
c178: e1a01005 mov r1, r5
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;
c17c: e1a07000 mov r7, r0
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
c180: e1a00006 mov r0, r6
c184: eb0029a1 bl 16810 <__umodsi3>
p = info->triply_indirect;
if ( malloc_it ) {
c188: e3580000 cmp r8, #0
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;
c18c: e1a05000 mov r5, r0
p = info->triply_indirect;
c190: e5940060 ldr r0, [r4, #96] ; 0x60
if ( malloc_it ) {
c194: 0a000016 beq c1f4 <IMFS_memfile_get_block_pointer+0x1bc>
if ( !p ) {
c198: e3500000 cmp r0, #0
c19c: 1a000003 bne c1b0 <IMFS_memfile_get_block_pointer+0x178>
p = memfile_alloc_block();
c1a0: ebffff97 bl c004 <memfile_alloc_block>
if ( !p )
c1a4: e3500000 cmp r0, #0
c1a8: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
info->triply_indirect = p;
c1ac: e5840060 str r0, [r4, #96] ; 0x60
}
p1 = (block_p *) p[ triply ];
c1b0: e0804107 add r4, r0, r7, lsl #2
c1b4: e7900107 ldr r0, [r0, r7, lsl #2]
if ( !p1 ) {
c1b8: e3500000 cmp r0, #0
c1bc: 1a000003 bne c1d0 <IMFS_memfile_get_block_pointer+0x198>
p1 = memfile_alloc_block();
c1c0: ebffff8f bl c004 <memfile_alloc_block>
if ( !p1 )
c1c4: e3500000 cmp r0, #0
c1c8: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
p[ triply ] = (block_p) p1;
c1cc: e5840000 str r0, [r4]
}
p2 = (block_p *)p1[ doubly ];
c1d0: e0804105 add r4, r0, r5, lsl #2
c1d4: e7900105 ldr r0, [r0, r5, lsl #2]
if ( !p2 ) {
c1d8: e3500000 cmp r0, #0
c1dc: 1a00000c bne c214 <IMFS_memfile_get_block_pointer+0x1dc>
p2 = memfile_alloc_block();
c1e0: ebffff87 bl c004 <memfile_alloc_block>
if ( !p2 )
c1e4: e3500000 cmp r0, #0
return 0;
p1[ doubly ] = (block_p) p2;
c1e8: 15840000 strne r0, [r4]
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
if ( !p2 )
c1ec: 1a000008 bne c214 <IMFS_memfile_get_block_pointer+0x1dc>
c1f0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
}
if ( !p )
c1f4: e3500000 cmp r0, #0
c1f8: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
p1 = (block_p *) p[ triply ];
c1fc: e7900107 ldr r0, [r0, r7, lsl #2]
if ( !p1 )
c200: e3500000 cmp r0, #0
c204: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
p2 = (block_p *)p1[ doubly ];
c208: e7900105 ldr r0, [r0, r5, lsl #2]
if ( !p2 )
c20c: e3500000 cmp r0, #0
c210: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return 0;
return (block_p *)&p2[ singly ];
c214: e080010a add r0, r0, sl, lsl #2
c218: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
}
/*
* This means the requested block number is out of range.
*/
return 0;
c21c: e3a00000 mov r0, #0 <== NOT EXECUTED
}
c220: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
00001d30 <IMFS_mount>:
#include "imfs.h"
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
1d30: e5903020 ldr r3, [r0, #32]
1d34: e5933008 ldr r3, [r3, #8]
return node->control->imfs_type;
}
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )
{
return node->control->imfs_type == IMFS_DIRECTORY;
1d38: e593204c ldr r2, [r3, #76] ; 0x4c
if ( IMFS_is_directory( node ) ) {
1d3c: e5922000 ldr r2, [r2]
1d40: e3520000 cmp r2, #0
#endif
#include "imfs.h"
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
1d44: e52de004 push {lr} ; (str lr, [sp, #-4]!)
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
if ( IMFS_is_directory( node ) ) {
1d48: 1a000009 bne 1d74 <IMFS_mount+0x44>
if ( node->info.directory.mt_fs == NULL ) {
1d4c: e593205c ldr r2, [r3, #92] ; 0x5c
1d50: e3520000 cmp r2, #0
node->info.directory.mt_fs = mt_entry;
1d54: 0583005c streq r0, [r3, #92] ; 0x5c
#include "imfs.h"
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
int rv = 0;
1d58: 01a00002 moveq r0, r2
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
if ( IMFS_is_directory( node ) ) {
if ( node->info.directory.mt_fs == NULL ) {
1d5c: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
node->info.directory.mt_fs = mt_entry;
} else {
errno = EBUSY;
1d60: eb002e73 bl d734 <__errno> <== NOT EXECUTED
1d64: e3a03010 mov r3, #16 <== NOT EXECUTED
1d68: e5803000 str r3, [r0] <== NOT EXECUTED
rv = -1;
1d6c: e3e00000 mvn r0, #0 <== NOT EXECUTED
1d70: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
}
} else {
errno = ENOTDIR;
1d74: eb002e6e bl d734 <__errno>
1d78: e3a03014 mov r3, #20
1d7c: e5803000 str r3, [r0]
rv = -1;
1d80: e3e00000 mvn r0, #0
}
return rv;
}
1d84: e49df004 pop {pc} ; (ldr pc, [sp], #4)
00009fec <IMFS_node_remove_directory>:
static IMFS_jnode_t *IMFS_node_remove_directory(
IMFS_jnode_t *node
)
{
if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {
9fec: e5902050 ldr r2, [r0, #80] ; 0x50
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
9ff0: e2803054 add r3, r0, #84 ; 0x54
9ff4: e1520003 cmp r2, r3
}
static IMFS_jnode_t *IMFS_node_remove_directory(
IMFS_jnode_t *node
)
{
9ff8: e52de004 push {lr} ; (str lr, [sp, #-4]!)
if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {
9ffc: 0a000004 beq a014 <IMFS_node_remove_directory+0x28>
errno = ENOTEMPTY;
a000: eb000dcb bl d734 <__errno>
a004: e3a0305a mov r3, #90 ; 0x5a
a008: e5803000 str r3, [r0]
node = NULL;
a00c: e3a00000 mov r0, #0
a010: e49df004 pop {pc} ; (ldr pc, [sp], #4)
} else if ( IMFS_is_mount_point( node ) ) {
a014: e590305c ldr r3, [r0, #92] ; 0x5c
a018: e3530000 cmp r3, #0
a01c: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
errno = EBUSY;
a020: eb000dc3 bl d734 <__errno> <== NOT EXECUTED
a024: e3a03010 mov r3, #16 <== NOT EXECUTED
a028: e5803000 str r3, [r0] <== NOT EXECUTED
a02c: e3a00000 mov r0, #0 <== NOT EXECUTED
node = NULL;
}
return node;
}
a030: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00001de8 <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
1de8: e92d40f3 push {r0, r1, r4, r5, r6, r7, lr}
int rv = 0; IMFS_jnode_t *node = oldloc->node_access;
1dec: e5914008 ldr r4, [r1, #8]
IMFS_jnode_t *new_parent = newparentloc->node_access;
1df0: e5925008 ldr r5, [r2, #8]
/*
* FIXME: Due to insufficient checks we can create inaccessible nodes with
* this operation.
*/
if ( node->Parent != NULL ) {
1df4: e5942008 ldr r2, [r4, #8]
1df8: e3520000 cmp r2, #0
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
1dfc: e59d601c ldr r6, [sp, #28]
/*
* FIXME: Due to insufficient checks we can create inaccessible nodes with
* this operation.
*/
if ( node->Parent != NULL ) {
1e00: 0a00001c beq 1e78 <IMFS_rename+0x90>
if ( namelen < IMFS_NAME_MAX ) {
1e04: e356001f cmp r6, #31
1e08: 8a000017 bhi 1e6c <IMFS_rename+0x84>
memcpy( node->name, name, namelen );
1e0c: e1a01003 mov r1, r3
1e10: e1a02006 mov r2, r6
node->name [namelen] = '\0';
1e14: e3a07000 mov r7, #0
* this operation.
*/
if ( node->Parent != NULL ) {
if ( namelen < IMFS_NAME_MAX ) {
memcpy( node->name, name, namelen );
1e18: e284000c add r0, r4, #12
node->name [namelen] = '\0';
1e1c: e0846006 add r6, r4, r6
* this operation.
*/
if ( node->Parent != NULL ) {
if ( namelen < IMFS_NAME_MAX ) {
memcpy( node->name, name, namelen );
1e20: eb00307d bl e01c <memcpy>
node->name [namelen] = '\0';
1e24: e5c6700c strb r7, [r6, #12]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
1e28: e894000c ldm r4, {r2, r3}
next->previous = previous;
1e2c: e5823004 str r3, [r2, #4]
previous->next = next;
1e30: e5832000 str r2, [r3]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
1e34: e5953058 ldr r3, [r5, #88] ; 0x58
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
1e38: e2852054 add r2, r5, #84 ; 0x54
static inline void IMFS_add_to_directory(
IMFS_jnode_t *dir,
IMFS_jnode_t *node
)
{
node->Parent = dir;
1e3c: e5845008 str r5, [r4, #8]
Chain_Node *old_last = tail->previous;
the_node->next = tail;
1e40: e5842000 str r2, [r4]
tail->previous = the_node;
1e44: e5854058 str r4, [r5, #88] ; 0x58
old_last->next = the_node;
1e48: e5834000 str r4, [r3]
the_node->previous = old_last;
1e4c: e5843004 str r3, [r4, #4]
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
1e50: e1a0000d mov r0, sp
1e54: e1a01007 mov r1, r7
1e58: eb00015b bl 23cc <gettimeofday>
1e5c: e59d3000 ldr r3, [sp]
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
int rv = 0;
1e60: e1a00007 mov r0, r7
memcpy( node->name, name, namelen );
node->name [namelen] = '\0';
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
1e64: e5843048 str r3, [r4, #72] ; 0x48
1e68: ea000006 b 1e88 <IMFS_rename+0xa0>
} else {
errno = ENAMETOOLONG;
1e6c: eb002e30 bl d734 <__errno> <== NOT EXECUTED
1e70: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED
1e74: ea000001 b 1e80 <IMFS_rename+0x98> <== NOT EXECUTED
rv = -1;
}
} else {
errno = EINVAL;
1e78: eb002e2d bl d734 <__errno> <== NOT EXECUTED
1e7c: e3a03016 mov r3, #22 <== NOT EXECUTED
1e80: e5803000 str r3, [r0] <== NOT EXECUTED
rv = -1;
1e84: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return rv;
}
1e88: e8bd80fc pop {r2, r3, r4, r5, r6, r7, pc}
00001f6c <IMFS_unmount>:
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
1f6c: e5903020 ldr r3, [r0, #32]
1f70: e5932008 ldr r2, [r3, #8]
return node->control->imfs_type;
}
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )
{
return node->control->imfs_type == IMFS_DIRECTORY;
1f74: e592304c ldr r3, [r2, #76] ; 0x4c
if ( IMFS_is_directory( node ) ) {
1f78: e5933000 ldr r3, [r3]
1f7c: e3530000 cmp r3, #0
#endif
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
1f80: e52de004 push {lr} ; (str lr, [sp, #-4]!)
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
if ( IMFS_is_directory( node ) ) {
1f84: 1a000009 bne 1fb0 <IMFS_unmount+0x44>
if ( node->info.directory.mt_fs == mt_entry ) {
1f88: e592105c ldr r1, [r2, #92] ; 0x5c
1f8c: e1510000 cmp r1, r0
node->info.directory.mt_fs = NULL;
1f90: 0582305c streq r3, [r2, #92] ; 0x5c
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
int rv = 0;
1f94: 01a00003 moveq r0, r3
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
if ( IMFS_is_directory( node ) ) {
if ( node->info.directory.mt_fs == mt_entry ) {
1f98: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
node->info.directory.mt_fs = NULL;
} else {
errno = EINVAL;
1f9c: eb002de4 bl d734 <__errno> <== NOT EXECUTED
1fa0: e3a03016 mov r3, #22 <== NOT EXECUTED
1fa4: e5803000 str r3, [r0] <== NOT EXECUTED
rv = -1;
1fa8: e3e00000 mvn r0, #0 <== NOT EXECUTED
1fac: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
}
} else {
errno = ENOTDIR;
1fb0: eb002ddf bl d734 <__errno> <== NOT EXECUTED
1fb4: e3a03014 mov r3, #20 <== NOT EXECUTED
1fb8: e5803000 str r3, [r0] <== NOT EXECUTED
rv = -1;
1fbc: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return rv;
}
1fc0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
0001eecc <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
static void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
1eecc: e92d4fff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, lr}
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
1eed0: e59060b4 ldr r6, [r0, #180] ; 0xb4
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
1eed4: e59030b8 ldr r3, [r0, #184] ; 0xb8
size = Stack_check_usable_stack_size(stack);
1eed8: e2466010 sub r6, r6, #16
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
1eedc: e2838020 add r8, r3, #32
for (ebase = base + length; base < ebase; base++)
1eee0: e3c61003 bic r1, r6, #3
static rtems_printk_plugin_t print_handler;
static void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
1eee4: e1a05000 mov r5, r0
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
1eee8: e590b0e4 ldr fp, [r0, #228] ; 0xe4
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
1eeec: e0881001 add r1, r8, r1
if (*base != U32_PATTERN)
1eef0: e59f20bc ldr r2, [pc, #188] ; 1efb4 <Stack_check_Dump_threads_usage+0xe8> 1eef4: ea000003 b 1ef08 <Stack_check_Dump_threads_usage+0x3c> 1eef8: e5980000 ldr r0, [r8] 1eefc: e1500002 cmp r0, r2
1ef00: 1a000004 bne 1ef18 <Stack_check_Dump_threads_usage+0x4c>
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
1ef04: e2888004 add r8, r8, #4 1ef08: e1580001 cmp r8, r1
1ef0c: 3afffff9 bcc 1eef8 <Stack_check_Dump_threads_usage+0x2c>
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
used = Stack_check_Calculate_used( low, size, high_water_mark );
else
used = 0;
1ef10: e3a08000 mov r8, #0 <== NOT EXECUTED 1ef14: ea000003 b 1ef28 <Stack_check_Dump_threads_usage+0x5c> <== NOT EXECUTED
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
1ef18: e3580000 cmp r8, #0
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
1ef1c: 12833010 addne r3, r3, #16
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
used = Stack_check_Calculate_used( low, size, high_water_mark );
1ef20: 10833006 addne r3, r3, r6 1ef24: 10688003 rsbne r8, r8, r3
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
#endif
{
(*print_handler)(
1ef28: e595a008 ldr sl, [r5, #8]
1ef2c: e59f4084 ldr r4, [pc, #132] ; 1efb8 <Stack_check_Dump_threads_usage+0xec>
1ef30: e3a01005 mov r1, #5
1ef34: e28d2008 add r2, sp, #8
1ef38: e1a0000a mov r0, sl
1ef3c: e8940280 ldm r4, {r7, r9}
1ef40: ebffbb2f bl dc04 <rtems_object_get_name>
1ef44: e59f1070 ldr r1, [pc, #112] ; 1efbc <Stack_check_Dump_threads_usage+0xf0>
1ef48: e1a03000 mov r3, r0
1ef4c: e1a0200a mov r2, sl
1ef50: e1a00009 mov r0, r9
1ef54: e1a0e00f mov lr, pc
1ef58: e12fff17 bx r7
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
1ef5c: e59530b4 ldr r3, [r5, #180] ; 0xb4 1ef60: e59520b8 ldr r2, [r5, #184] ; 0xb8 1ef64: e2433001 sub r3, r3, #1
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
1ef68: e0823003 add r3, r2, r3 1ef6c: e58db000 str fp, [sp] 1ef70: e58d6004 str r6, [sp, #4] 1ef74: e5940004 ldr r0, [r4, #4] 1ef78: e59f1040 ldr r1, [pc, #64] ; 1efc0 <Stack_check_Dump_threads_usage+0xf4> 1ef7c: e1a0e00f mov lr, pc 1ef80: e594f000 ldr pc, [r4]
current,
size
);
if (Stack_check_Initialized == 0) {
(*print_handler)( print_context, "Unavailable\n" );
1ef84: e9940009 ldmib r4, {r0, r3}
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
1ef88: e3530000 cmp r3, #0
1ef8c: 1a000003 bne 1efa0 <Stack_check_Dump_threads_usage+0xd4>
(*print_handler)( print_context, "Unavailable\n" );
1ef90: e59f102c ldr r1, [pc, #44] ; 1efc4 <Stack_check_Dump_threads_usage+0xf8><== NOT EXECUTED 1ef94: e1a0e00f mov lr, pc <== NOT EXECUTED 1ef98: e594f000 ldr pc, [r4] <== NOT EXECUTED 1ef9c: ea000003 b 1efb0 <Stack_check_Dump_threads_usage+0xe4> <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
1efa0: e59f1020 ldr r1, [pc, #32] ; 1efc8 <Stack_check_Dump_threads_usage+0xfc> 1efa4: e1a02008 mov r2, r8 1efa8: e1a0e00f mov lr, pc 1efac: e594f000 ldr pc, [r4]
}
}
1efb0: e8bd8fff pop {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
000072fc <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
72fc: e92d4007 push {r0, r1, r2, lr}
7300: e20160ff and r6, r1, #255 ; 0xff
7304: e1a04000 mov r4, r0
Internal_errors_Source source,
bool is_internal,
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, is_internal, error };
7308: e58d0000 str r0, [sp]
_User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );
730c: e59f1040 ldr r1, [pc, #64] ; 7354 <_Internal_error_Occurred+0x58>
7310: e1a0000d mov r0, sp
7314: e1a05002 mov r5, r2
Internal_errors_Source source,
bool is_internal,
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, is_internal, error };
7318: e58d2008 str r2, [sp, #8]
731c: e5cd6004 strb r6, [sp, #4]
_User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );
7320: eb00076e bl 90e0 <_User_extensions_Iterate>
_User_extensions_Fatal( the_source, is_internal, the_error );
_Internal_errors_What_happened.the_source = the_source;
7324: e59f302c ldr r3, [pc, #44] ; 7358 <_Internal_error_Occurred+0x5c><== NOT EXECUTED
7328: e5834000 str r4, [r3] <== NOT EXECUTED
_Internal_errors_What_happened.is_internal = is_internal;
732c: e5c36004 strb r6, [r3, #4] <== NOT EXECUTED
_Internal_errors_What_happened.the_error = the_error;
7330: e5835008 str r5, [r3, #8] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
7334: e59f3020 ldr r3, [pc, #32] ; 735c <_Internal_error_Occurred+0x60><== NOT EXECUTED
7338: e3a02005 mov r2, #5 <== NOT EXECUTED
733c: e5832000 str r2, [r3] <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
7340: e10f2000 mrs r2, CPSR <== NOT EXECUTED
7344: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED
7348: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
734c: e1a00005 mov r0, r5 <== NOT EXECUTED
7350: eafffffe b 7350 <_Internal_error_Occurred+0x54> <== NOT EXECUTED
0000d018 <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
d018: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
d01c: e5906008 ldr r6, [r0, #8]
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
d020: e59f5080 ldr r5, [pc, #128] ; d0a8 <_POSIX_Keys_Run_destructors+0x90>
d024: e1a07c26 lsr r7, r6, #24
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
d028: e1a06806 lsl r6, r6, #16
d02c: e2077007 and r7, r7, #7
d030: e1a06726 lsr r6, r6, #14
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
d034: e3a04001 mov r4, #1
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
d038: e1d5a1b0 ldrh sl, [r5, #16]
done = true;
d03c: e1a02004 mov r2, r4
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
if ( value != NULL ) {
key->Values [ thread_api ][ thread_index ] = NULL;
d040: e3a08000 mov r8, #0
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
d044: ea000012 b d094 <_POSIX_Keys_Run_destructors+0x7c>
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
d048: e595301c ldr r3, [r5, #28]
d04c: e7933104 ldr r3, [r3, r4, lsl #2]
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
d050: e3530000 cmp r3, #0
d054: 0a00000b beq d088 <_POSIX_Keys_Run_destructors+0x70>
d058: e5931010 ldr r1, [r3, #16]
d05c: e3510000 cmp r1, #0
d060: 0a000008 beq d088 <_POSIX_Keys_Run_destructors+0x70>
void *value = key->Values [ thread_api ][ thread_index ];
d064: e2871005 add r1, r7, #5
d068: e7931101 ldr r1, [r3, r1, lsl #2]
d06c: e7910006 ldr r0, [r1, r6]
if ( value != NULL ) {
d070: e3500000 cmp r0, #0
d074: 0a000003 beq d088 <_POSIX_Keys_Run_destructors+0x70>
key->Values [ thread_api ][ thread_index ] = NULL;
d078: e7818006 str r8, [r1, r6] <== NOT EXECUTED
(*key->destructor)( value );
d07c: e1a0e00f mov lr, pc <== NOT EXECUTED
d080: e593f010 ldr pc, [r3, #16] <== NOT EXECUTED
done = false;
d084: e3a02000 mov r2, #0 <== NOT EXECUTED
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
d088: e2844001 add r4, r4, #1
d08c: e1a04804 lsl r4, r4, #16
d090: e1a04824 lsr r4, r4, #16
d094: e154000a cmp r4, sl
d098: 9affffea bls d048 <_POSIX_Keys_Run_destructors+0x30>
* number of iterations. An infinite loop may happen if destructors set
* thread specific data. This can be considered dubious.
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
while ( !done ) {
d09c: e3520000 cmp r2, #0
d0a0: 0affffe3 beq d034 <_POSIX_Keys_Run_destructors+0x1c>
done = false;
}
}
}
}
}
d0a4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
0000ce60 <_POSIX_Semaphore_Create_support>:
POSIX_Semaphore_Control *the_semaphore;
CORE_semaphore_Attributes *the_sem_attr;
char *name;
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0)
ce60: e3520000 cmp r2, #0
size_t name_len,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
ce64: e92d40f0 push {r4, r5, r6, r7, lr}
ce68: e1a04000 mov r4, r0
ce6c: e1a06001 mov r6, r1
ce70: e1a07003 mov r7, r3
POSIX_Semaphore_Control *the_semaphore;
CORE_semaphore_Attributes *the_sem_attr;
char *name;
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0)
ce74: 0a000002 beq ce84 <_POSIX_Semaphore_Create_support+0x24>
rtems_set_errno_and_return_minus_one( ENOSYS );
ce78: eb00099c bl f4f0 <__errno>
ce7c: e3a03058 mov r3, #88 ; 0x58
ce80: ea000018 b cee8 <_POSIX_Semaphore_Create_support+0x88>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
ce84: e59f30d8 ldr r3, [pc, #216] ; cf64 <_POSIX_Semaphore_Create_support+0x104>
ce88: e5932000 ldr r2, [r3]
++level;
ce8c: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
ce90: e5832000 str r2, [r3]
* _POSIX_Semaphore_Allocate
*/
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{
return (POSIX_Semaphore_Control *)
ce94: e59f00cc ldr r0, [pc, #204] ; cf68 <_POSIX_Semaphore_Create_support+0x108>
ce98: ebffeffe bl 8e98 <_Objects_Allocate>
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
ce9c: e2505000 subs r5, r0, #0
cea0: 1a000003 bne ceb4 <_POSIX_Semaphore_Create_support+0x54>
_Thread_Enable_dispatch();
cea4: ebfff4c1 bl a1b0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSPC );
cea8: eb000990 bl f4f0 <__errno>
ceac: e3a0301c mov r3, #28
ceb0: ea00000c b cee8 <_POSIX_Semaphore_Create_support+0x88>
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
if ( name_arg != NULL ) {
ceb4: e3540000 cmp r4, #0
ceb8: 0a00000d beq cef4 <_POSIX_Semaphore_Create_support+0x94>
name = _Workspace_String_duplicate( name_arg, name_len );
cebc: e1a00004 mov r0, r4
cec0: e1a01006 mov r1, r6
cec4: eb000431 bl df90 <_Workspace_String_duplicate>
if ( !name ) {
cec8: e2504000 subs r4, r0, #0
cecc: 1a000008 bne cef4 <_POSIX_Semaphore_Create_support+0x94>
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free (
POSIX_Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_POSIX_Semaphore_Information, &the_semaphore->Object );
ced0: e59f0090 ldr r0, [pc, #144] ; cf68 <_POSIX_Semaphore_Create_support+0x108><== NOT EXECUTED
ced4: e1a01005 mov r1, r5 <== NOT EXECUTED
ced8: ebfff0bd bl 91d4 <_Objects_Free> <== NOT EXECUTED
_POSIX_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
cedc: ebfff4b3 bl a1b0 <_Thread_Enable_dispatch> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
cee0: eb000982 bl f4f0 <__errno> <== NOT EXECUTED
cee4: e3a0300c mov r3, #12 <== NOT EXECUTED
cee8: e5803000 str r3, [r0]
ceec: e3e00000 mvn r0, #0
cef0: e8bd80f0 pop {r4, r5, r6, r7, pc}
}
} else {
name = NULL;
}
the_semaphore->process_shared = pshared;
cef4: e3a03000 mov r3, #0
if ( name ) {
cef8: e1540003 cmp r4, r3
}
} else {
name = NULL;
}
the_semaphore->process_shared = pshared;
cefc: e5853010 str r3, [r5, #16]
if ( name ) {
the_semaphore->named = true;
cf00: 13a03001 movne r3, #1
cf04: 15c53014 strbne r3, [r5, #20]
the_semaphore->open_count = 1;
cf08: 15853018 strne r3, [r5, #24]
the_semaphore->linked = true;
cf0c: 15c53015 strbne r3, [r5, #21]
* blocking tasks on this semaphore should be. It could somehow * be derived from the current scheduling policy. One * thing is certain, no matter what we decide, it won't be * the same as all other POSIX implementations. :) */ the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
cf10: e3a06000 mov r6, #0
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
cf14: e3e03000 mvn r3, #0
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
cf18: e285001c add r0, r5, #28
if ( name ) {
the_semaphore->named = true;
the_semaphore->open_count = 1;
the_semaphore->linked = true;
} else {
the_semaphore->named = false;
cf1c: 05c54014 strbeq r4, [r5, #20]
the_semaphore->open_count = 0;
cf20: 05854018 streq r4, [r5, #24]
the_semaphore->linked = false;
cf24: 05c54015 strbeq r4, [r5, #21]
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
cf28: e585305c str r3, [r5, #92] ; 0x5c
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
cf2c: e285105c add r1, r5, #92 ; 0x5c
cf30: e1a02007 mov r2, r7
* blocking tasks on this semaphore should be. It could somehow * be derived from the current scheduling policy. One * thing is certain, no matter what we decide, it won't be * the same as all other POSIX implementations. :) */ the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
cf34: e5856060 str r6, [r5, #96] ; 0x60
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
cf38: ebffee57 bl 889c <_CORE_semaphore_Initialize>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
cf3c: e59f3024 ldr r3, [pc, #36] ; cf68 <_POSIX_Semaphore_Create_support+0x108>
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
cf40: e1d520b8 ldrh r2, [r5, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
cf44: e593301c ldr r3, [r3, #28]
cf48: e7835102 str r5, [r3, r2, lsl #2]
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name
);
*the_sem = the_semaphore;
cf4c: e59d3014 ldr r3, [sp, #20]
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
cf50: e585400c str r4, [r5, #12]
cf54: e5835000 str r5, [r3]
_Thread_Enable_dispatch();
cf58: ebfff494 bl a1b0 <_Thread_Enable_dispatch>
return 0;
cf5c: e1a00006 mov r0, r6
}
cf60: e8bd80f0 pop {r4, r5, r6, r7, pc}
0000ae28 <_POSIX_Threads_Delete_extension>:
*/
static void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
ae28: e92d40f0 push {r4, r5, r6, r7, lr}
api = deleted->API_Extensions[ THREAD_API_POSIX ];
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
ae2c: e1a00001 mov r0, r1
*/
static void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
ae30: e1a04001 mov r4, r1
Thread_Control *the_thread;
POSIX_API_Control *api;
void **value_ptr;
api = deleted->API_Extensions[ THREAD_API_POSIX ];
ae34: e59150f4 ldr r5, [r1, #244] ; 0xf4
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
ae38: eb00085f bl cfbc <_POSIX_Threads_cancel_run>
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
ae3c: e1a00004 mov r0, r4
ae40: eb000874 bl d018 <_POSIX_Keys_Run_destructors>
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
ae44: e2856044 add r6, r5, #68 ; 0x44
_POSIX_Keys_Run_destructors( deleted );
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
ae48: e5947028 ldr r7, [r4, #40] ; 0x28
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
ae4c: ea000001 b ae58 <_POSIX_Threads_Delete_extension+0x30>
*(void **)the_thread->Wait.return_argument = value_ptr;
ae50: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
ae54: e5837000 str r7, [r3] <== NOT EXECUTED
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
ae58: e1a00006 mov r0, r6
ae5c: ebfff6c9 bl 8988 <_Thread_queue_Dequeue>
ae60: e3500000 cmp r0, #0
ae64: 1afffff9 bne ae50 <_POSIX_Threads_Delete_extension+0x28>
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
ae68: e5953084 ldr r3, [r5, #132] ; 0x84
ae6c: e3530004 cmp r3, #4
(void) _Watchdog_Remove( &api->Sporadic_timer );
ae70: 028500a8 addeq r0, r5, #168 ; 0xa8
ae74: 0bfff932 bleq 9344 <_Watchdog_Remove>
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
ae78: e3a03000 mov r3, #0
_Workspace_Free( api );
ae7c: e1a00005 mov r0, r5
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
ae80: e58430f4 str r3, [r4, #244] ; 0xf4
_Workspace_Free( api );
}
ae84: e8bd40f0 pop {r4, r5, r6, r7, lr}
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
_Workspace_Free( api );
ae88: eafff9bd b 9584 <_Workspace_Free>
000086f0 <_RBTree_Sibling>:
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
86f0: e2502000 subs r2, r0, #0
86f4: 01a00002 moveq r0, r2
86f8: 012fff1e bxeq lr
if(!(the_node->parent)) return NULL;
86fc: e5923000 ldr r3, [r2]
8700: e3530000 cmp r3, #0
8704: 0a000006 beq 8724 <_RBTree_Sibling+0x34>
if(!(the_node->parent->parent)) return NULL;
8708: e5930000 ldr r0, [r3]
870c: e3500000 cmp r0, #0
8710: 012fff1e bxeq lr
if(the_node == the_node->parent->child[RBT_LEFT])
8714: e5930004 ldr r0, [r3, #4]
8718: e1520000 cmp r2, r0
return the_node->parent->child[RBT_RIGHT];
871c: 05930008 ldreq r0, [r3, #8]
8720: e12fff1e bx lr
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
8724: e1a00003 mov r0, r3 <== NOT EXECUTED
if(the_node == the_node->parent->child[RBT_LEFT])
return the_node->parent->child[RBT_RIGHT];
else
return the_node->parent->child[RBT_LEFT];
}
8728: e12fff1e bx lr <== NOT EXECUTED
00009484 <_Scheduler_CBS_Create_server>:
)
{
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
9484: e5903004 ldr r3, [r0, #4]
9488: e3530000 cmp r3, #0
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
948c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
9490: e1a04000 mov r4, r0
9494: e1a05001 mov r5, r1
9498: e1a0a002 mov sl, r2
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
949c: da000023 ble 9530 <_Scheduler_CBS_Create_server+0xac>
94a0: e5903000 ldr r3, [r0]
94a4: e3530000 cmp r3, #0
94a8: da000020 ble 9530 <_Scheduler_CBS_Create_server+0xac>
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
94ac: e59f308c ldr r3, [pc, #140] ; 9540 <_Scheduler_CBS_Create_server+0xbc>
94b0: e5932000 ldr r2, [r3]
94b4: e59f3088 ldr r3, [pc, #136] ; 9544 <_Scheduler_CBS_Create_server+0xc0>
if ( !_Scheduler_CBS_Server_list[i] )
94b8: e3a06000 mov r6, #0
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
94bc: e5933000 ldr r3, [r3]
94c0: ea00000f b 9504 <_Scheduler_CBS_Create_server+0x80>
if ( !_Scheduler_CBS_Server_list[i] )
94c4: e4937004 ldr r7, [r3], #4
94c8: e3570000 cmp r7, #0
94cc: 1a00000b bne 9500 <_Scheduler_CBS_Create_server+0x7c>
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
94d0: e59f806c ldr r8, [pc, #108] ; 9544 <_Scheduler_CBS_Create_server+0xc0>
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
94d4: e58a6000 str r6, [sl]
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
94d8: e3a00010 mov r0, #16
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
94dc: e5989000 ldr r9, [r8]
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
94e0: eb00072f bl b1a4 <_Workspace_Allocate>
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
94e4: e7890106 str r0, [r9, r6, lsl #2]
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
94e8: e59a2000 ldr r2, [sl]
94ec: e5983000 ldr r3, [r8]
94f0: e7933102 ldr r3, [r3, r2, lsl #2]
if ( !the_server )
94f4: e3530000 cmp r3, #0
94f8: 1a000005 bne 9514 <_Scheduler_CBS_Create_server+0x90>
94fc: ea00000d b 9538 <_Scheduler_CBS_Create_server+0xb4> <== NOT EXECUTED
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
9500: e2866001 add r6, r6, #1
9504: e1560002 cmp r6, r2
9508: 1affffed bne 94c4 <_Scheduler_CBS_Create_server+0x40>
if ( !_Scheduler_CBS_Server_list[i] )
break;
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
950c: e3e00019 mvn r0, #25
9510: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
9514: e8940003 ldm r4, {r0, r1}
the_server->task_id = -1;
9518: e3e02000 mvn r2, #0
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
951c: e9830003 stmib r3, {r0, r1}
the_server->task_id = -1;
9520: e5832000 str r2, [r3]
the_server->cbs_budget_overrun = budget_overrun_callback;
9524: e583500c str r5, [r3, #12]
return SCHEDULER_CBS_OK;
9528: e1a00007 mov r0, r7
952c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
if ( params->budget <= 0 ||
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
9530: e3e00011 mvn r0, #17
9534: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
9538: e3e00010 mvn r0, #16 <== NOT EXECUTED
the_server->parameters = *params;
the_server->task_id = -1;
the_server->cbs_budget_overrun = budget_overrun_callback;
return SCHEDULER_CBS_OK;
}
953c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
000098b0 <_Scheduler_CBS_Initialize>:
int _Scheduler_CBS_Initialize(void)
{
98b0: e92d4010 push {r4, lr}
unsigned int i; _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
98b4: e59f4050 ldr r4, [pc, #80] ; 990c <_Scheduler_CBS_Initialize+0x5c>
98b8: e5940000 ldr r0, [r4]
98bc: e1a00100 lsl r0, r0, #2
98c0: eb000637 bl b1a4 <_Workspace_Allocate>
98c4: e59f3044 ldr r3, [pc, #68] ; 9910 <_Scheduler_CBS_Initialize+0x60>
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
98c8: e3500000 cmp r0, #0
}
int _Scheduler_CBS_Initialize(void)
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
98cc: e5830000 str r0, [r3]
98d0: e1a00003 mov r0, r3
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
98d4: 13a03000 movne r3, #0
98d8: 15941000 ldrne r1, [r4]
98dc: 11a02003 movne r2, r3
int _Scheduler_CBS_Initialize(void)
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
98e0: 1a000003 bne 98f4 <_Scheduler_CBS_Initialize+0x44>
98e4: ea000006 b 9904 <_Scheduler_CBS_Initialize+0x54> <== NOT EXECUTED
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
_Scheduler_CBS_Server_list[i] = NULL;
98e8: e590c000 ldr ip, [r0]
98ec: e78c2103 str r2, [ip, r3, lsl #2]
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
98f0: e2833001 add r3, r3, #1
98f4: e1530001 cmp r3, r1
98f8: 1afffffa bne 98e8 <_Scheduler_CBS_Initialize+0x38>
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
98fc: e3a00000 mov r0, #0
9900: e8bd8010 pop {r4, pc}
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
9904: e3e00010 mvn r0, #16 <== NOT EXECUTED
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
}
9908: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00008b88 <_Thread_queue_Enqueue_priority>:
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
8b88: e281c03c add ip, r1, #60 ; 0x3c
head->next = tail;
8b8c: e581c038 str ip, [r1, #56] ; 0x38
head->previous = NULL;
8b90: e3a0c000 mov ip, #0
8b94: e581c03c str ip, [r1, #60] ; 0x3c
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
8b98: e591c014 ldr ip, [r1, #20]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
8b9c: e2813038 add r3, r1, #56 ; 0x38
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
8ba0: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
head->next = tail;
head->previous = NULL;
tail->previous = head;
8ba4: e5813040 str r3, [r1, #64] ; 0x40
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
8ba8: e3a0500c mov r5, #12
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
8bac: e1a0332c lsr r3, ip, #6
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
8bb0: e31c0020 tst ip, #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 ];
8bb4: e0250593 mla r5, r3, r5, r0
block_state = the_thread_queue->state;
8bb8: e5908038 ldr r8, [r0, #56] ; 0x38
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
8bbc: 159fa150 ldrne sl, [pc, #336] ; 8d14 <_Thread_queue_Enqueue_priority+0x18c>
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 ) )
8bc0: 1a000022 bne 8c50 <_Thread_queue_Enqueue_priority+0xc8>
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
8bc4: e285a004 add sl, r5, #4
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
8bc8: e10f4000 mrs r4, CPSR
8bcc: e3843080 orr r3, r4, #128 ; 0x80
8bd0: e129f003 msr CPSR_fc, r3
8bd4: e1a06004 mov r6, r4
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
8bd8: e3e07000 mvn r7, #0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
8bdc: e5953000 ldr r3, [r5]
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
8be0: ea00000b b 8c14 <_Thread_queue_Enqueue_priority+0x8c>
search_priority = search_thread->current_priority;
8be4: e5937014 ldr r7, [r3, #20]
if ( priority <= search_priority )
8be8: e15c0007 cmp ip, r7
8bec: 9a00000a bls 8c1c <_Thread_queue_Enqueue_priority+0x94>
static inline void arm_interrupt_flash( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
8bf0: e10f9000 mrs r9, CPSR
8bf4: e129f004 msr CPSR_fc, r4
8bf8: e129f009 msr CPSR_fc, r9
RTEMS_INLINE_ROUTINE bool _States_Are_set (
States_Control the_states,
States_Control mask
)
{
return ( (the_states & mask) != STATES_READY);
8bfc: e5939010 ldr r9, [r3, #16]
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) ) {
8c00: e1180009 tst r8, r9
8c04: 1a000001 bne 8c10 <_Thread_queue_Enqueue_priority+0x88>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
8c08: e129f004 msr CPSR_fc, r4
8c0c: eaffffed b 8bc8 <_Thread_queue_Enqueue_priority+0x40>
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
8c10: e5933000 ldr r3, [r3]
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
8c14: e153000a cmp r3, sl
8c18: 1afffff1 bne 8be4 <_Thread_queue_Enqueue_priority+0x5c>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
8c1c: e5905030 ldr r5, [r0, #48] ; 0x30
8c20: e3550001 cmp r5, #1
8c24: 1a000037 bne 8d08 <_Thread_queue_Enqueue_priority+0x180>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
8c28: e3a02000 mov r2, #0
if ( priority == search_priority )
8c2c: e15c0007 cmp ip, r7
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
8c30: e5802030 str r2, [r0, #48] ; 0x30
if ( priority == search_priority )
8c34: 0a000029 beq 8ce0 <_Thread_queue_Enqueue_priority+0x158>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
8c38: e5932004 ldr r2, [r3, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
8c3c: e5813000 str r3, [r1]
the_node->previous = previous_node;
8c40: e5812004 str r2, [r1, #4]
previous_node->next = the_node;
8c44: e5821000 str r1, [r2]
search_node->previous = the_node;
8c48: e5831004 str r1, [r3, #4]
8c4c: ea000020 b 8cd4 <_Thread_queue_Enqueue_priority+0x14c>
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
8c50: e5da7000 ldrb r7, [sl]
8c54: e2877001 add r7, r7, #1
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
8c58: e10f4000 mrs r4, CPSR
8c5c: e3843080 orr r3, r4, #128 ; 0x80
8c60: e129f003 msr CPSR_fc, r3
8c64: e1a06004 mov r6, r4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
8c68: e5953008 ldr r3, [r5, #8]
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
8c6c: ea00000b b 8ca0 <_Thread_queue_Enqueue_priority+0x118>
search_priority = search_thread->current_priority;
8c70: e5937014 ldr r7, [r3, #20]
if ( priority >= search_priority )
8c74: e15c0007 cmp ip, r7
8c78: 2a00000a bcs 8ca8 <_Thread_queue_Enqueue_priority+0x120>
static inline void arm_interrupt_flash( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
8c7c: e10f9000 mrs r9, CPSR
8c80: e129f004 msr CPSR_fc, r4
8c84: e129f009 msr CPSR_fc, r9
8c88: e5939010 ldr r9, [r3, #16]
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) ) {
8c8c: e1180009 tst r8, r9
8c90: 1a000001 bne 8c9c <_Thread_queue_Enqueue_priority+0x114>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
8c94: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
8c98: eaffffec b 8c50 <_Thread_queue_Enqueue_priority+0xc8> <== NOT EXECUTED
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
8c9c: e5933004 ldr r3, [r3, #4]
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
8ca0: e1530005 cmp r3, r5
8ca4: 1afffff1 bne 8c70 <_Thread_queue_Enqueue_priority+0xe8>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
8ca8: e5905030 ldr r5, [r0, #48] ; 0x30
8cac: e3550001 cmp r5, #1
8cb0: 1a000014 bne 8d08 <_Thread_queue_Enqueue_priority+0x180>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
8cb4: e3a02000 mov r2, #0
if ( priority == search_priority )
8cb8: e15c0007 cmp ip, r7
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
8cbc: e5802030 str r2, [r0, #48] ; 0x30
if ( priority == search_priority )
8cc0: 0a000006 beq 8ce0 <_Thread_queue_Enqueue_priority+0x158>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
8cc4: e5932000 ldr r2, [r3]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
8cc8: e881000c stm r1, {r2, r3}
search_node->next = the_node;
8ccc: e5831000 str r1, [r3]
next_node->previous = the_node;
8cd0: e5821004 str r1, [r2, #4]
the_thread->Wait.queue = the_thread_queue;
8cd4: e5810044 str r0, [r1, #68] ; 0x44
8cd8: e129f004 msr CPSR_fc, r4
8cdc: ea000007 b 8d00 <_Thread_queue_Enqueue_priority+0x178>
_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;
8ce0: e5932040 ldr r2, [r3, #64] ; 0x40
the_thread->Wait.queue = the_thread_queue;
_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 );
8ce4: e283c03c add ip, r3, #60 ; 0x3c
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
8ce8: e581c000 str ip, [r1]
the_node->previous = previous_node;
8cec: e5812004 str r2, [r1, #4]
previous_node->next = the_node;
8cf0: e5821000 str r1, [r2]
search_node->previous = the_node;
8cf4: e5831040 str r1, [r3, #64] ; 0x40
the_thread->Wait.queue = the_thread_queue;
8cf8: e5810044 str r0, [r1, #68] ; 0x44
8cfc: e129f006 msr CPSR_fc, r6
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
8d00: e3a00001 mov r0, #1
8d04: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, 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;
8d08: e5826000 str r6, [r2]
return the_thread_queue->sync_state;
8d0c: e5900030 ldr r0, [r0, #48] ; 0x30
}
8d10: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
00014f84 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
14f84: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
14f88: e24dd01c sub sp, sp, #28
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
14f8c: e28d8004 add r8, sp, #4 14f90: e28d5010 add r5, sp, #16
head->previous = NULL;
14f94: e3a03000 mov r3, #0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
14f98: e2889004 add r9, r8, #4 14f9c: e2856004 add r6, r5, #4 14fa0: e58d9004 str r9, [sp, #4]
head->previous = NULL;
14fa4: e58d3008 str r3, [sp, #8]
tail->previous = head;
14fa8: e58d800c str r8, [sp, #12]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
14fac: e58d6010 str r6, [sp, #16]
head->previous = NULL;
14fb0: e58d3014 str r3, [sp, #20]
tail->previous = head;
14fb4: e58d5018 str r5, [sp, #24] 14fb8: e1a04000 mov r4, r0
{
/*
* 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;
14fbc: e5848078 str r8, [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;
14fc0: e59f7174 ldr r7, [pc, #372] ; 1513c <_Timer_server_Body+0x1b8> 14fc4: e5973000 ldr r3, [r7]
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
14fc8: e594103c ldr r1, [r4, #60] ; 0x3c
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
14fcc: e2840030 add r0, r4, #48 ; 0x30 14fd0: e0611003 rsb r1, r1, r3
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
14fd4: e584303c str r3, [r4, #60] ; 0x3c
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
14fd8: e1a02005 mov r2, r5
14fdc: eb0010d5 bl 19338 <_Watchdog_Adjust_to_chain>
14fe0: e59f3158 ldr r3, [pc, #344] ; 15140 <_Timer_server_Body+0x1bc>
14fe4: e59f2158 ldr r2, [pc, #344] ; 15144 <_Timer_server_Body+0x1c0>
14fe8: e8930003 ldm r3, {r0, r1}
14fec: e3a03000 mov r3, #0
14ff0: eb004ee7 bl 28b94 <__divdi3>
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
14ff4: e5942074 ldr r2, [r4, #116] ; 0x74
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the watchdogs->Chain to indicate this.
*/
if ( snapshot > last_snapshot ) {
14ff8: e1500002 cmp r0, r2 14ffc: e1a0a000 mov sl, r0
15000: 9a000004 bls 15018 <_Timer_server_Body+0x94>
/*
* 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 );
15004: e062100a rsb r1, r2, sl 15008: e2840068 add r0, r4, #104 ; 0x68 1500c: e1a02005 mov r2, r5 15010: eb0010c8 bl 19338 <_Watchdog_Adjust_to_chain> 15014: ea000003 b 15028 <_Timer_server_Body+0xa4>
/*
* 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 );
15018: 32840068 addcc r0, r4, #104 ; 0x68 1501c: 33a01001 movcc r1, #1 15020: 306a2002 rsbcc r2, sl, r2 15024: 3b00109b blcc 19298 <_Watchdog_Adjust>
}
watchdogs->last_snapshot = snapshot;
15028: e584a074 str sl, [r4, #116] ; 0x74
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
1502c: e284b068 add fp, r4, #104 ; 0x68
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
15030: e284a030 add sl, r4, #48 ; 0x30
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
15034: e5940078 ldr r0, [r4, #120] ; 0x78 15038: eb0002bd bl 15b34 <_Chain_Get>
if ( timer == NULL ) {
1503c: e2501000 subs r1, r0, #0
15040: 0a000009 beq 1506c <_Timer_server_Body+0xe8>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
15044: e5913038 ldr r3, [r1, #56] ; 0x38 15048: e3530001 cmp r3, #1
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
1504c: 01a0000a moveq r0, sl
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
15050: 0a000002 beq 15060 <_Timer_server_Body+0xdc>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
15054: e3530003 cmp r3, #3
15058: 1afffff5 bne 15034 <_Timer_server_Body+0xb0>
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
1505c: e1a0000b mov r0, fp 15060: e2811010 add r1, r1, #16 15064: eb0010d8 bl 193cc <_Watchdog_Insert> 15068: eafffff1 b 15034 <_Timer_server_Body+0xb0>
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
1506c: e58d1000 str r1, [sp] 15070: ebffff97 bl 14ed4 <arm_interrupt_disable>
if ( _Chain_Is_empty( insert_chain ) ) {
15074: e59d3004 ldr r3, [sp, #4] 15078: e1530009 cmp r3, r9 1507c: e59d1000 ldr r1, [sp]
15080: 1a000006 bne 150a0 <_Timer_server_Body+0x11c>
ts->insert_chain = NULL;
15084: e5841078 str r1, [r4, #120] ; 0x78 15088: e129f000 msr CPSR_fc, r0
_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 ) ) {
1508c: e59d3010 ldr r3, [sp, #16] 15090: e1530006 cmp r3, r6
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
15094: 13a07000 movne r7, #0
_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 ) ) {
15098: 1a000002 bne 150a8 <_Timer_server_Body+0x124>
1509c: ea000011 b 150e8 <_Timer_server_Body+0x164>
150a0: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 150a4: eaffffc6 b 14fc4 <_Timer_server_Body+0x40> <== NOT EXECUTED
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
150a8: ebffff89 bl 14ed4 <arm_interrupt_disable>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
150ac: e59d3010 ldr r3, [sp, #16]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
150b0: e1530006 cmp r3, r6
150b4: 0a000009 beq 150e0 <_Timer_server_Body+0x15c>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
150b8: e5932000 ldr r2, [r3]
head->next = new_first;
new_first->previous = head;
150bc: e5825004 str r5, [r2, #4]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
150c0: e58d2010 str r2, [sp, #16]
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
150c4: e5837008 str r7, [r3, #8] 150c8: e129f000 msr CPSR_fc, r0
/*
* 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 );
150cc: e2830020 add r0, r3, #32
150d0: e8900003 ldm r0, {r0, r1}
150d4: e1a0e00f mov lr, pc
150d8: e593f01c ldr pc, [r3, #28]
}
150dc: eafffff1 b 150a8 <_Timer_server_Body+0x124> 150e0: e129f000 msr CPSR_fc, r0 150e4: eaffffb4 b 14fbc <_Timer_server_Body+0x38>
} else {
ts->active = false;
150e8: e3a03000 mov r3, #0 150ec: e5c4307c strb r3, [r4, #124] ; 0x7c
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
150f0: e59f3050 ldr r3, [pc, #80] ; 15148 <_Timer_server_Body+0x1c4> 150f4: e5932000 ldr r2, [r3]
++level;
150f8: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
150fc: e5832000 str r2, [r3]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
15100: e3a01008 mov r1, #8 15104: e5940000 ldr r0, [r4] 15108: eb000f88 bl 18f30 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
1510c: e1a00004 mov r0, r4 15110: ebffff73 bl 14ee4 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
15114: e1a00004 mov r0, r4 15118: ebffff85 bl 14f34 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
1511c: eb000d54 bl 18674 <_Thread_Enable_dispatch>
ts->active = true;
15120: e3a03001 mov r3, #1 15124: 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 );
15128: e2840008 add r0, r4, #8 1512c: eb0010fd bl 19528 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
15130: e2840040 add r0, r4, #64 ; 0x40 15134: eb0010fb bl 19528 <_Watchdog_Remove> 15138: eaffff9f b 14fbc <_Timer_server_Body+0x38>
00010e00 <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
10e00: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
10e04: e59db028 ldr fp, [sp, #40] ; 0x28
10e08: e1a08000 mov r8, r0
10e0c: e1a05003 mov r5, r3
int rc = RC_OK;
ssize_t cmpltd = 0;
uint32_t sec_num = start;
uint32_t ofs = offset;
10e10: e1a07002 mov r7, r2
void *buff
)
{
int rc = RC_OK;
ssize_t cmpltd = 0;
uint32_t sec_num = start;
10e14: e1a06001 mov r6, r1
uint32_t count,
void *buff
)
{
int rc = RC_OK;
ssize_t cmpltd = 0;
10e18: e3a04000 mov r4, #0
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while (count > 0)
10e1c: ea000013 b 10e70 <_fat_block_read+0x70>
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
10e20: e1a00008 mov r0, r8 10e24: e1a01006 mov r1, r6 10e28: e3a02001 mov r2, #1 10e2c: e1a0300d mov r3, sp 10e30: ebffffc7 bl 10d54 <fat_buf_access>
if (rc != RC_OK)
10e34: e2509000 subs r9, r0, #0
10e38: 1a00000f bne 10e7c <_fat_block_read+0x7c>
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
10e3c: e1d8a0b0 ldrh sl, [r8]
memcpy((buff + cmpltd), (sec_buf + ofs), c);
10e40: e59d1000 ldr r1, [sp]
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
10e44: e067a00a rsb sl, r7, sl 10e48: e15a0005 cmp sl, r5 10e4c: 21a0a005 movcs sl, r5
memcpy((buff + cmpltd), (sec_buf + ofs), c);
10e50: e08b0004 add r0, fp, r4 10e54: e0811007 add r1, r1, r7 10e58: e1a0200a mov r2, sl 10e5c: eb002128 bl 19304 <memcpy>
count -= c;
10e60: e06a5005 rsb r5, sl, r5
cmpltd += c;
10e64: e08a4004 add r4, sl, r4
sec_num++;
10e68: e2866001 add r6, r6, #1
ofs = 0;
10e6c: e1a07009 mov r7, r9
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while (count > 0)
10e70: e3550000 cmp r5, #0
10e74: 1affffe9 bne 10e20 <_fat_block_read+0x20>
10e78: ea000000 b 10e80 <_fat_block_read+0x80>
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return -1;
10e7c: e3e04000 mvn r4, #0 <== NOT EXECUTED
cmpltd += c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
10e80: e1a00004 mov r0, r4
10e84: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
00010004 <_hash_search>:
rtems_chain_control *hash,
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
10004: e92d41f0 push {r4, r5, r6, r7, r8, lr}
10008: e1a05002 mov r5, r2
1000c: e1a07003 mov r7, r3
uint32_t mod = (key1) % FAT_HASH_MODULE;
10010: e2023001 and r3, r2, #1
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
10014: e3a0200c mov r2, #12 10018: e0030392 mul r3, r2, r3 1001c: e0818003 add r8, r1, r3
rtems_chain_control *hash,
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
10020: e1a04000 mov r4, r0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
10024: e7916003 ldr r6, [r1, r3]
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
10028: e2888004 add r8, r8, #4
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
1002c: ea00000e b 1006c <_hash_search+0x68>
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(fs_info, &ffd->dir_pos.sname);
10030: e1a00004 mov r0, r4 10034: e2861020 add r1, r6, #32 10038: ebffffe2 bl ffc8 <fat_construct_key>
if ( (key1) == ck)
1003c: e1550000 cmp r5, r0
10040: 1a000008 bne 10068 <_hash_search+0x64>
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
10044: e3570000 cmp r7, #0
10048: 0a000002 beq 10058 <_hash_search+0x54>
1004c: e596300c ldr r3, [r6, #12] <== NOT EXECUTED 10050: e1570003 cmp r7, r3 <== NOT EXECUTED 10054: 1a000003 bne 10068 <_hash_search+0x64> <== NOT EXECUTED
{
*ret = (void *)the_node;
10058: e59d3018 ldr r3, [sp, #24]
return 0;
1005c: e3a00000 mov r0, #0
if ( (key1) == ck)
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
{
*ret = (void *)the_node;
10060: e5836000 str r6, [r3]
return 0;
10064: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
}
}
the_node = the_node->next;
10068: e5966000 ldr r6, [r6]
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
1006c: e1560008 cmp r6, r8
10070: 1affffee bne 10030 <_hash_search+0x2c>
return 0;
}
}
the_node = the_node->next;
}
return -1;
10074: e3e00000 mvn r0, #0
}
10078: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
00002d68 <_lstat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
2d68: e1a00001 mov r0, r1 <== NOT EXECUTED
2d6c: e1a01002 mov r1, r2 <== NOT EXECUTED
2d70: eaffffe4 b 2d08 <lstat> <== NOT EXECUTED
00003238 <_stat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
3238: e1a00001 mov r0, r1 <== NOT EXECUTED
323c: e1a01002 mov r1, r2 <== NOT EXECUTED
3240: eaffffe4 b 31d8 <stat> <== NOT EXECUTED
000062c0 <aio_fsync>:
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
62c0: e3500a02 cmp r0, #8192 ; 0x2000
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
62c4: e92d4030 push {r4, r5, lr}
62c8: e1a04001 mov r4, r1
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
62cc: 13a05016 movne r5, #22
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
62d0: 1a00000c bne 6308 <aio_fsync+0x48>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
62d4: e5910000 ldr r0, [r1]
62d8: e3a01003 mov r1, #3
62dc: eb0018bf bl c5e0 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
62e0: e2000003 and r0, r0, #3
62e4: e2400001 sub r0, r0, #1
62e8: e3500001 cmp r0, #1
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
62ec: 83a05009 movhi r5, #9
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
62f0: 8a000004 bhi 6308 <aio_fsync+0x48>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
62f4: e3a00018 mov r0, #24
62f8: ebfff289 bl 2d24 <malloc>
if (req == NULL)
62fc: e2503000 subs r3, r0, #0
6300: 1a000007 bne 6324 <aio_fsync+0x64>
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
6304: e3a0500b mov r5, #11 <== NOT EXECUTED
6308: e3e03000 mvn r3, #0
630c: e5845030 str r5, [r4, #48] ; 0x30
6310: e5843034 str r3, [r4, #52] ; 0x34
6314: eb002574 bl f8ec <__errno>
6318: e5805000 str r5, [r0]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
631c: e3e00000 mvn r0, #0
6320: e8bd8030 pop {r4, r5, pc}
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
6324: e5834014 str r4, [r3, #20]
req->aiocbp->aio_lio_opcode = LIO_SYNC;
6328: e3a03003 mov r3, #3
632c: e584302c str r3, [r4, #44] ; 0x2c
return rtems_aio_enqueue (req);
}
6330: e8bd4030 pop {r4, r5, lr}
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
6334: ea000135 b 6810 <rtems_aio_enqueue>
00006a10 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
6a10: e92d4030 push {r4, r5, lr}
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
6a14: e3a01003 mov r1, #3
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
6a18: e1a04000 mov r4, r0
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
6a1c: e5900000 ldr r0, [r0]
6a20: eb0016ee bl c5e0 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
6a24: e2000003 and r0, r0, #3
6a28: e3500002 cmp r0, #2
6a2c: 13500000 cmpne r0, #0
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
6a30: 13a05009 movne r5, #9
{
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
6a34: 1a00000d bne 6a70 <aio_read+0x60>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
6a38: e5943014 ldr r3, [r4, #20]
6a3c: e3530000 cmp r3, #0
6a40: 1a000003 bne 6a54 <aio_read+0x44>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
6a44: e994000c ldmib r4, {r2, r3}
6a48: e3520000 cmp r2, #0
6a4c: e2d31000 sbcs r1, r3, #0
6a50: aa000001 bge 6a5c <aio_read+0x4c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
6a54: e3a05016 mov r5, #22
6a58: ea000004 b 6a70 <aio_read+0x60>
req = malloc (sizeof (rtems_aio_request));
6a5c: e3a00018 mov r0, #24
6a60: ebfff0af bl 2d24 <malloc>
if (req == NULL)
6a64: e2503000 subs r3, r0, #0
6a68: 1a000007 bne 6a8c <aio_read+0x7c>
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
6a6c: e3a0500b mov r5, #11 <== NOT EXECUTED
6a70: e3e03000 mvn r3, #0
6a74: e5845030 str r5, [r4, #48] ; 0x30
6a78: e5843034 str r3, [r4, #52] ; 0x34
6a7c: eb00239a bl f8ec <__errno>
6a80: e5805000 str r5, [r0]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
6a84: e3e00000 mvn r0, #0
6a88: e8bd8030 pop {r4, r5, pc}
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
6a8c: e5834014 str r4, [r3, #20]
req->aiocbp->aio_lio_opcode = LIO_READ;
6a90: e3a03001 mov r3, #1
6a94: e584302c str r3, [r4, #44] ; 0x2c
return rtems_aio_enqueue (req);
}
6a98: e8bd4030 pop {r4, r5, lr}
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
6a9c: eaffff5b b 6810 <rtems_aio_enqueue>
00006aa8 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
6aa8: e92d4030 push {r4, r5, lr}
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
6aac: e3a01003 mov r1, #3
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
6ab0: e1a04000 mov r4, r0
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
6ab4: e5900000 ldr r0, [r0]
6ab8: eb0016c8 bl c5e0 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
6abc: e2000003 and r0, r0, #3
6ac0: e2400001 sub r0, r0, #1
6ac4: e3500001 cmp r0, #1
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
6ac8: 83a05009 movhi r5, #9
{
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
6acc: 8a00000d bhi 6b08 <aio_write+0x60>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
6ad0: e5943014 ldr r3, [r4, #20]
6ad4: e3530000 cmp r3, #0
6ad8: 1a000003 bne 6aec <aio_write+0x44>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
6adc: e994000c ldmib r4, {r2, r3}
6ae0: e3520000 cmp r2, #0
6ae4: e2d31000 sbcs r1, r3, #0
6ae8: aa000001 bge 6af4 <aio_write+0x4c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
6aec: e3a05016 mov r5, #22
6af0: ea000004 b 6b08 <aio_write+0x60>
req = malloc (sizeof (rtems_aio_request));
6af4: e3a00018 mov r0, #24
6af8: ebfff089 bl 2d24 <malloc>
if (req == NULL)
6afc: e2503000 subs r3, r0, #0
6b00: 1a000007 bne 6b24 <aio_write+0x7c>
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
6b04: e3a0500b mov r5, #11 <== NOT EXECUTED
6b08: e3e03000 mvn r3, #0
6b0c: e5845030 str r5, [r4, #48] ; 0x30
6b10: e5843034 str r3, [r4, #52] ; 0x34
6b14: eb002374 bl f8ec <__errno>
6b18: e5805000 str r5, [r0]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
6b1c: e3e00000 mvn r0, #0
6b20: e8bd8030 pop {r4, r5, pc}
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
6b24: e5834014 str r4, [r3, #20]
req->aiocbp->aio_lio_opcode = LIO_WRITE;
6b28: e3a03002 mov r3, #2
6b2c: e584302c str r3, [r4, #44] ; 0x2c
return rtems_aio_enqueue (req);
}
6b30: e8bd4030 pop {r4, r5, lr}
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
6b34: eaffff35 b 6810 <rtems_aio_enqueue>
00002398 <create_disk>:
dev_t dev,
const char *name,
rtems_disk_device **dd_ptr,
char **alloc_name_ptr
)
{
2398: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
239c: e58d3000 str r3, [sp]
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
23a0: e59f3168 ldr r3, [pc, #360] ; 2510 <create_disk+0x178>
23a4: e593a000 ldr sl, [r3]
23a8: e150000a cmp r0, sl
dev_t dev,
const char *name,
rtems_disk_device **dd_ptr,
char **alloc_name_ptr
)
{
23ac: e1a04000 mov r4, r0
23b0: e1a05001 mov r5, r1
23b4: e1a06002 mov r6, r2
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
23b8: 3a00000e bcc 23f8 <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;
23bc: e1a0708a lsl r7, sl, #1
if (major >= new_size) {
23c0: e1540007 cmp r4, r7
new_size = major + 1;
23c4: 22847001 addcs r7, r4, #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;
23c8: e5930004 ldr r0, [r3, #4]
if (major >= new_size) {
new_size = major + 1;
}
table = realloc(table, new_size * sizeof(*table));
23cc: e1a01187 lsl r1, r7, #3
23d0: eb0007dc bl 4348 <realloc>
if (table == NULL) {
23d4: e2508000 subs r8, r0, #0
23d8: 0a000043 beq 24ec <create_disk+0x154>
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
23dc: e06a2007 rsb r2, sl, r7 <== NOT EXECUTED
23e0: e088018a add r0, r8, sl, lsl #3 <== NOT EXECUTED
23e4: e3a01000 mov r1, #0 <== NOT EXECUTED
23e8: e1a02182 lsl r2, r2, #3 <== NOT EXECUTED
23ec: eb003f11 bl 12038 <memset> <== NOT EXECUTED
disktab = table;
23f0: e59f3118 ldr r3, [pc, #280] ; 2510 <create_disk+0x178> <== NOT EXECUTED
disktab_size = new_size;
23f4: e8830180 stm r3, {r7, r8} <== NOT EXECUTED
}
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
23f8: e59f3110 ldr r3, [pc, #272] ; 2510 <create_disk+0x178>
23fc: e5938004 ldr r8, [r3, #4]
2400: e7980184 ldr r0, [r8, r4, lsl #3]
2404: e0889184 add r9, r8, r4, lsl #3
2408: e3500000 cmp r0, #0
240c: e599b004 ldr fp, [r9, #4]
2410: 0a000001 beq 241c <create_disk+0x84>
2414: e155000b cmp r5, fp
2418: 3a00000f bcc 245c <create_disk+0xc4>
rtems_disk_device **table = disktab [major].minor;
rtems_device_minor_number old_size = disktab [major].size;
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
241c: e35b0000 cmp fp, #0
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
2420: 11a0708b lslne r7, fp, #1
rtems_disk_device **table = disktab [major].minor;
rtems_device_minor_number old_size = disktab [major].size;
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
new_size = DISKTAB_INITIAL_SIZE;
2424: 03a07008 moveq r7, #8
} else {
new_size = 2 * old_size;
}
if (minor >= new_size) {
2428: e1550007 cmp r5, r7
new_size = minor + 1;
242c: 22857001 addcs r7, r5, #1
}
table = realloc(table, new_size * sizeof(*table));
2430: e1a01107 lsl r1, r7, #2
2434: eb0007c3 bl 4348 <realloc>
if (table == NULL) {
2438: e250a000 subs sl, r0, #0
243c: 0a00002a beq 24ec <create_disk+0x154>
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
2440: e06b2007 rsb r2, fp, r7
2444: e08a010b add r0, sl, fp, lsl #2
2448: e3a01000 mov r1, #0
244c: e1a02102 lsl r2, r2, #2
2450: eb003ef8 bl 12038 <memset>
disktab [major].minor = table;
2454: e788a184 str sl, [r8, r4, lsl #3]
disktab [major].size = new_size;
2458: e5897004 str r7, [r9, #4]
}
return disktab [major].minor + minor;
245c: e7987184 ldr r7, [r8, r4, lsl #3]
2460: e0873105 add r3, r7, r5, 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) {
2464: e3530000 cmp r3, #0
2468: 0a00001f beq 24ec <create_disk+0x154>
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
246c: e7973105 ldr r3, [r7, r5, lsl #2]
2470: e3530000 cmp r3, #0
return RTEMS_RESOURCE_IN_USE;
2474: 13a0000c movne r0, #12
if (dd_entry == NULL) {
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
2478: 1a00001c bne 24f0 <create_disk+0x158>
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
247c: e3a00074 mov r0, #116 ; 0x74
2480: eb000518 bl 38e8 <malloc>
if (dd == NULL) {
2484: e2508000 subs r8, r0, #0
2488: 0a000017 beq 24ec <create_disk+0x154>
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
248c: e3560000 cmp r6, #0
2490: 0a00000d beq 24cc <create_disk+0x134>
alloc_name = strdup(name);
2494: e1a00006 mov r0, r6
2498: eb00409a bl 12708 <strdup>
if (alloc_name == NULL) {
249c: e250a000 subs sl, r0, #0
if (dd == NULL) {
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
alloc_name = strdup(name);
24a0: e1a06000 mov r6, r0
if (alloc_name == NULL) {
24a4: 1a000012 bne 24f4 <create_disk+0x15c>
free(dd);
24a8: e1a00008 mov r0, r8 <== NOT EXECUTED
24ac: eb0003df bl 3430 <free> <== NOT EXECUTED
24b0: ea00000d b 24ec <create_disk+0x154> <== NOT EXECUTED
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
free(alloc_name);
24b4: e1a00006 mov r0, r6 <== NOT EXECUTED
24b8: eb0003dc bl 3430 <free> <== NOT EXECUTED
free(dd);
24bc: e1a00008 mov r0, r8 <== NOT EXECUTED
24c0: eb0003da bl 3430 <free> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
24c4: e3a0000d mov r0, #13 <== NOT EXECUTED
24c8: ea000008 b 24f0 <create_disk+0x158> <== NOT EXECUTED
char **alloc_name_ptr
)
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
24cc: e1a0a006 mov sl, r6
return RTEMS_UNSATISFIED;
}
}
*dd_entry = dd;
*dd_ptr = dd;
24d0: e59d3000 ldr r3, [sp]
free(dd);
return RTEMS_UNSATISFIED;
}
}
*dd_entry = dd;
24d4: e7878105 str r8, [r7, r5, lsl #2]
*dd_ptr = dd;
24d8: e5838000 str r8, [r3]
*alloc_name_ptr = alloc_name;
24dc: e59d3028 ldr r3, [sp, #40] ; 0x28
return RTEMS_SUCCESSFUL;
24e0: e3a00000 mov r0, #0
}
}
*dd_entry = dd;
*dd_ptr = dd;
*alloc_name_ptr = alloc_name;
24e4: e583a000 str sl, [r3]
return RTEMS_SUCCESSFUL;
24e8: ea000000 b 24f0 <create_disk+0x158>
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
if (dd == NULL) {
return RTEMS_NO_MEMORY;
24ec: e3a0001a mov r0, #26
*dd_entry = dd;
*dd_ptr = dd;
*alloc_name_ptr = alloc_name;
return RTEMS_SUCCESSFUL;
}
24f0: e8bd8ff8 pop {r3, 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) {
24f4: e59f1018 ldr r1, [pc, #24] ; 2514 <create_disk+0x17c>
24f8: e1a02004 mov r2, r4
24fc: e1a03005 mov r3, r5
2500: eb000554 bl 3a58 <mknod>
2504: e3500000 cmp r0, #0
2508: aafffff0 bge 24d0 <create_disk+0x138>
250c: eaffffe8 b 24b4 <create_disk+0x11c> <== NOT EXECUTED
0000a9d8 <devFS_eval_path>:
static inline const devFS_data *devFS_get_data(
const rtems_filesystem_location_info_t *loc
)
{
return (const devFS_data *) loc->mt_entry->immutable_fs_info;
a9d8: e590302c ldr r3, [r0, #44] ; 0x2c
a9dc: e5933010 ldr r3, [r3, #16]
}
void devFS_eval_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
a9e0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
{
size_t i = 0;
size_t n = data->count;
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
devFS_node *free_node = NULL;
a9e4: e3a05000 mov r5, #0
}
void devFS_eval_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
a9e8: e1a04000 mov r4, r0
static inline const char *rtems_filesystem_eval_path_get_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->path;
a9ec: e5909000 ldr r9, [r0]
static inline size_t rtems_filesystem_eval_path_get_pathlen(
rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->pathlen;
a9f0: e5908004 ldr r8, [r0, #4]
size_t pathlen,
devFS_node **free_node_ptr
)
{
size_t i = 0;
size_t n = data->count;
a9f4: e8930880 ldm r3, {r7, fp}
devFS_node *nodes = data->nodes; devFS_node *node = NULL;
a9f8: e1a06005 mov r6, r5
devFS_node *free_node = NULL;
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
a9fc: e1a0a005 mov sl, r5
aa00: ea000010 b aa48 <devFS_eval_path+0x70>
devFS_node *current = nodes + i;
if (current->name != NULL) {
aa04: e5970000 ldr r0, [r7]
aa08: e3500000 cmp r0, #0
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
devFS_node *free_node = NULL;
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
devFS_node *current = nodes + i;
aa0c: e1a03007 mov r3, r7
if (current->name != NULL) {
aa10: 0a000009 beq aa3c <devFS_eval_path+0x64>
if (
aa14: e5973004 ldr r3, [r7, #4]
aa18: e1530008 cmp r3, r8
aa1c: 11a03005 movne r3, r5
aa20: 1a000005 bne aa3c <devFS_eval_path+0x64>
current->namelen == pathlen
&& memcmp(current->name, path, pathlen) == 0
aa24: e1a01009 mov r1, r9
aa28: e1a02008 mov r2, r8
aa2c: eb000cca bl dd5c <memcmp>
aa30: e3500000 cmp r0, #0
aa34: e1a03005 mov r3, r5
aa38: 01a06007 moveq r6, r7
size_t n = data->count;
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
devFS_node *free_node = NULL;
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
aa3c: e28aa001 add sl, sl, #1
aa40: e2877014 add r7, r7, #20
aa44: e1a05003 mov r5, r3
aa48: e3550000 cmp r5, #0
aa4c: 13560000 cmpne r6, #0
aa50: 1a000001 bne aa5c <devFS_eval_path+0x84>
aa54: e15a000b cmp sl, fp
aa58: 1affffe9 bne aa04 <devFS_eval_path+0x2c>
rtems_filesystem_eval_path_get_pathlen(ctx),
&free_node
);
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (node != NULL) {
aa5c: e3560000 cmp r6, #0
static inline int rtems_filesystem_eval_path_get_flags(
const rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->flags;
aa60: e5943010 ldr r3, [r4, #16]
aa64: 0a000006 beq aa84 <devFS_eval_path+0xac>
if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {
aa68: e2133040 ands r3, r3, #64 ; 0x40
currentloc->node_access = node;
aa6c: 05846020 streq r6, [r4, #32]
static inline void rtems_filesystem_eval_path_clear_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->pathlen = 0;
aa70: 05843004 streq r3, [r4, #4]
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, EEXIST);
aa74: 11a00004 movne r0, r4
aa78: 13a01011 movne r1, #17
&free_node
);
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (node != NULL) {
if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {
aa7c: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
aa80: ea00000f b aac4 <devFS_eval_path+0xec>
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, EEXIST);
}
} else {
if ((eval_flags & RTEMS_FS_MAKE) != 0) {
aa84: e3130020 tst r3, #32
aa88: 0a00000b beq aabc <devFS_eval_path+0xe4>
if (free_node != NULL) {
aa8c: e3550000 cmp r5, #0
aa90: 0a000006 beq aab0 <devFS_eval_path+0xd8>
free_node->mode = S_IRWXU | S_IRWXG | S_IRWXO;
aa94: e59f3030 ldr r3, [pc, #48] ; aacc <devFS_eval_path+0xf4>
aa98: e5853010 str r3, [r5, #16]
currentloc->node_access = free_node;
aa9c: e5845020 str r5, [r4, #32]
rtems_filesystem_eval_path_context_t *ctx,
const char *token,
size_t tokenlen
)
{
ctx->token = token;
aaa0: e5849008 str r9, [r4, #8]
ctx->tokenlen = tokenlen;
aaa4: e584800c str r8, [r4, #12]
static inline void rtems_filesystem_eval_path_clear_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->pathlen = 0;
aaa8: e5846004 str r6, [r4, #4]
aaac: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rtems_filesystem_eval_path_get_path(ctx),
rtems_filesystem_eval_path_get_pathlen(ctx)
);
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, ENOSPC);
aab0: e1a00004 mov r0, r4
aab4: e3a0101c mov r1, #28
aab8: ea000001 b aac4 <devFS_eval_path+0xec>
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
aabc: e1a00004 mov r0, r4 <== NOT EXECUTED
aac0: e3a01002 mov r1, #2 <== NOT EXECUTED
}
}
}
aac4: e8bd4ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, ENOSPC);
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
aac8: eaffe5fb b 42bc <rtems_filesystem_eval_path_error>
00002368 <disk_unlock>:
static void
disk_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
2368: e59f3020 ldr r3, [pc, #32] ; 2390 <disk_unlock+0x28>
236c: e3a02000 mov r2, #0
}
}
static void
disk_unlock(void)
{
2370: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
sc = rtems_semaphore_release(diskdevs_mutex);
2374: e5930008 ldr r0, [r3, #8]
static void
disk_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
2378: e5c3200c strb r2, [r3, #12]
sc = rtems_semaphore_release(diskdevs_mutex);
237c: eb001403 bl 7390 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL) {
2380: e3500000 cmp r0, #0
2384: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
/* FIXME: Error number */
rtems_fatal_error_occurred(0xdeadbeef);
2388: e59f0004 ldr r0, [pc, #4] ; 2394 <disk_unlock+0x2c> <== NOT EXECUTED
238c: eb00156b bl 7940 <rtems_fatal_error_occurred> <== NOT EXECUTED
00003d9c <drainOutput.part.0>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
3d9c: e92d4030 push {r4, r5, lr}
3da0: e1a04000 mov r4, r0
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
3da4: ebffff6e bl 3b64 <arm_interrupt_disable>
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
3da8: e3a05002 mov r5, #2
3dac: ea000008 b 3dd4 <drainOutput.part.0+0x38>
3db0: e5845094 str r5, [r4, #148] ; 0x94 <== NOT EXECUTED
3db4: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
3db8: e3a01000 mov r1, #0 <== NOT EXECUTED
3dbc: e594008c ldr r0, [r4, #140] ; 0x8c <== NOT EXECUTED
3dc0: e1a02001 mov r2, r1 <== NOT EXECUTED
3dc4: eb000876 bl 5fa4 <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
3dc8: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
3dcc: 1b000a3f blne 66d0 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_interrupt_disable (level);
3dd0: ebffff63 bl 3b64 <arm_interrupt_disable> <== 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) {
3dd4: e5942084 ldr r2, [r4, #132] ; 0x84
3dd8: e5943080 ldr r3, [r4, #128] ; 0x80
3ddc: e1520003 cmp r2, r3
3de0: 1afffff2 bne 3db0 <drainOutput.part.0+0x14>
3de4: e129f000 msr CPSR_fc, r0
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
rtems_interrupt_enable (level);
}
}
3de8: e8bd8030 pop {r4, r5, pc}
00004af0 <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)
4af0: e5903020 ldr r3, [r0, #32]
4af4: e3530000 cmp r3, #0
* 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)
{
4af8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
4afc: e1a04000 mov r4, r0
4b00: e1a07001 mov r7, r1
if (tty->ccount == 0)
4b04: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
return;
if (lineFlag) {
4b08: e3510000 cmp r1, #0
4b0c: 0a000060 beq 4c94 <erase+0x1a4>
if (!(tty->termios.c_lflag & ECHO)) {
4b10: e590303c ldr r3, [r0, #60] ; 0x3c
4b14: e2132008 ands r2, r3, #8
tty->ccount = 0;
4b18: 05802020 streq r2, [r0, #32]
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
4b1c: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
4b20: e2133010 ands r3, r3, #16
4b24: 1a00005a bne 4c94 <erase+0x1a4>
tty->ccount = 0;
4b28: e5803020 str r3, [r0, #32] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
4b2c: e1a01004 mov r1, r4 <== NOT EXECUTED
4b30: e5d00044 ldrb r0, [r0, #68] ; 0x44 <== NOT EXECUTED
4b34: ebffffca bl 4a64 <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
4b38: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
4b3c: e3130020 tst r3, #32 <== NOT EXECUTED
echo ('\n', tty);
4b40: 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)
4b44: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
4b48: ea00000b b 4b7c <erase+0x8c> <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
4b4c: e2411001 sub r1, r1, #1
if (tty->termios.c_lflag & ECHO) {
4b50: e594303c ldr r3, [r4, #60] ; 0x3c
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
4b54: e594001c ldr r0, [r4, #28]
4b58: e5841020 str r1, [r4, #32]
if (tty->termios.c_lflag & ECHO) {
4b5c: e3130008 tst r3, #8
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
4b60: e7d05001 ldrb r5, [r0, r1]
if (tty->termios.c_lflag & ECHO) {
4b64: 0a000047 beq 4c88 <erase+0x198>
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
4b68: e3570000 cmp r7, #0
4b6c: 1a000005 bne 4b88 <erase+0x98>
4b70: e3130010 tst r3, #16
4b74: 1a000003 bne 4b88 <erase+0x98>
echo (tty->termios.c_cc[VERASE], tty);
4b78: e5d40043 ldrb r0, [r4, #67] ; 0x43 <== NOT EXECUTED
4b7c: e1a01004 mov r1, r4 <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
4b80: 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);
4b84: eaffffb6 b 4a64 <echo> <== NOT EXECUTED
} else if (c == '\t') {
4b88: e3550009 cmp r5, #9
4b8c: 1a00001f bne 4c10 <erase+0x120>
int col = tty->read_start_column;
4b90: e594502c ldr r5, [r4, #44] ; 0x2c
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
4b94: e5968000 ldr r8, [r6]
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;
int i = 0;
4b98: e3a02000 mov r2, #0
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
4b9c: e2033c02 and r3, r3, #512 ; 0x200
4ba0: ea00000c b 4bd8 <erase+0xe8>
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
4ba4: e7d0c002 ldrb ip, [r0, r2]
if (c == '\t') {
4ba8: e35c0009 cmp ip, #9
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
4bac: e2822001 add r2, r2, #1
if (c == '\t') {
col = (col | 7) + 1;
4bb0: 03855007 orreq r5, r5, #7
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
4bb4: 0a000006 beq 4bd4 <erase+0xe4>
col = (col | 7) + 1;
} else if (iscntrl (c)) {
4bb8: e088c00c add ip, r8, ip
4bbc: e5dcc001 ldrb ip, [ip, #1]
4bc0: e31c0020 tst ip, #32
4bc4: 0a000002 beq 4bd4 <erase+0xe4>
if (tty->termios.c_lflag & ECHOCTL)
4bc8: e3530000 cmp r3, #0 <== NOT EXECUTED
col += 2;
4bcc: 12855002 addne r5, r5, #2 <== NOT EXECUTED
4bd0: ea000000 b 4bd8 <erase+0xe8> <== NOT EXECUTED
} else {
col++;
4bd4: e2855001 add r5, r5, #1
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
4bd8: e1520001 cmp r2, r1
4bdc: 1afffff0 bne 4ba4 <erase+0xb4>
4be0: ea000006 b 4c00 <erase+0x110>
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
4be4: e59f00bc ldr r0, [pc, #188] ; 4ca8 <erase+0x1b8>
4be8: e3a01001 mov r1, #1
4bec: e1a02004 mov r2, r4
4bf0: ebffff0a bl 4820 <rtems_termios_puts>
tty->column--;
4bf4: e5943028 ldr r3, [r4, #40] ; 0x28
4bf8: e2433001 sub r3, r3, #1
4bfc: e5843028 str r3, [r4, #40] ; 0x28
}
/*
* Back up over the tab
*/
while (tty->column > col) {
4c00: e5943028 ldr r3, [r4, #40] ; 0x28
4c04: e1530005 cmp r3, r5
4c08: cafffff5 bgt 4be4 <erase+0xf4>
4c0c: ea00001d b 4c88 <erase+0x198>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
4c10: e5962000 ldr r2, [r6]
4c14: e2855001 add r5, r5, #1
4c18: e7d22005 ldrb r2, [r2, r5]
4c1c: e3120020 tst r2, #32
4c20: 0a000009 beq 4c4c <erase+0x15c>
4c24: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
4c28: 0a000007 beq 4c4c <erase+0x15c> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
4c2c: e59f0078 ldr r0, [pc, #120] ; 4cac <erase+0x1bc> <== NOT EXECUTED
4c30: e3a01003 mov r1, #3 <== NOT EXECUTED
4c34: e1a02004 mov r2, r4 <== NOT EXECUTED
4c38: ebfffef8 bl 4820 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
4c3c: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
4c40: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
4c44: 12433001 subne r3, r3, #1 <== NOT EXECUTED
4c48: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
4c4c: e5963000 ldr r3, [r6]
4c50: e7d33005 ldrb r3, [r3, r5]
4c54: e3130020 tst r3, #32
4c58: 0a000002 beq 4c68 <erase+0x178>
4c5c: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
4c60: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
4c64: 0a000007 beq 4c88 <erase+0x198> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
4c68: e59f003c ldr r0, [pc, #60] ; 4cac <erase+0x1bc>
4c6c: e3a01003 mov r1, #3
4c70: e1a02004 mov r2, r4
4c74: ebfffee9 bl 4820 <rtems_termios_puts>
if (tty->column)
4c78: e5943028 ldr r3, [r4, #40] ; 0x28
4c7c: e3530000 cmp r3, #0
tty->column--;
4c80: 12433001 subne r3, r3, #1
4c84: 15843028 strne r3, [r4, #40] ; 0x28
}
}
}
if (!lineFlag)
4c88: e3570000 cmp r7, #0
4c8c: 1a000001 bne 4c98 <erase+0x1a8>
4c90: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
4c94: e59f6014 ldr r6, [pc, #20] ; 4cb0 <erase+0x1c0>
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
4c98: e5941020 ldr r1, [r4, #32]
4c9c: e3510000 cmp r1, #0
4ca0: 1affffa9 bne 4b4c <erase+0x5c>
4ca4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
00010d54 <fat_buf_access>:
int
fat_buf_access(fat_fs_info_t *fs_info,
const uint32_t sec_num,
const int op_type,
uint8_t **sec_buf)
{
10d54: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
10d58: e1a0a003 mov sl, r3
static inline uint32_t
fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,
const uint32_t sector_number)
{
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
10d5c: e5d07002 ldrb r7, [r0, #2] 10d60: e5d0800c ldrb r8, [r0, #12]
sec_num);
uint32_t blk_ofs = fat_sector_offset_to_block_offset (fs_info,
sec_num,
0);
if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
10d64: e5d03089 ldrb r3, [r0, #137] ; 0x89 10d68: e0678008 rsb r8, r7, r8 10d6c: e3530000 cmp r3, #0
int
fat_buf_access(fat_fs_info_t *fs_info,
const uint32_t sec_num,
const int op_type,
uint8_t **sec_buf)
{
10d70: e1a04000 mov r4, r0 10d74: e1a05001 mov r5, r1 10d78: e1a09002 mov r9, r2 10d7c: e1a06831 lsr r6, r1, r8
sec_num);
uint32_t blk_ofs = fat_sector_offset_to_block_offset (fs_info,
sec_num,
0);
if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
10d80: 0a000002 beq 10d90 <fat_buf_access+0x3c>
10d84: e5903084 ldr r3, [r0, #132] ; 0x84 10d88: e1530001 cmp r3, r1
10d8c: 0a000014 beq 10de4 <fat_buf_access+0x90>
{
fat_buf_release(fs_info);
10d90: e1a00004 mov r0, r4 10d94: ebffff8b bl 10bc8 <fat_buf_release>
if (op_type == FAT_OP_TYPE_READ)
10d98: e3590001 cmp r9, #1
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
10d9c: e5940064 ldr r0, [r4, #100] ; 0x64 10da0: e1a01006 mov r1, r6 10da4: e284208c add r2, r4, #140 ; 0x8c
if (fs_info->c.state == FAT_CACHE_EMPTY || fs_info->c.blk_num != sec_num)
{
fat_buf_release(fs_info);
if (op_type == FAT_OP_TYPE_READ)
10da8: 1a000001 bne 10db4 <fat_buf_access+0x60>
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
10dac: ebfff829 bl ee58 <rtems_bdbuf_read> 10db0: ea000000 b 10db8 <fat_buf_access+0x64>
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
10db4: ebfff7f6 bl ed94 <rtems_bdbuf_get>
if (sc != RTEMS_SUCCESSFUL)
10db8: e3500000 cmp r0, #0
10dbc: 0a000004 beq 10dd4 <fat_buf_access+0x80>
rtems_set_errno_and_return_minus_one(EIO);
10dc0: eb001ea8 bl 18868 <__errno> <== NOT EXECUTED
10dc4: e3a03005 mov r3, #5 <== NOT EXECUTED
10dc8: e5803000 str r3, [r0] <== NOT EXECUTED
10dcc: e3e00000 mvn r0, #0 <== NOT EXECUTED
10dd0: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
fs_info->c.blk_num = sec_num;
fs_info->c.modified = 0;
fs_info->c.state = FAT_CACHE_ACTUAL;
10dd4: e3a03001 mov r3, #1
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = sec_num;
10dd8: e5845084 str r5, [r4, #132] ; 0x84
fs_info->c.modified = 0;
10ddc: e5c40088 strb r0, [r4, #136] ; 0x88
fs_info->c.state = FAT_CACHE_ACTUAL;
10de0: e5c43089 strb r3, [r4, #137] ; 0x89
fat_sector_offset_to_block_offset (const fat_fs_info_t *fs_info,
const uint32_t sector,
const uint32_t sector_offset)
{
return sector_offset +
((sector -
10de4: e0455816 sub r5, r5, r6, lsl r8
}
*sec_buf = &fs_info->c.buf->buffer[blk_ofs];
10de8: e594308c ldr r3, [r4, #140] ; 0x8c 10dec: e593301c ldr r3, [r3, #28] 10df0: e0837715 add r7, r3, r5, lsl r7
return RC_OK;
10df4: e3a00000 mov r0, #0
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = sec_num;
fs_info->c.modified = 0;
fs_info->c.state = FAT_CACHE_ACTUAL;
}
*sec_buf = &fs_info->c.buf->buffer[blk_ofs];
10df8: e58a7000 str r7, [sl]
return RC_OK;
}
10dfc: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
00010bc8 <fat_buf_release>:
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
10bc8: e92d4071 push {r0, r4, r5, r6, lr}
10bcc: e1a04000 mov r4, r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (fs_info->c.state == FAT_CACHE_EMPTY)
10bd0: e5d00089 ldrb r0, [r0, #137] ; 0x89 10bd4: e3500000 cmp r0, #0
10bd8: 0a00005c beq 10d50 <fat_buf_release+0x188>
return RC_OK;
if (fs_info->c.modified)
10bdc: e5d43088 ldrb r3, [r4, #136] ; 0x88 10be0: e3530000 cmp r3, #0
10be4: 0a00004e beq 10d24 <fat_buf_release+0x15c>
{
uint32_t sec_num = fs_info->c.blk_num;
10be8: e5942084 ldr r2, [r4, #132] ; 0x84
bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
10bec: e1d431b8 ldrh r3, [r4, #24] 10bf0: e1520003 cmp r2, r3 10bf4: 33a05000 movcc r5, #0
10bf8: 3a000003 bcc 10c0c <fat_buf_release+0x44>
10bfc: e5945020 ldr r5, [r4, #32] 10c00: e1520005 cmp r2, r5 10c04: 23a05000 movcs r5, #0 10c08: 33a05001 movcc r5, #1
uint32_t blk = fat_sector_num_to_block_num(fs_info, sec_num);
uint32_t blk_ofs = fat_sector_offset_to_block_offset(fs_info,
sec_num,
0);
if (sec_of_fat && !fs_info->vol.mirror)
10c0c: e21550ff ands r5, r5, #255 ; 0xff
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
10c10: e5d43002 ldrb r3, [r4, #2] 10c14: e5d4100c ldrb r1, [r4, #12]
uint32_t blk = fat_sector_num_to_block_num(fs_info, sec_num);
uint32_t blk_ofs = fat_sector_offset_to_block_offset(fs_info,
sec_num,
0);
if (sec_of_fat && !fs_info->vol.mirror)
10c18: 0a00000b beq 10c4c <fat_buf_release+0x84>
10c1c: e5d40054 ldrb r0, [r4, #84] ; 0x54 10c20: e3500000 cmp r0, #0
10c24: 1a000008 bne 10c4c <fat_buf_release+0x84>
10c28: e0631001 rsb r1, r3, r1 10c2c: e1a0c132 lsr ip, r2, r1
fat_sector_offset_to_block_offset (const fat_fs_info_t *fs_info,
const uint32_t sector,
const uint32_t sector_offset)
{
return sector_offset +
((sector -
10c30: e042111c sub r1, r2, ip, lsl r1
memcpy(fs_info->sec_buf,
fs_info->c.buf->buffer + blk_ofs,
10c34: e594008c ldr r0, [r4, #140] ; 0x8c
uint32_t blk_ofs = fat_sector_offset_to_block_offset(fs_info,
sec_num,
0);
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf,
10c38: e590201c ldr r2, [r0, #28] 10c3c: e5940090 ldr r0, [r4, #144] ; 0x90 10c40: e0821311 add r1, r2, r1, lsl r3 10c44: e1d420b0 ldrh r2, [r4] 10c48: eb0021ad bl 19304 <memcpy>
fs_info->c.buf->buffer + blk_ofs,
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
10c4c: e594008c ldr r0, [r4, #140] ; 0x8c 10c50: ebfff923 bl f0e4 <rtems_bdbuf_release_modified>
if (sc != RTEMS_SUCCESSFUL)
10c54: e3500000 cmp r0, #0
10c58: 1a000035 bne 10d34 <fat_buf_release+0x16c>
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.modified = 0;
if (sec_of_fat && !fs_info->vol.mirror)
10c5c: e3550000 cmp r5, #0
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;
10c60: e5c40088 strb r0, [r4, #136] ; 0x88
if (sec_of_fat && !fs_info->vol.mirror)
10c64: 0a000037 beq 10d48 <fat_buf_release+0x180>
10c68: e5d43054 ldrb r3, [r4, #84] ; 0x54 10c6c: e3530000 cmp r3, #0 10c70: 03a05001 moveq r5, #1
10c74: 0a000026 beq 10d14 <fat_buf_release+0x14c>
10c78: ea000032 b 10d48 <fat_buf_release+0x180> <== NOT EXECUTED
for (i = 1; i < fs_info->vol.fats; i++)
{
rtems_bdbuf_buffer *bd;
sec_num = fs_info->c.blk_num + fs_info->vol.fat_length * i,
10c7c: e5943084 ldr r3, [r4, #132] ; 0x84 10c80: e594601c ldr r6, [r4, #28] 10c84: e0263695 mla r6, r5, r6, r3
static inline uint32_t
fat_sector_num_to_block_num (const fat_fs_info_t *fs_info,
const uint32_t sector_number)
{
return sector_number >> (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
10c88: e5d4200c ldrb r2, [r4, #12] 10c8c: e5d43002 ldrb r3, [r4, #2] 10c90: e0632002 rsb r2, r3, r2 10c94: e1a01236 lsr r1, r6, r2
fat_sector_offset_to_block_offset (const fat_fs_info_t *fs_info,
const uint32_t sector,
const uint32_t sector_offset)
{
return sector_offset +
((sector -
10c98: e0466211 sub r6, r6, r1, lsl r2
blk = fat_sector_num_to_block_num(fs_info, sec_num);
blk_ofs = fat_sector_offset_to_block_offset(fs_info,
sec_num,
0);
if (blk_ofs == 0
10c9c: e1b06316 lsls r6, r6, r3
10ca0: 1a000007 bne 10cc4 <fat_buf_release+0xfc>
&& fs_info->vol.bps == fs_info->vol.bytes_per_block)
10ca4: e1d420b0 ldrh r2, [r4] 10ca8: e1d430ba ldrh r3, [r4, #10] 10cac: e1520003 cmp r2, r3
10cb0: 1a000003 bne 10cc4 <fat_buf_release+0xfc>
{
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
10cb4: e5940064 ldr r0, [r4, #100] ; 0x64 10cb8: e1a0200d mov r2, sp 10cbc: ebfff834 bl ed94 <rtems_bdbuf_get> 10cc0: ea000002 b 10cd0 <fat_buf_release+0x108>
}
else
{
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd);
10cc4: e5940064 ldr r0, [r4, #100] ; 0x64 10cc8: e1a0200d mov r2, sp 10ccc: ebfff861 bl ee58 <rtems_bdbuf_read>
}
if ( sc != RTEMS_SUCCESSFUL)
10cd0: e3500000 cmp r0, #0
10cd4: 1a000009 bne 10d00 <fat_buf_release+0x138>
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps);
10cd8: e59d3000 ldr r3, [sp] 10cdc: e593001c ldr r0, [r3, #28] 10ce0: e5941090 ldr r1, [r4, #144] ; 0x90 10ce4: e1d420b0 ldrh r2, [r4] 10ce8: e0800006 add r0, r0, r6 10cec: eb002184 bl 19304 <memcpy>
sc = rtems_bdbuf_release_modified(bd);
10cf0: e59d0000 ldr r0, [sp] 10cf4: ebfff8fa bl f0e4 <rtems_bdbuf_release_modified>
if ( sc != RTEMS_SUCCESSFUL)
10cf8: e3500000 cmp r0, #0
10cfc: 0a000002 beq 10d0c <fat_buf_release+0x144>
rtems_set_errno_and_return_minus_one(ENOMEM);
10d00: eb001ed8 bl 18868 <__errno> <== NOT EXECUTED 10d04: e3a0300c mov r3, #12 <== NOT EXECUTED 10d08: ea00000b b 10d3c <fat_buf_release+0x174> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
uint8_t i;
for (i = 1; i < fs_info->vol.fats; i++)
10d0c: e2855001 add r5, r5, #1 10d10: e20550ff and r5, r5, #255 ; 0xff 10d14: e5d4300d ldrb r3, [r4, #13] 10d18: e1530005 cmp r3, r5
10d1c: 8affffd6 bhi 10c7c <fat_buf_release+0xb4>
10d20: ea000008 b 10d48 <fat_buf_release+0x180>
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
10d24: e594008c ldr r0, [r4, #140] ; 0x8c 10d28: ebfff8bf bl f02c <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL)
10d2c: e3500000 cmp r0, #0
10d30: 0a000004 beq 10d48 <fat_buf_release+0x180>
rtems_set_errno_and_return_minus_one(EIO);
10d34: eb001ecb bl 18868 <__errno> <== NOT EXECUTED 10d38: e3a03005 mov r3, #5 <== NOT EXECUTED 10d3c: e5803000 str r3, [r0] <== NOT EXECUTED 10d40: e3e00000 mvn r0, #0 <== NOT EXECUTED 10d44: ea000001 b 10d50 <fat_buf_release+0x188> <== NOT EXECUTED
}
fs_info->c.state = FAT_CACHE_EMPTY;
10d48: e3a00000 mov r0, #0 10d4c: e5c40089 strb r0, [r4, #137] ; 0x89
return RC_OK;
}
10d50: e8bd8078 pop {r3, r4, r5, r6, pc}
000104f0 <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)
104f0: e5913008 ldr r3, [r1, #8] 104f4: e3530001 cmp r3, #1
int
fat_file_close(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
104f8: e92d4070 push {r4, r5, r6, lr}
104fc: e1a05000 mov r5, r0
10500: e1a04001 mov r4, r1
/*
* 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)
10504: 9a000003 bls 10518 <fat_file_close+0x28>
{
fat_fd->links_num--;
10508: e2433001 sub r3, r3, #1 1050c: e5813008 str r3, [r1, #8]
return rc;
10510: e3a00000 mov r0, #0
10514: e8bd8070 pop {r4, r5, r6, pc}
}
key = fat_construct_key(fs_info, &fat_fd->dir_pos.sname);
if (fat_fd->flags & FAT_FILE_REMOVED)
10518: e5d16030 ldrb r6, [r1, #48] ; 0x30 1051c: e2166001 ands r6, r6, #1
10520: 0a00000e beq 10560 <fat_file_close+0x70>
{
rc = fat_file_truncate(fs_info, fat_fd, 0);
10524: e3a02000 mov r2, #0 10528: ebffffb4 bl 10400 <fat_file_truncate>
if ( rc != RC_OK )
1052c: e3500000 cmp r0, #0
10530: 18bd8070 popne {r4, r5, r6, pc}
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10534: e1a00004 mov r0, r4 10538: eb000d8a bl 13b68 <_Chain_Extract>
return rc;
_hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);
if ( fat_ino_is_unique(fs_info, fat_fd->ino) )
1053c: e1a00005 mov r0, r5 10540: e594100c ldr r1, [r4, #12] 10544: eb00054c bl 11a7c <fat_ino_is_unique> 10548: e3500000 cmp r0, #0
1054c: 0a00000a beq 1057c <fat_file_close+0x8c>
fat_free_unique_ino(fs_info, fat_fd->ino);
10550: e1a00005 mov r0, r5 <== NOT EXECUTED 10554: e594100c ldr r1, [r4, #12] <== NOT EXECUTED 10558: eb00053e bl 11a58 <fat_free_unique_ino> <== NOT EXECUTED 1055c: ea000006 b 1057c <fat_file_close+0x8c> <== NOT EXECUTED
free(fat_fd);
}
else
{
if (fat_ino_is_unique(fs_info, fat_fd->ino))
10560: e591100c ldr r1, [r1, #12] 10564: eb000544 bl 11a7c <fat_ino_is_unique> 10568: e3500000 cmp r0, #0
{
fat_fd->links_num = 0;
1056c: 15846008 strne r6, [r4, #8]
free(fat_fd);
}
else
{
if (fat_ino_is_unique(fs_info, fat_fd->ino))
10570: 1a000003 bne 10584 <fat_file_close+0x94>
10574: e1a00004 mov r0, r4 10578: eb000d7a bl 13b68 <_Chain_Extract>
fat_fd->links_num = 0;
}
else
{
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
free(fat_fd);
1057c: e1a00004 mov r0, r4 10580: ebffcea5 bl 401c <free>
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
10584: e1a00005 mov r0, r5
return rc;
}
10588: e8bd4070 pop {r4, r5, r6, lr}
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
1058c: ea00018d b 10bc8 <fat_buf_release>
00010644 <fat_file_extend>:
fat_file_fd_t *fat_fd,
bool zero_fill,
uint32_t new_length,
uint32_t *a_length
)
{
10644: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
10648: e24dd01c sub sp, sp, #28
1064c: e1a07003 mov r7, r3
uint32_t last_cl = 0;
uint32_t bytes_remain = 0;
uint32_t cls_added;
ssize_t bytes_written;
*a_length = new_length;
10650: e59d3040 ldr r3, [sp, #64] ; 0x40 10654: e5837000 str r7, [r3]
if (new_length <= fat_fd->fat_file_size)
10658: e5913018 ldr r3, [r1, #24]
uint32_t new_length,
uint32_t *a_length
)
{
int rc = RC_OK;
uint32_t chain = 0;
1065c: e3a06000 mov r6, #0
uint32_t cls_added;
ssize_t bytes_written;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
10660: e1570003 cmp r7, r3
fat_file_fd_t *fat_fd,
bool zero_fill,
uint32_t new_length,
uint32_t *a_length
)
{
10664: e1a04000 mov r4, r0 10668: e1a05001 mov r5, r1 1066c: e202b0ff and fp, r2, #255 ; 0xff
int rc = RC_OK;
uint32_t chain = 0;
10670: e58d6008 str r6, [sp, #8]
uint32_t bytes2add = 0;
uint32_t cls2add = 0;
uint32_t old_last_cl;
uint32_t last_cl = 0;
10674: e58d6010 str r6, [sp, #16]
uint32_t cls_added;
ssize_t bytes_written;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
10678: 9a000078 bls 10860 <fat_file_extend+0x21c>
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
1067c: e5912020 ldr r2, [r1, #32] 10680: e3520001 cmp r2, #1
10684: 1a000005 bne 106a0 <fat_file_extend+0x5c>
10688: e5912024 ldr r2, [r1, #36] ; 0x24 1068c: e1520006 cmp r2, r6
10690: 1a000002 bne 106a0 <fat_file_extend+0x5c>
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
10694: e5d0200e ldrb r2, [r0, #14]
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
10698: e3120003 tst r2, #3
1069c: 1a00002f bne 10760 <fat_file_extend+0x11c>
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
106a0: e1d480b6 ldrh r8, [r4, #6]
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
106a4: e2482001 sub r2, r8, #1 106a8: e0029003 and r9, r2, r3
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 -
106ac: e0698008 rsb r8, r9, r8
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
106b0: e063a007 rsb sl, r3, r7
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 -
106b4: e0088002 and r8, r8, r2
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
if (bytes2add > bytes_remain)
106b8: e15a0008 cmp sl, r8
bytes2add -= bytes_remain;
106bc: 8068a00a rsbhi sl, r8, sl
else
bytes2add = 0;
106c0: 93a0a000 movls sl, #0
if (zero_fill && bytes_remain > 0) {
106c4: e35b0000 cmp fp, #0
106c8: 0a000011 beq 10714 <fat_file_extend+0xd0>
106cc: e3580000 cmp r8, #0
106d0: 0a00000f beq 10714 <fat_file_extend+0xd0>
uint32_t start = fat_fd->fat_file_size;
uint32_t cl_start = start >> fs_info->vol.bpc_log2;
106d4: e5d42008 ldrb r2, [r4, #8]
uint32_t ofs = start & (fs_info->vol.bpc - 1);
uint32_t cur_cln;
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
106d8: e1a00004 mov r0, r4 106dc: e1a02233 lsr r2, r3, r2 106e0: e1a01005 mov r1, r5 106e4: e28d3018 add r3, sp, #24 106e8: ebfffe63 bl 1007c <fat_file_lseek>
if (rc != RC_OK)
106ec: e2506000 subs r6, r0, #0
106f0: 1a00005a bne 10860 <fat_file_extend+0x21c>
return rc;
bytes_written = fat_cluster_set (fs_info, cur_cln, ofs, bytes_remain, 0);
106f4: e1a00004 mov r0, r4 106f8: e59d1018 ldr r1, [sp, #24] 106fc: e1a02009 mov r2, r9 10700: e1a03008 mov r3, r8 10704: e58d6000 str r6, [sp] 10708: eb000206 bl 10f28 <fat_cluster_set>
if (bytes_remain != bytes_written)
1070c: e1580000 cmp r8, r0
10710: 1a000051 bne 1085c <fat_file_extend+0x218>
/*
* 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)
10714: e35a0000 cmp sl, #0
return RC_OK;
10718: 01a0600a moveq r6, sl
/*
* 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)
1071c: 0a00004f beq 10860 <fat_file_extend+0x21c>
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
10720: e5d43008 ldrb r3, [r4, #8] 10724: e24a9001 sub r9, sl, #1 10728: e1a09339 lsr r9, r9, r3
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
1072c: e28d3010 add r3, sp, #16
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
10730: e2899001 add r9, r9, #1
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
10734: e88d0808 stm sp, {r3, fp}
10738: e1a00004 mov r0, r4
1073c: e28d1008 add r1, sp, #8
10740: e1a02009 mov r2, r9
10744: e28d3014 add r3, sp, #20
10748: eb0019cd bl 16e84 <fat_scan_fat_for_free_clusters>
&cls_added, &last_cl, zero_fill);
/* this means that low level I/O error occured */
if (rc != RC_OK)
1074c: e2506000 subs r6, r0, #0
10750: 1a000042 bne 10860 <fat_file_extend+0x21c>
return rc;
/* this means that no space left on device */
if ((cls_added == 0) && (bytes_remain == 0))
10754: e59d3014 ldr r3, [sp, #20] 10758: e1988003 orrs r8, r8, r3
1075c: 1a000003 bne 10770 <fat_file_extend+0x12c>
rtems_set_errno_and_return_minus_one(ENOSPC);
10760: eb002040 bl 18868 <__errno> 10764: e3a0301c mov r3, #28 10768: e5803000 str r3, [r0] 1076c: ea00003a b 1085c <fat_file_extend+0x218>
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
10770: e1590003 cmp r9, r3
10774: 0a000006 beq 10794 <fat_file_extend+0x150>
{
new_length -= bytes2add & (fs_info->vol.bpc - 1);
10778: e1d420b6 ldrh r2, [r4, #6] <== NOT EXECUTED 1077c: e2422001 sub r2, r2, #1 <== NOT EXECUTED 10780: e00aa002 and sl, sl, r2 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
10784: e5d42008 ldrb r2, [r4, #8] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
{
new_length -= bytes2add & (fs_info->vol.bpc - 1);
10788: e06a7007 rsb r7, sl, r7 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
1078c: e0639009 rsb r9, r3, r9 <== NOT EXECUTED 10790: e0477219 sub r7, r7, r9, lsl r2 <== NOT EXECUTED
}
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
10794: e5953018 ldr r3, [r5, #24] 10798: e3530000 cmp r3, #0
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
1079c: 059d2008 ldreq r2, [sp, #8]
fat_fd->map.file_cln = 0;
107a0: 05853034 streq r3, [r5, #52] ; 0x34
}
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
107a4: 0585201c streq r2, [r5, #28] 107a8: 05852038 streq r2, [r5, #56] ; 0x38
107ac: 0a000014 beq 10804 <fat_file_extend+0x1c0>
fat_fd->map.file_cln = 0;
}
else
{
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
107b0: e595203c ldr r2, [r5, #60] ; 0x3c 107b4: e3720001 cmn r2, #1
{
old_last_cl = fat_fd->map.last_cln;
107b8: 158d200c strne r2, [sp, #12]
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)
107bc: 1a000008 bne 107e4 <fat_file_extend+0x1a0>
{
old_last_cl = fat_fd->map.last_cln;
}
else
{
rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM,
107c0: e28d200c add r2, sp, #12 <== NOT EXECUTED 107c4: e58d2000 str r2, [sp] <== NOT EXECUTED 107c8: e1a00004 mov r0, r4 <== NOT EXECUTED 107cc: e1a01005 mov r1, r5 <== NOT EXECUTED 107d0: e3a02001 mov r2, #1 <== NOT EXECUTED 107d4: e2433001 sub r3, r3, #1 <== NOT EXECUTED 107d8: ebffff6c bl 10590 <fat_file_ioctl> <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
107dc: e2508000 subs r8, r0, #0 <== NOT EXECUTED 107e0: 1a000014 bne 10838 <fat_file_extend+0x1f4> <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, chain);
return rc;
}
}
rc = fat_set_fat_cluster(fs_info, old_last_cl, chain);
107e4: e1a00004 mov r0, r4 107e8: e59d100c ldr r1, [sp, #12] 107ec: e59d2008 ldr r2, [sp, #8] 107f0: eb0018f4 bl 16bc8 <fat_set_fat_cluster>
if ( rc != RC_OK )
107f4: e2508000 subs r8, r0, #0
{
fat_free_fat_clusters_chain(fs_info, chain);
107f8: e1a00004 mov r0, r4
return rc;
}
}
rc = fat_set_fat_cluster(fs_info, old_last_cl, chain);
if ( rc != RC_OK )
107fc: 1a00000e bne 1083c <fat_file_extend+0x1f8>
{
fat_free_fat_clusters_chain(fs_info, chain);
return rc;
}
fat_buf_release(fs_info);
10800: eb0000f0 bl 10bc8 <fat_buf_release>
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
10804: e59d3014 ldr r3, [sp, #20] 10808: e3530000 cmp r3, #0
1080c: 0a00000e beq 1084c <fat_file_extend+0x208>
{
fat_fd->map.last_cln = last_cl;
10810: e59d3010 ldr r3, [sp, #16] 10814: e585303c str r3, [r5, #60] ; 0x3c
if (fat_fd->fat_file_type == FAT_DIRECTORY)
10818: e5953010 ldr r3, [r5, #16] 1081c: e3530000 cmp r3, #0
10820: 1a000009 bne 1084c <fat_file_extend+0x208>
{
rc = fat_init_clusters_chain(fs_info, chain);
10824: e1a00004 mov r0, r4 10828: e59d1008 ldr r1, [sp, #8] 1082c: eb00043e bl 1192c <fat_init_clusters_chain>
if ( rc != RC_OK )
10830: e2508000 subs r8, r0, #0
10834: 0a000004 beq 1084c <fat_file_extend+0x208>
{
fat_free_fat_clusters_chain(fs_info, chain);
10838: e1a00004 mov r0, r4 <== NOT EXECUTED 1083c: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 10840: eb001962 bl 16dd0 <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
10844: e1a06008 mov r6, r8 <== NOT EXECUTED 10848: ea000004 b 10860 <fat_file_extend+0x21c> <== NOT EXECUTED
}
}
}
*a_length = new_length;
1084c: e59d3040 ldr r3, [sp, #64] ; 0x40 10850: e5837000 str r7, [r3]
fat_fd->fat_file_size = new_length;
10854: e5857018 str r7, [r5, #24]
return RC_OK;
10858: ea000000 b 10860 <fat_file_extend+0x21c>
if (rc != RC_OK)
return rc;
bytes_written = fat_cluster_set (fs_info, cur_cln, ofs, bytes_remain, 0);
if (bytes_remain != bytes_written)
return -1;
1085c: e3e06000 mvn r6, #0
*a_length = new_length;
fat_fd->fat_file_size = new_length;
return RC_OK;
}
10860: e1a00006 mov r0, r6
10864: e28dd01c add sp, sp, #28
10868: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00010590 <fat_file_ioctl>:
fat_file_ioctl(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
10590: e92d000c push {r2, r3}
10594: e92d4013 push {r0, r1, r4, lr}
int rc = RC_OK;
uint32_t cur_cln = 0;
10598: e3a03000 mov r3, #0 1059c: e58d3000 str r3, [sp]
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
105a0: e59d3010 ldr r3, [sp, #16]
uint32_t cl_start = 0;
uint32_t pos = 0;
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
105a4: e28d2014 add r2, sp, #20
switch (cmd)
105a8: e3530001 cmp r3, #1
uint32_t cl_start = 0;
uint32_t pos = 0;
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
105ac: e58d2004 str r2, [sp, #4]
switch (cmd)
105b0: 1a00001c bne 10628 <fat_file_ioctl+0x98>
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
105b4: e1a0c002 mov ip, r2 105b8: e49c3008 ldr r3, [ip], #8
ret = va_arg(ap, uint32_t *);
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
105bc: e5912018 ldr r2, [r1, #24] 105c0: e1530002 cmp r3, r2
switch (cmd)
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
ret = va_arg(ap, uint32_t *);
105c4: e58dc004 str ip, [sp, #4] 105c8: e59d4018 ldr r4, [sp, #24]
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
105cc: 3a000002 bcc 105dc <fat_file_ioctl+0x4c>
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
105d0: eb0020a4 bl 18868 <__errno> <== NOT EXECUTED 105d4: e3a03005 mov r3, #5 <== NOT EXECUTED 105d8: ea000014 b 10630 <fat_file_ioctl+0xa0> <== NOT EXECUTED
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
105dc: e5912020 ldr r2, [r1, #32] 105e0: e3520001 cmp r2, #1
105e4: 1a000007 bne 10608 <fat_file_ioctl+0x78>
105e8: e5912024 ldr r2, [r1, #36] ; 0x24 105ec: e3520000 cmp r2, #0
105f0: 1a000004 bne 10608 <fat_file_ioctl+0x78>
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
105f4: e5d0c00e ldrb ip, [r0, #14]
if ( pos >= fat_fd->fat_file_size ) {
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
105f8: e31c0003 tst ip, #3
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
/* cluster 0 (zero) reserved for root dir */
*ret = 0;
105fc: 15842000 strne r2, [r4]
rc = RC_OK;
10600: 11a00002 movne r0, r2
if ( pos >= fat_fd->fat_file_size ) {
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
10604: 1a00000b bne 10638 <fat_file_ioctl+0xa8>
*ret = 0;
rc = RC_OK;
break;
}
cl_start = pos >> fs_info->vol.bpc_log2;
10608: e5d02008 ldrb r2, [r0, #8]
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
1060c: e1a02233 lsr r2, r3, r2 10610: e1a0300d mov r3, sp 10614: ebfffe98 bl 1007c <fat_file_lseek>
if ( rc != RC_OK )
10618: e3500000 cmp r0, #0
break;
*ret = cur_cln;
1061c: 059d3000 ldreq r3, [sp] 10620: 05843000 streq r3, [r4] 10624: ea000003 b 10638 <fat_file_ioctl+0xa8>
break;
default:
errno = EINVAL;
10628: eb00208e bl 18868 <__errno> <== NOT EXECUTED 1062c: e3a03016 mov r3, #22 <== NOT EXECUTED 10630: e5803000 str r3, [r0] <== NOT EXECUTED
rc = -1;
10634: e3e00000 mvn r0, #0 <== NOT EXECUTED
break;
}
va_end(ap);
return rc;
}
10638: e8bd401c pop {r2, r3, r4, lr}
1063c: e28dd008 add sp, sp, #8
10640: e12fff1e bx lr
00010108 <fat_file_open>:
fat_file_open(
fat_fs_info_t *fs_info,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
10108: e92d47f3 push {r0, r1, r4, r5, r6, r7, r8, r9, sl, lr}
int rc = RC_OK;
fat_file_fd_t *lfat_fd = NULL;
1010c: e3a07000 mov r7, #0 10110: e28d4008 add r4, sp, #8 10114: e5247004 str r7, [r4, #-4]!
fat_file_open(
fat_fs_info_t *fs_info,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
10118: e1a05000 mov r5, r0 1011c: e1a09001 mov r9, r1 10120: e1a08002 mov r8, r2
int rc = RC_OK;
fat_file_fd_t *lfat_fd = NULL;
uint32_t key = 0;
/* construct key */
key = fat_construct_key(fs_info, &dir_pos->sname);
10124: ebffffa7 bl ffc8 <fat_construct_key> 10128: e1a06000 mov r6, r0
/* access "valid" hash table */
rc = _hash_search(fs_info, fs_info->vhash, key, 0, &lfat_fd);
1012c: e595106c ldr r1, [r5, #108] ; 0x6c 10130: e1a00005 mov r0, r5 10134: e1a02006 mov r2, r6 10138: e1a03007 mov r3, r7 1013c: e58d4000 str r4, [sp] 10140: ebffffaf bl 10004 <_hash_search>
if ( rc == RC_OK )
10144: e3500000 cmp r0, #0
10148: 1a000005 bne 10164 <fat_file_open+0x5c>
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
1014c: e59d3004 ldr r3, [sp, #4]
lfat_fd->links_num++;
10150: e5932008 ldr r2, [r3, #8] 10154: e2822001 add r2, r2, #1
/* access "valid" hash table */
rc = _hash_search(fs_info, fs_info->vhash, key, 0, &lfat_fd);
if ( rc == RC_OK )
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
10158: e5883000 str r3, [r8]
lfat_fd->links_num++;
1015c: e5832008 str r2, [r3, #8]
return rc;
10160: ea000037 b 10244 <fat_file_open+0x13c>
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(fs_info, fs_info->rhash, key, key, &lfat_fd);
10164: e5951070 ldr r1, [r5, #112] ; 0x70 10168: e1a02006 mov r2, r6 1016c: e1a03006 mov r3, r6 10170: e1a00005 mov r0, r5 10174: e58d4000 str r4, [sp] 10178: ebffffa1 bl 10004 <_hash_search> 1017c: e1a0a000 mov sl, r0
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
10180: e3a00044 mov r0, #68 ; 0x44 10184: ebffd0d9 bl 44f0 <malloc>
if ( lfat_fd == NULL )
10188: e3500000 cmp r0, #0
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(fs_info, fs_info->rhash, key, key, &lfat_fd);
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
1018c: e1a04000 mov r4, r0 10190: e5880000 str r0, [r8] 10194: e58d0004 str r0, [sp, #4]
if ( lfat_fd == NULL )
10198: 1a000004 bne 101b0 <fat_file_open+0xa8>
rtems_set_errno_and_return_minus_one( ENOMEM );
1019c: eb0021b1 bl 18868 <__errno> <== NOT EXECUTED 101a0: e3a0300c mov r3, #12 <== NOT EXECUTED 101a4: e5803000 str r3, [r0] <== NOT EXECUTED 101a8: e3e00000 mvn r0, #0 <== NOT EXECUTED 101ac: ea000024 b 10244 <fat_file_open+0x13c> <== NOT EXECUTED
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
101b0: e1a01007 mov r1, r7 101b4: e3a02044 mov r2, #68 ; 0x44 101b8: eb002487 bl 193dc <memset>
lfat_fd->links_num = 1;
101bc: e3a03001 mov r3, #1 101c0: e5843008 str r3, [r4, #8]
lfat_fd->flags &= ~FAT_FILE_REMOVED;
101c4: e5d43030 ldrb r3, [r4, #48] ; 0x30
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
101c8: e3e07000 mvn r7, #0
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;
101cc: e3c33001 bic r3, r3, #1 101d0: e5c43030 strb r3, [r4, #48] ; 0x30
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
101d4: e584703c str r7, [r4, #60] ; 0x3c
lfat_fd->dir_pos = *dir_pos;
101d8: e899000f ldm r9, {r0, r1, r2, r3}
101dc: e284c020 add ip, r4, #32
if ( rc != RC_OK )
101e0: e35a0000 cmp sl, #0
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
101e4: e88c000f stm ip, {r0, r1, r2, r3}
if ( rc != RC_OK )
lfat_fd->ino = key;
101e8: 1584600c strne r6, [r4, #12]
lfat_fd->flags &= ~FAT_FILE_REMOVED;
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
if ( rc != RC_OK )
101ec: 1a00000d bne 10228 <fat_file_open+0x120>
lfat_fd->ino = key;
else
{
lfat_fd->ino = fat_get_unique_ino(fs_info);
101f0: e1a00005 mov r0, r5 <== NOT EXECUTED 101f4: eb0005ea bl 119a4 <fat_get_unique_ino> <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
101f8: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
if ( rc != RC_OK )
lfat_fd->ino = key;
else
{
lfat_fd->ino = fat_get_unique_ino(fs_info);
101fc: e584000c str r0, [r4, #12] <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
10200: e593300c ldr r3, [r3, #12] <== NOT EXECUTED 10204: e3530000 cmp r3, #0 <== NOT EXECUTED 10208: 1a000006 bne 10228 <fat_file_open+0x120> <== NOT EXECUTED
{
free((*fat_fd));
1020c: e5980000 ldr r0, [r8] <== NOT EXECUTED 10210: ebffcf81 bl 401c <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 );
10214: eb002193 bl 18868 <__errno> <== NOT EXECUTED 10218: e3a0300c mov r3, #12 <== NOT EXECUTED 1021c: e5803000 str r3, [r0] <== NOT EXECUTED 10220: e1a00007 mov r0, r7 <== NOT EXECUTED 10224: ea000006 b 10244 <fat_file_open+0x13c> <== NOT EXECUTED
*/
static inline void
_hash_insert(rtems_chain_control *hash, uint32_t key1, uint32_t key2,
fat_file_fd_t *el)
{
rtems_chain_append((hash) + ((key1) % FAT_HASH_MODULE), &(el)->link);
10228: e595306c ldr r3, [r5, #108] ; 0x6c 1022c: e2066001 and r6, r6, #1
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
10230: e3a0000c mov r0, #12 10234: e0203096 mla r0, r6, r0, r3 10238: e59d1004 ldr r1, [sp, #4] 1023c: ebffe22a bl 8aec <_Chain_Append>
/*
* other fields of fat-file descriptor will be initialized on upper
* level
*/
return RC_OK;
10240: e3a00000 mov r0, #0
}
10244: e8bd87fc pop {r2, r3, r4, r5, r6, r7, r8, r9, sl, pc}
0001025c <fat_file_read>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
1025c: e92d4fff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, lr}
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
10260: e3a0a000 mov sl, #0
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)
10264: e2535000 subs r5, r3, #0
)
{
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
10268: e58da00c str sl, [sp, #12]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
1026c: e1a04000 mov r4, r0 10270: e1a06001 mov r6, r1 10274: e1a08002 mov r8, r2
uint32_t byte = 0;
uint32_t c = 0;
/* it couldn't be removed - otherwise cache update will be broken */
if (count == 0)
return cmpltd;
10278: 01a0a005 moveq sl, r5
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)
1027c: 0a00005c beq 103f4 <fat_file_read+0x198>
/*
* >= because start is offset and computed from 0 and file_size
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
10280: e5913018 ldr r3, [r1, #24] 10284: e1520003 cmp r2, r3
10288: 2a000059 bcs 103f4 <fat_file_read+0x198>
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
1028c: e1550003 cmp r5, r3
10290: 8a000002 bhi 102a0 <fat_file_read+0x44>
(start > fat_fd->fat_file_size - count))
10294: e0652003 rsb r2, r5, r3
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
10298: e1580002 cmp r8, r2
1029c: 9a000000 bls 102a4 <fat_file_read+0x48>
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
102a0: e0685003 rsb r5, r8, r3
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
102a4: e5963020 ldr r3, [r6, #32] 102a8: e3530001 cmp r3, #1
102ac: 1a000014 bne 10304 <fat_file_read+0xa8>
102b0: e5963024 ldr r3, [r6, #36] ; 0x24 102b4: e3530000 cmp r3, #0
102b8: 1a000011 bne 10304 <fat_file_read+0xa8>
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
102bc: e5d4300e ldrb r3, [r4, #14]
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)) &&
102c0: e3130003 tst r3, #3
102c4: 0a00000e beq 10304 <fat_file_read+0xa8>
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
102c8: e596101c ldr r1, [r6, #28] 102cc: e1a00004 mov r0, r4 102d0: ebffff31 bl ff9c <fat_cluster_num_to_sector_num>
sec += (start >> fs_info->vol.sec_log2);
102d4: e5d41002 ldrb r1, [r4, #2]
byte = start & (fs_info->vol.bps - 1);
102d8: e1d420b0 ldrh r2, [r4]
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
102dc: e0801138 add r1, r0, r8, lsr r1
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_read(fs_info, sec, byte, count, buf);
102e0: e59d0034 ldr r0, [sp, #52] ; 0x34
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
102e4: e2422001 sub r2, r2, #1
ret = _fat_block_read(fs_info, sec, byte, count, buf);
102e8: e58d0000 str r0, [sp] 102ec: e0082002 and r2, r8, r2 102f0: e1a00004 mov r0, r4 102f4: e1a03005 mov r3, r5 102f8: eb0002c0 bl 10e00 <_fat_block_read>
if ( ret < 0 )
return -1;
102fc: e180afc0 orr sl, r0, r0, asr #31 10300: ea00003b b 103f4 <fat_file_read+0x198>
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
10304: e5d43008 ldrb r3, [r4, #8] 10308: e1a03338 lsr r3, r8, r3
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
1030c: e28dc00c add ip, sp, #12
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
10310: e58d3008 str r3, [sp, #8]
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
10314: e1a02003 mov r2, r3 10318: e1a00004 mov r0, r4 1031c: e1a01006 mov r1, r6 10320: e1a0300c mov r3, ip
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
10324: e1d470b6 ldrh r7, [r4, #6]
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
10328: e58dc004 str ip, [sp, #4] 1032c: ebffff52 bl 1007c <fat_file_lseek>
if (rc != RC_OK)
10330: e250a000 subs sl, r0, #0
10334: 1a00002e bne 103f4 <fat_file_read+0x198>
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
10338: e2477001 sub r7, r7, #1 1033c: e0088007 and r8, r8, r7 10340: e1a0b008 mov fp, r8 10344: e1a0900a mov r9, sl 10348: ea00001c b 103c0 <fat_file_read+0x164>
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
1034c: e59d100c ldr r1, [sp, #12] 10350: e1a00004 mov r0, r4 10354: ebffff10 bl ff9c <fat_cluster_num_to_sector_num>
sec += (ofs >> fs_info->vol.sec_log2);
10358: e5d41002 ldrb r1, [r4, #2]
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
1035c: e1d470b6 ldrh r7, [r4, #6]
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
10360: e080113b add r1, r0, fp, lsr r1
byte = ofs & (fs_info->vol.bps - 1);
10364: e1d420b0 ldrh r2, [r4]
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
10368: e59d0034 ldr r0, [sp, #52] ; 0x34
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
1036c: e06b7007 rsb r7, fp, r7
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
10370: e080300a add r3, r0, sl
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
10374: e1570005 cmp r7, r5 10378: 21a07005 movcs r7, r5
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
1037c: e2422001 sub r2, r2, #1
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
10380: e58d3000 str r3, [sp] 10384: e1a00004 mov r0, r4 10388: e00b2002 and r2, fp, r2 1038c: e1a03007 mov r3, r7 10390: eb00029a bl 10e00 <_fat_block_read>
if ( ret < 0 )
10394: e3500000 cmp r0, #0
10398: ba000012 blt 103e8 <fat_file_read+0x18c>
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
1039c: e59d900c ldr r9, [sp, #12]
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
103a0: e1a00004 mov r0, r4 103a4: e1a01009 mov r1, r9 103a8: e28d200c add r2, sp, #12 103ac: eb0019b1 bl 16a78 <fat_get_fat_cluster>
if ( rc != RC_OK )
103b0: e250b000 subs fp, r0, #0
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
103b4: e0675005 rsb r5, r7, r5
cmpltd += c;
103b8: e08aa007 add sl, sl, r7
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
if ( rc != RC_OK )
103bc: 1a00000b bne 103f0 <fat_file_read+0x194>
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
103c0: e3550000 cmp r5, #0
103c4: 1affffe0 bne 1034c <fat_file_read+0xf0>
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
103c8: e5d43008 ldrb r3, [r4, #8] 103cc: e2488001 sub r8, r8, #1
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
103d0: e59d2008 ldr r2, [sp, #8]
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
103d4: e088800a add r8, r8, sl
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
103d8: e0828338 add r8, r2, r8, lsr r3
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
103dc: e5869038 str r9, [r6, #56] ; 0x38
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
103e0: e5868034 str r8, [r6, #52] ; 0x34
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
103e4: ea000002 b 103f4 <fat_file_read+0x198>
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
103e8: e3e0a000 mvn sl, #0 <== NOT EXECUTED 103ec: ea000000 b 103f4 <fat_file_read+0x198> <== NOT EXECUTED
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
103f0: e1a0a00b mov sl, fp <== NOT EXECUTED
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
}
103f4: e1a0000a mov r0, sl
103f8: e28dd010 add sp, sp, #16
103fc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0001086c <fat_file_write>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
1086c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
ssize_t ret;
uint32_t cmpltd = 0;
uint32_t byte;
uint32_t c = 0;
bool zero_fill = start > fat_fd->fat_file_size;
uint32_t file_cln_initial = fat_fd->map.file_cln;
10870: e591c034 ldr ip, [r1, #52] ; 0x34
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
10874: e24dd020 sub sp, sp, #32 10878: e1a08002 mov r8, r2
bool zero_fill = start > fat_fd->fat_file_size;
uint32_t file_cln_initial = fat_fd->map.file_cln;
uint32_t cln;
if ( count == 0 )
1087c: e3530000 cmp r3, #0
{
int rc = RC_OK;
ssize_t ret;
uint32_t cmpltd = 0;
uint32_t byte;
uint32_t c = 0;
10880: e3a02000 mov r2, #0
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
10884: e1a05000 mov r5, r0
int rc = RC_OK;
ssize_t ret;
uint32_t cmpltd = 0;
uint32_t byte;
uint32_t c = 0;
10888: e58d2018 str r2, [sp, #24]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
1088c: e1a04001 mov r4, r1
int rc = RC_OK;
ssize_t ret;
uint32_t cmpltd = 0;
uint32_t byte;
uint32_t c = 0;
bool zero_fill = start > fat_fd->fat_file_size;
10890: e5912018 ldr r2, [r1, #24]
uint32_t file_cln_initial = fat_fd->map.file_cln;
10894: e58dc010 str ip, [sp, #16]
uint32_t cln;
if ( count == 0 )
return cmpltd;
10898: 01a00003 moveq r0, r3
bool zero_fill = start > fat_fd->fat_file_size;
uint32_t file_cln_initial = fat_fd->map.file_cln;
uint32_t cln;
if ( count == 0 )
1089c: 0a00006b beq 10a50 <fat_file_write+0x1e4>
return cmpltd;
if (start >= fat_fd->size_limit)
108a0: e5916014 ldr r6, [r1, #20] 108a4: e1580006 cmp r8, r6
108a8: 3a000003 bcc 108bc <fat_file_write+0x50>
rtems_set_errno_and_return_minus_one(EFBIG);
108ac: eb001fed bl 18868 <__errno> <== NOT EXECUTED 108b0: e3a0301b mov r3, #27 <== NOT EXECUTED 108b4: e5803000 str r3, [r0] <== NOT EXECUTED 108b8: ea000063 b 10a4c <fat_file_write+0x1e0> <== NOT EXECUTED
if (count > fat_fd->size_limit - start)
108bc: e0686006 rsb r6, r8, r6
if ( count == 0 )
return cmpltd;
if (start >= fat_fd->size_limit)
rtems_set_errno_and_return_minus_one(EFBIG);
108c0: e1560003 cmp r6, r3 108c4: 21a06003 movcs r6, r3
if (count > fat_fd->size_limit - start)
count = fat_fd->size_limit - start;
rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c);
108c8: e0867008 add r7, r6, r8 108cc: e1580002 cmp r8, r2 108d0: e28d3018 add r3, sp, #24 108d4: e58d3000 str r3, [sp] 108d8: 93a02000 movls r2, #0 108dc: 83a02001 movhi r2, #1 108e0: e1a03007 mov r3, r7 108e4: ebffff56 bl 10644 <fat_file_extend>
if (RC_OK == rc)
108e8: e3500000 cmp r0, #0
108ec: 1a000057 bne 10a50 <fat_file_write+0x1e4>
{
/*
* check whether there was enough room on device to locate
* file of 'start + count' bytes
*/
if (c != (start + count))
108f0: e59d3018 ldr r3, [sp, #24]
*/
static bool
fat_is_fat12_or_fat16_root_dir (const fat_file_fd_t *fat_fd,
const uint8_t volume_type)
{
return (FAT_FD_OF_ROOT_DIR(fat_fd)) && (volume_type & (FAT_FAT12 | FAT_FAT16));
108f4: e5942020 ldr r2, [r4, #32]
{
/*
* check whether there was enough room on device to locate
* file of 'start + count' bytes
*/
if (c != (start + count))
108f8: e1530007 cmp r3, r7
count = c - start;
108fc: 10686003 rsbne r6, r8, r3
*/
static bool
fat_is_fat12_or_fat16_root_dir (const fat_file_fd_t *fat_fd,
const uint8_t volume_type)
{
return (FAT_FD_OF_ROOT_DIR(fat_fd)) && (volume_type & (FAT_FAT12 | FAT_FAT16));
10900: e3520001 cmp r2, #1
*/
if (c != (start + count))
count = c - start;
/* for the root directory of FAT12 and FAT16 we need this special handling */
if (fat_is_fat12_or_fat16_root_dir(fat_fd, fs_info->vol.type))
10904: e5d5300e ldrb r3, [r5, #14]
*/
static bool
fat_is_fat12_or_fat16_root_dir (const fat_file_fd_t *fat_fd,
const uint8_t volume_type)
{
return (FAT_FD_OF_ROOT_DIR(fat_fd)) && (volume_type & (FAT_FAT12 | FAT_FAT16));
10908: 1a000052 bne 10a58 <fat_file_write+0x1ec>
1090c: e5940024 ldr r0, [r4, #36] ; 0x24 10910: e3500000 cmp r0, #0
10914: 1a00004f bne 10a58 <fat_file_write+0x1ec>
10918: e3130003 tst r3, #3
1091c: 0a00004d beq 10a58 <fat_file_write+0x1ec>
/* for the root directory of FAT12 and FAT16 we need this special handling */
if (fat_is_fat12_or_fat16_root_dir(fat_fd, fs_info->vol.type))
{
cln = fat_fd->cln;
cln += (start >> fs_info->vol.bpc_log2);
byte = start & (fs_info->vol.bpc -1);
10920: e1d520b6 ldrh r2, [r5, #6]
count = c - start;
/* for the root directory of FAT12 and FAT16 we need this special handling */
if (fat_is_fat12_or_fat16_root_dir(fat_fd, fs_info->vol.type))
{
cln = fat_fd->cln;
10924: e594301c ldr r3, [r4, #28]
cln += (start >> fs_info->vol.bpc_log2);
10928: e5d51008 ldrb r1, [r5, #8]
byte = start & (fs_info->vol.bpc -1);
ret = fat_cluster_write(fs_info,
1092c: e59dc044 ldr ip, [sp, #68] ; 0x44
/* for the root directory of FAT12 and FAT16 we need this special handling */
if (fat_is_fat12_or_fat16_root_dir(fat_fd, fs_info->vol.type))
{
cln = fat_fd->cln;
cln += (start >> fs_info->vol.bpc_log2);
byte = start & (fs_info->vol.bpc -1);
10930: e2422001 sub r2, r2, #1
ret = fat_cluster_write(fs_info,
10934: e58d0004 str r0, [sp, #4] 10938: e0831138 add r1, r3, r8, lsr r1 1093c: e1a00005 mov r0, r5 10940: e0082002 and r2, r8, r2 10944: e1a03006 mov r3, r6 10948: e58dc000 str ip, [sp] 1094c: eb0001b3 bl 11020 <fat_cluster_write>
cln,
byte,
count,
buf,
false);
if (0 > ret)
10950: e3500000 cmp r0, #0 10954: ea00003b b 10a48 <fat_file_write+0x1dc>
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
uint32_t ofs_cln = start - (start_cln << fs_info->vol.bpc_log2);
10958: e59dc008 ldr ip, [sp, #8] 1095c: e048871c sub r8, r8, ip, lsl r7
bool overwrite_cluster = false;
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
if (RC_OK == rc)
{
file_cln_cnt = cur_cln - fat_fd->cln;
10960: e594301c ldr r3, [r4, #28]
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
uint32_t ofs_cln = start - (start_cln << fs_info->vol.bpc_log2);
10964: e58d800c str r8, [sp, #12]
bool overwrite_cluster = false;
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
if (RC_OK == rc)
{
file_cln_cnt = cur_cln - fat_fd->cln;
10968: e59d801c ldr r8, [sp, #28] 1096c: e58d4014 str r4, [sp, #20] 10970: e0638008 rsb r8, r3, r8
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
uint32_t ofs_cln = start - (start_cln << fs_info->vol.bpc_log2);
10974: e59d700c ldr r7, [sp, #12]
uint32_t ofs_cln_save = ofs_cln;
uint32_t bytes_to_write = count;
uint32_t file_cln_cnt;
ssize_t ret;
uint32_t c;
bool overwrite_cluster = false;
10978: e1a0b000 mov fp, r0
const uint32_t count,
const uint8_t *buf,
const uint32_t file_cln_initial)
{
int rc = RC_OK;
uint32_t cmpltd = 0;
1097c: e1a0a000 mov sl, r0 10980: e1a04000 mov r4, r0 10984: ea00001c b 109fc <fat_file_write+0x190>
&& (bytes_to_write > 0))
{
c = MIN(bytes_to_write, (fs_info->vol.bpc - ofs_cln));
if (file_cln_initial < file_cln_cnt)
overwrite_cluster = true;
10988: e59dc010 ldr ip, [sp, #16]
{
file_cln_cnt = cur_cln - fat_fd->cln;
while ( (RC_OK == rc)
&& (bytes_to_write > 0))
{
c = MIN(bytes_to_write, (fs_info->vol.bpc - ofs_cln));
1098c: e1d530b6 ldrh r3, [r5, #6]
if (file_cln_initial < file_cln_cnt)
overwrite_cluster = true;
10990: e15c0008 cmp ip, r8
ret = fat_cluster_write(fs_info,
10994: e59dc044 ldr ip, [sp, #68] ; 0x44
&& (bytes_to_write > 0))
{
c = MIN(bytes_to_write, (fs_info->vol.bpc - ofs_cln));
if (file_cln_initial < file_cln_cnt)
overwrite_cluster = true;
10998: 33a0b001 movcc fp, #1
ret = fat_cluster_write(fs_info,
1099c: e08c200a add r2, ip, sl
{
file_cln_cnt = cur_cln - fat_fd->cln;
while ( (RC_OK == rc)
&& (bytes_to_write > 0))
{
c = MIN(bytes_to_write, (fs_info->vol.bpc - ofs_cln));
109a0: e0673003 rsb r3, r7, r3
if (file_cln_initial < file_cln_cnt)
overwrite_cluster = true;
ret = fat_cluster_write(fs_info,
109a4: e88d0804 stm sp, {r2, fp}
109a8: e1530006 cmp r3, r6
109ac: 21a03006 movcs r3, r6
109b0: e1a00005 mov r0, r5
109b4: e59d101c ldr r1, [sp, #28]
109b8: e1a02007 mov r2, r7
109bc: eb000197 bl 11020 <fat_cluster_write>
cur_cln,
ofs_cln,
c,
&buf[cmpltd],
overwrite_cluster);
if (0 > ret)
109c0: e3500000 cmp r0, #0 109c4: b3e00000 mvnlt r0, #0
109c8: ba00000b blt 109fc <fat_file_write+0x190>
{
++file_cln_cnt;
bytes_to_write -= ret;
cmpltd += ret;
save_cln = cur_cln;
if (0 < bytes_to_write)
109cc: e0566000 subs r6, r6, r0
if (RC_OK == rc)
{
++file_cln_cnt;
bytes_to_write -= ret;
cmpltd += ret;
109d0: e08aa000 add sl, sl, r0
if (0 > ret)
rc = -1;
if (RC_OK == rc)
{
++file_cln_cnt;
109d4: e2888001 add r8, r8, #1
bytes_to_write -= ret;
cmpltd += ret;
save_cln = cur_cln;
109d8: e59d401c ldr r4, [sp, #28]
if (0 < bytes_to_write)
109dc: 01a00006 moveq r0, r6
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
ofs_cln = 0;
109e0: 01a07006 moveq r7, r6
{
++file_cln_cnt;
bytes_to_write -= ret;
cmpltd += ret;
save_cln = cur_cln;
if (0 < bytes_to_write)
109e4: 0a000004 beq 109fc <fat_file_write+0x190>
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
109e8: e1a00005 mov r0, r5 109ec: e1a01004 mov r1, r4 109f0: e1a02009 mov r2, r9 109f4: eb00181f bl 16a78 <fat_get_fat_cluster>
ofs_cln = 0;
109f8: e3a07000 mov r7, #0
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
if (RC_OK == rc)
{
file_cln_cnt = cur_cln - fat_fd->cln;
while ( (RC_OK == rc)
109fc: e2963000 adds r3, r6, #0 10a00: 13a03001 movne r3, #1 10a04: e3500000 cmp r0, #0 10a08: 13a03000 movne r3, #0 10a0c: e3530000 cmp r3, #0
10a10: 1affffdc bne 10988 <fat_file_write+0x11c>
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
10a14: e59d100c ldr r1, [sp, #12] 10a18: e5d53008 ldrb r3, [r5, #8] 10a1c: e2417001 sub r7, r1, #1
}
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
10a20: e59d2008 ldr r2, [sp, #8]
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
10a24: e087700a add r7, r7, sl
}
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
10a28: e0827337 add r7, r2, r7, lsr r3 10a2c: e1a0c004 mov ip, r4 10a30: e59d4014 ldr r4, [sp, #20]
}
if (RC_OK != rc)
return rc;
else
return cmpltd;
10a34: e3500000 cmp r0, #0
}
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
10a38: e5847034 str r7, [r4, #52] ; 0x34
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
10a3c: e584c038 str ip, [r4, #56] ; 0x38
}
if (RC_OK != rc)
return rc;
else
return cmpltd;
10a40: 01a0000a moveq r0, sl
fat_fd,
start,
count,
buf,
file_cln_initial);
if (0 > ret)
10a44: e3500000 cmp r0, #0
10a48: aa000000 bge 10a50 <fat_file_write+0x1e4>
rc = -1;
10a4c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
if (RC_OK != rc)
return rc;
else
return cmpltd;
}
10a50: e28dd020 add sp, sp, #32
10a54: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
10a58: e5d57008 ldrb r7, [r5, #8] 10a5c: e1a0c738 lsr ip, r8, r7
const uint8_t *buf,
const uint32_t file_cln_initial)
{
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
10a60: e28d9020 add r9, sp, #32 10a64: e3a03000 mov r3, #0 10a68: e5293004 str r3, [r9, #-4]!
uint32_t file_cln_cnt;
ssize_t ret;
uint32_t c;
bool overwrite_cluster = false;
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
10a6c: e1a00005 mov r0, r5 10a70: e1a01004 mov r1, r4 10a74: e1a0200c mov r2, ip 10a78: e1a03009 mov r3, r9
{
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
10a7c: e58dc008 str ip, [sp, #8]
uint32_t file_cln_cnt;
ssize_t ret;
uint32_t c;
bool overwrite_cluster = false;
rc = fat_file_lseek(fs_info, fat_fd, start_cln, &cur_cln);
10a80: ebfffd7d bl 1007c <fat_file_lseek>
if (RC_OK == rc)
10a84: e3500000 cmp r0, #0
10a88: 0affffb2 beq 10958 <fat_file_write+0xec>
10a8c: eaffffec b 10a44 <fat_file_write+0x1d8> <== NOT EXECUTED
00016dd0 <fat_free_fat_clusters_chain>:
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
16dd0: e92d47f1 push {r0, r4, r5, r6, r7, r8, r9, sl, lr}
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
16dd4: e3a05000 mov r5, #0 16dd8: e28d8004 add r8, sp, #4
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
16ddc: e1a04000 mov r4, r0 16de0: e1a0a001 mov sl, r1
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
16de4: e5285004 str r5, [r8, #-4]!
fat_fs_info_t *fs_info,
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
16de8: e1a06001 mov r6, r1
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
16dec: e1a07005 mov r7, r5
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)
16df0: ea000014 b 16e48 <fat_free_fat_clusters_chain+0x78>
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
16df4: e1a00004 mov r0, r4 16df8: e1a01006 mov r1, r6 16dfc: e1a0200d mov r2, sp 16e00: ebffff1c bl 16a78 <fat_get_fat_cluster>
if ( rc != RC_OK )
16e04: e2509000 subs r9, r0, #0
16e08: 0a000006 beq 16e28 <fat_free_fat_clusters_chain+0x58>
{
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
16e0c: e5943044 ldr r3, [r4, #68] ; 0x44 <== NOT EXECUTED 16e10: e3730001 cmn r3, #1 <== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
16e14: 10855003 addne r5, r5, r3 <== NOT EXECUTED 16e18: 15845044 strne r5, [r4, #68] ; 0x44 <== NOT EXECUTED
fat_buf_release(fs_info);
16e1c: e1a00004 mov r0, r4 <== NOT EXECUTED 16e20: ebffe768 bl 10bc8 <fat_buf_release> <== NOT EXECUTED
return rc;
16e24: ea000014 b 16e7c <fat_free_fat_clusters_chain+0xac> <== NOT EXECUTED
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
16e28: e1a01006 mov r1, r6 16e2c: e1a00004 mov r0, r4 16e30: e1a02009 mov r2, r9 16e34: ebffff63 bl 16bc8 <fat_set_fat_cluster>
if ( rc != RC_OK )
rc1 = rc;
freed_cls_cnt++;
cur_cln = next_cln;
16e38: e59d6000 ldr r6, [sp]
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
if ( rc != RC_OK )
16e3c: e3500000 cmp r0, #0 16e40: 11a07000 movne r7, r0
rc1 = rc;
freed_cls_cnt++;
16e44: e2855001 add r5, r5, #1
int rc = RC_OK, rc1 = RC_OK;
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)
16e48: e5942010 ldr r2, [r4, #16] 16e4c: e5943014 ldr r3, [r4, #20] 16e50: e0062002 and r2, r6, r2 16e54: e1520003 cmp r2, r3
16e58: 3affffe5 bcc 16df4 <fat_free_fat_clusters_chain+0x24>
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
16e5c: e5943044 ldr r3, [r4, #68] ; 0x44 16e60: e3730001 cmn r3, #1
fs_info->vol.free_cls += freed_cls_cnt;
16e64: 10855003 addne r5, r5, r3
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
16e68: e584a04c str sl, [r4, #76] ; 0x4c
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
fs_info->vol.free_cls += freed_cls_cnt;
16e6c: 15845044 strne r5, [r4, #68] ; 0x44
fat_buf_release(fs_info);
16e70: e1a00004 mov r0, r4 16e74: ebffe753 bl 10bc8 <fat_buf_release> 16e78: e1a09007 mov r9, r7
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
16e7c: e1a00009 mov r0, r9
16e80: e8bd87f8 pop {r3, r4, r5, r6, r7, r8, r9, sl, pc}
00011a58 <fat_free_unique_ino>:
fat_free_unique_ino(
fat_fs_info_t *fs_info,
uint32_t ino
)
{
FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino);
11a58: e5903080 ldr r3, [r0, #128] ; 0x80 <== NOT EXECUTED 11a5c: e5902074 ldr r2, [r0, #116] ; 0x74 <== NOT EXECUTED 11a60: e0633001 rsb r3, r3, r1 <== NOT EXECUTED 11a64: e7d201a3 ldrb r0, [r2, r3, lsr #3] <== NOT EXECUTED 11a68: e2031007 and r1, r3, #7 <== NOT EXECUTED 11a6c: e3a0c001 mov ip, #1 <== NOT EXECUTED 11a70: e1c0111c bic r1, r0, ip, lsl r1 <== NOT EXECUTED 11a74: e7c211a3 strb r1, [r2, r3, lsr #3] <== NOT EXECUTED
}
11a78: e12fff1e bx lr <== NOT EXECUTED
00016a78 <fat_get_fat_cluster>:
uint8_t *sec_buf;
uint32_t sec = 0;
uint32_t ofs = 0;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
16a78: e3510001 cmp r1, #1
fat_get_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t *ret_val
)
{
16a7c: e92d47f1 push {r0, r4, r5, r6, r7, r8, r9, sl, lr}
16a80: e1a06000 mov r6, r0
16a84: e1a04001 mov r4, r1
16a88: e1a05002 mov r5, r2
uint8_t *sec_buf;
uint32_t sec = 0;
uint32_t ofs = 0;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
16a8c: 9a000045 bls 16ba8 <fat_get_fat_cluster+0x130>
16a90: e5903038 ldr r3, [r0, #56] ; 0x38 16a94: e2833001 add r3, r3, #1 16a98: e1510003 cmp r1, r3
16a9c: 8a000041 bhi 16ba8 <fat_get_fat_cluster+0x130>
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
16aa0: e5d0300e ldrb r3, [r0, #14] 16aa4: e2131001 ands r1, r3, #1 16aa8: 108420a4 addne r2, r4, r4, lsr #1
16aac: 1a000002 bne 16abc <fat_get_fat_cluster+0x44>
16ab0: e3130002 tst r3, #2 16ab4: 11a02084 lslne r2, r4, #1 16ab8: 01a02104 lsleq r2, r4, #2 16abc: e5d69002 ldrb r9, [r6, #2] 16ac0: e5960058 ldr r0, [r6, #88] ; 0x58
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
16ac4: e3510000 cmp r1, #0
/* 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) +
16ac8: e0809932 add r9, r0, r2, lsr r9
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
16acc: 1084a0a4 addne sl, r4, r4, lsr #1
16ad0: 1a000002 bne 16ae0 <fat_get_fat_cluster+0x68>
16ad4: e3130002 tst r3, #2 16ad8: 11a0a084 lslne sl, r4, #1 16adc: 01a0a104 lsleq sl, r4, #2
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
16ae0: e1a00006 mov r0, r6 16ae4: e1a01009 mov r1, r9 16ae8: e3a02001 mov r2, #1 16aec: e1a0300d mov r3, sp
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);
16af0: e1d670b0 ldrh r7, [r6]
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
16af4: ebffe896 bl 10d54 <fat_buf_access>
if (rc != RC_OK)
16af8: e2508000 subs r8, r0, #0
16afc: 1a00002f bne 16bc0 <fat_get_fat_cluster+0x148>
return rc;
switch ( fs_info->vol.type )
16b00: e5d6200e ldrb r2, [r6, #14]
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);
16b04: e2477001 sub r7, r7, #1
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
16b08: e3520002 cmp r2, #2
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);
16b0c: e00aa007 and sl, sl, r7
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
16b10: 0a00001d beq 16b8c <fat_get_fat_cluster+0x114>
16b14: e3520004 cmp r2, #4
16b18: 0a00001e beq 16b98 <fat_get_fat_cluster+0x120>
16b1c: e3520001 cmp r2, #1
16b20: 1a000020 bne 16ba8 <fat_get_fat_cluster+0x130>
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*(sec_buf + ofs));
16b24: e59d7000 ldr r7, [sp]
if ( ofs == (fs_info->vol.bps - 1) )
16b28: e1d610b0 ldrh r1, [r6]
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*(sec_buf + ofs));
16b2c: e7d7300a ldrb r3, [r7, sl]
if ( ofs == (fs_info->vol.bps - 1) )
16b30: e2411001 sub r1, r1, #1 16b34: e15a0001 cmp sl, r1
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*(sec_buf + ofs));
16b38: e5853000 str r3, [r5]
*ret_val |= *sec_buf << 8;
}
else
{
*ret_val |= *(sec_buf + ofs + 1) << 8;
16b3c: 1087a00a addne sl, r7, sl 16b40: 15da2001 ldrbne r2, [sl, #1]
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*(sec_buf + ofs));
if ( ofs == (fs_info->vol.bps - 1) )
16b44: 1a000008 bne 16b6c <fat_get_fat_cluster+0xf4>
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
16b48: e1a0300d mov r3, sp <== NOT EXECUTED 16b4c: e1a00006 mov r0, r6 <== NOT EXECUTED 16b50: e2891001 add r1, r9, #1 <== NOT EXECUTED 16b54: ebffe87e bl 10d54 <fat_buf_access> <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
16b58: e3500000 cmp r0, #0 <== NOT EXECUTED
return rc;
*ret_val |= *sec_buf << 8;
16b5c: 059d3000 ldreq r3, [sp] <== NOT EXECUTED 16b60: 05d32000 ldrbeq r2, [r3] <== NOT EXECUTED 16b64: 05953000 ldreq r3, [r5] <== NOT EXECUTED
*ret_val = (*(sec_buf + ofs));
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&sec_buf);
if (rc != RC_OK)
16b68: 1a000013 bne 16bbc <fat_get_fat_cluster+0x144> <== NOT EXECUTED
*ret_val |= *sec_buf << 8;
}
else
{
*ret_val |= *(sec_buf + ofs + 1) << 8;
16b6c: e1833402 orr r3, r3, r2, lsl #8 16b70: e5853000 str r3, [r5] 16b74: e5953000 ldr r3, [r5]
}
if ( FAT_CLUSTER_IS_ODD(cln) )
16b78: e3140001 tst r4, #1
*ret_val = (*ret_val) >> FAT12_SHIFT;
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
16b7c: 01a03a03 lsleq r3, r3, #20
{
*ret_val |= *(sec_buf + ofs + 1) << 8;
}
if ( FAT_CLUSTER_IS_ODD(cln) )
*ret_val = (*ret_val) >> FAT12_SHIFT;
16b80: 11a03223 lsrne r3, r3, #4
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
16b84: 01a03a23 lsreq r3, r3, #20 16b88: ea000004 b 16ba0 <fat_get_fat_cluster+0x128>
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(sec_buf + ofs));
16b8c: e59d3000 ldr r3, [sp] 16b90: e19330ba ldrh r3, [r3, sl] 16b94: ea000001 b 16ba0 <fat_get_fat_cluster+0x128>
*ret_val = CF_LE_W(*ret_val);
break;
case FAT_FAT32:
*ret_val = *((uint32_t *)(sec_buf + ofs));
16b98: e59d3000 ldr r3, [sp] 16b9c: e793300a ldr r3, [r3, sl] 16ba0: e5853000 str r3, [r5]
*ret_val = CF_LE_L(*ret_val);
break;
16ba4: ea000005 b 16bc0 <fat_get_fat_cluster+0x148>
default:
rtems_set_errno_and_return_minus_one(EIO);
16ba8: eb00072e bl 18868 <__errno> <== NOT EXECUTED 16bac: e3a03005 mov r3, #5 <== NOT EXECUTED 16bb0: e5803000 str r3, [r0] <== NOT EXECUTED 16bb4: e3e08000 mvn r8, #0 <== NOT EXECUTED 16bb8: ea000000 b 16bc0 <fat_get_fat_cluster+0x148> <== NOT EXECUTED
*ret_val = (*(sec_buf + ofs));
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&sec_buf);
if (rc != RC_OK)
16bbc: e1a08000 mov r8, r0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
16bc0: e1a00008 mov r0, r8
16bc4: e8bd87f8 pop {r3, r4, r5, r6, r7, r8, r9, sl, pc}
000119a4 <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(fat_fs_info_t *fs_info)
{
119a4: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
119a8: e1a04000 mov r4, r0 <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
119ac: e3a05000 mov r5, #0 <== NOT EXECUTED
fat_get_unique_ino(fat_fs_info_t *fs_info)
{
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
119b0: ea000023 b 11a44 <fat_get_unique_ino+0xa0> <== NOT EXECUTED
{
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
119b4: e2840074 add r0, r4, #116 ; 0x74 <== NOT EXECUTED
119b8: e8900009 ldm r0, {r0, r3} <== NOT EXECUTED
119bc: e08061a3 add r6, r0, r3, lsr #3 <== NOT EXECUTED
119c0: e7d001a3 ldrb r0, [r0, r3, lsr #3] <== NOT EXECUTED
119c4: e203c007 and ip, r3, #7 <== NOT EXECUTED
119c8: e1a07c50 asr r7, r0, ip <== NOT EXECUTED
119cc: e3170001 tst r7, #1 <== NOT EXECUTED
119d0: 1a000006 bne 119f0 <fat_get_unique_ino+0x4c> <== NOT EXECUTED
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
119d4: e3a03001 mov r3, #1 <== NOT EXECUTED 119d8: e1800c13 orr r0, r0, r3, lsl ip <== NOT EXECUTED 119dc: e5c60000 strb r0, [r6] <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
119e0: e5940078 ldr r0, [r4, #120] ; 0x78 <== NOT EXECUTED
119e4: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED
119e8: e0800003 add r0, r0, r3 <== NOT EXECUTED
119ec: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
}
fs_info->index++;
119f0: e2833001 add r3, r3, #1 <== NOT EXECUTED
if (fs_info->index >= fs_info->uino_pool_size)
119f4: e1530002 cmp r3, r2 <== NOT EXECUTED
fs_info->index = 0;
119f8: 21a03005 movcs r3, r5 <== NOT EXECUTED 119fc: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
11a00: e2811001 add r1, r1, #1 <== NOT EXECUTED 11a04: e1510002 cmp r1, r2 <== NOT EXECUTED 11a08: 1affffe9 bne 119b4 <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))
11a0c: e5942080 ldr r2, [r4, #128] ; 0x80 <== NOT EXECUTED 11a10: e3e0320f mvn r3, #-268435456 ; 0xf0000000 <== NOT EXECUTED 11a14: e1a01081 lsl r1, r1, #1 <== NOT EXECUTED 11a18: e0623003 rsb r3, r2, r3 <== NOT EXECUTED 11a1c: e1510003 cmp r1, r3 <== NOT EXECUTED 11a20: 2a00000a bcs 11a50 <fat_get_unique_ino+0xac> <== NOT EXECUTED
{
fs_info->uino_pool_size <<= 1;
11a24: e584107c str r1, [r4, #124] ; 0x7c <== NOT EXECUTED
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
11a28: e5940074 ldr r0, [r4, #116] ; 0x74 <== NOT EXECUTED 11a2c: ebffcd47 bl 4f50 <realloc> <== NOT EXECUTED
if (fs_info->uino != NULL)
11a30: 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);
11a34: e5840074 str r0, [r4, #116] ; 0x74 <== NOT EXECUTED
if (fs_info->uino != NULL)
11a38: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
11a3c: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED 11a40: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
11a44: e594207c ldr r2, [r4, #124] ; 0x7c <== NOT EXECUTED 11a48: e3a01000 mov r1, #0 <== NOT EXECUTED 11a4c: eaffffec b 11a04 <fat_get_unique_ino+0x60> <== NOT EXECUTED
resrc_unsuff = true;
}
else
resrc_unsuff = true;
}
return 0;
11a50: e3a00000 mov r0, #0 <== NOT EXECUTED
}
11a54: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
0001192c <fat_init_clusters_chain>:
int
fat_init_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t start_cln
)
{
1192c: e92d4073 push {r0, r1, r4, r5, r6, lr}
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cur_cln = start_cln;
11930: e28d5008 add r5, sp, #8
int
fat_init_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t start_cln
)
{
11934: e1a04000 mov r4, r0
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cur_cln = start_cln;
11938: e5251004 str r1, [r5, #-4]! 1193c: e3a06000 mov r6, #0
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
11940: ea00000d b 1197c <fat_init_clusters_chain+0x50>
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
11944: e1d430b6 ldrh r3, [r4, #6] 11948: e1a00004 mov r0, r4 1194c: e3a02000 mov r2, #0 11950: e58d6000 str r6, [sp] 11954: ebfffd73 bl 10f28 <fat_cluster_set>
if ( ret != fs_info->vol.bpc )
11958: e1d430b6 ldrh r3, [r4, #6] 1195c: e1500003 cmp r0, r3
11960: 1a00000d bne 1199c <fat_init_clusters_chain+0x70>
{
return -1;
}
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
11964: e1a00004 mov r0, r4 11968: e59d1004 ldr r1, [sp, #4] 1196c: e1a02005 mov r2, r5 11970: eb001440 bl 16a78 <fat_get_fat_cluster>
if ( rc != RC_OK )
11974: e3500000 cmp r0, #0
11978: 1a000008 bne 119a0 <fat_init_clusters_chain+0x74>
{
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cur_cln = start_cln;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
1197c: e59d1004 ldr r1, [sp, #4] 11980: e5942010 ldr r2, [r4, #16] 11984: e5943014 ldr r3, [r4, #20] 11988: e0012002 and r2, r1, r2 1198c: e1520003 cmp r2, r3
11990: 3affffeb bcc 11944 <fat_init_clusters_chain+0x18>
return rc;
}
}
return rc;
11994: e3a00000 mov r0, #0 11998: ea000000 b 119a0 <fat_init_clusters_chain+0x74>
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
if ( ret != fs_info->vol.bpc )
{
return -1;
1199c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
}
return rc;
}
119a0: e8bd807c pop {r2, r3, r4, r5, r6, pc}
00011128 <fat_init_volume_info>:
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_init_volume_info(fat_fs_info_t *fs_info, const char *device)
{
11128: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
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;
1112c: e3a03000 mov r3, #0
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_init_volume_info(fat_fs_info_t *fs_info, const char *device)
{
11130: e24dd0ac sub sp, sp, #172 ; 0xac 11134: e1a04000 mov r4, r0
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
vol->fd = open(device, O_RDWR);
11138: e1a00001 mov r0, r1 1113c: e3a01002 mov r1, #2
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;
11140: e58d30a8 str r3, [sp, #168] ; 0xa8
vol->fd = open(device, O_RDWR);
11144: ebffcefd bl 4d40 <open>
if (vol->fd < 0)
11148: e3500000 cmp r0, #0
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
vol->fd = open(device, O_RDWR);
1114c: e5840060 str r0, [r4, #96] ; 0x60
if (vol->fd < 0)
11150: ba000005 blt 1116c <fat_init_volume_info+0x44>
{
rtems_set_errno_and_return_minus_one(ENXIO);
}
rc = fstat(vol->fd, &stat_buf);
11154: e28d1054 add r1, sp, #84 ; 0x54 11158: ebffcbd8 bl 40c0 <fstat>
if (rc != 0)
1115c: e3500000 cmp r0, #0
11160: 0a000006 beq 11180 <fat_init_volume_info+0x58>
{
close(vol->fd);
11164: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 11168: ebffcb09 bl 3d94 <close> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENXIO);
1116c: eb001dbd bl 18868 <__errno> <== NOT EXECUTED 11170: e3a03006 mov r3, #6 <== NOT EXECUTED 11174: e5803000 str r3, [r0] <== NOT EXECUTED 11178: e3e00000 mvn r0, #0 <== NOT EXECUTED 1117c: ea000189 b 117a8 <fat_init_volume_info+0x680> <== NOT EXECUTED
}
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
11180: e59d3060 ldr r3, [sp, #96] ; 0x60 11184: e2033a0f and r3, r3, #61440 ; 0xf000 11188: e3530a06 cmp r3, #24576 ; 0x6000
{
close(vol->fd);
1118c: e5940060 ldr r0, [r4, #96] ; 0x60
close(vol->fd);
rtems_set_errno_and_return_minus_one(ENXIO);
}
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
11190: 1afffff4 bne 11168 <fat_init_volume_info+0x40>
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
11194: e59f1614 ldr r1, [pc, #1556] ; 117b0 <fat_init_volume_info+0x688> 11198: e2842064 add r2, r4, #100 ; 0x64 1119c: eb000516 bl 125fc <ioctl>
rtems_set_errno_and_return_minus_one(ENXIO);
}
/* check that device is registred as block device and lock it */
rc = rtems_disk_fd_get_disk_device(vol->fd, &vol->dd);
if (rc != 0) {
111a0: e2501000 subs r1, r0, #0
111a4: 1affffee bne 11164 <fat_init_volume_info+0x3c>
rtems_set_errno_and_return_minus_one(ENXIO);
}
/* Read boot record */
/* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */
sc = rtems_bdbuf_read( vol->dd, 0, &block);
111a8: e5940064 ldr r0, [r4, #100] ; 0x64 111ac: e28d20a8 add r2, sp, #168 ; 0xa8 111b0: ebfff728 bl ee58 <rtems_bdbuf_read>
if (sc != RTEMS_SUCCESSFUL)
111b4: e3500000 cmp r0, #0
111b8: 1a000033 bne 1128c <fat_init_volume_info+0x164>
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
111bc: e59d00a8 ldr r0, [sp, #168] ; 0xa8 111c0: e590201c ldr r2, [r0, #28] 111c4: e5d2c013 ldrb ip, [r2, #19] 111c8: e58dc00c str ip, [sp, #12] 111cc: e5d2c014 ldrb ip, [r2, #20] 111d0: e58dc010 str ip, [sp, #16] 111d4: e5d2c016 ldrb ip, [r2, #22] 111d8: e58dc014 str ip, [sp, #20] 111dc: e5d2c017 ldrb ip, [r2, #23] 111e0: e58dc018 str ip, [sp, #24] 111e4: e5d2c020 ldrb ip, [r2, #32] 111e8: e58dc040 str ip, [sp, #64] ; 0x40 111ec: e5d2c021 ldrb ip, [r2, #33] ; 0x21 111f0: e58dc044 str ip, [sp, #68] ; 0x44 111f4: e5d2c022 ldrb ip, [r2, #34] ; 0x22 111f8: e58dc048 str ip, [sp, #72] ; 0x48 111fc: e5d2c023 ldrb ip, [r2, #35] ; 0x23 11200: e58dc04c str ip, [sp, #76] ; 0x4c 11204: e5d2c024 ldrb ip, [r2, #36] ; 0x24 11208: e58dc050 str ip, [sp, #80] ; 0x50 1120c: e5d2c025 ldrb ip, [r2, #37] ; 0x25 11210: e58dc034 str ip, [sp, #52] ; 0x34 11214: e5d2c026 ldrb ip, [r2, #38] ; 0x26 11218: e58dc038 str ip, [sp, #56] ; 0x38 1121c: e5d2c027 ldrb ip, [r2, #39] ; 0x27 11220: e5d2100c ldrb r1, [r2, #12] 11224: e5d2300f ldrb r3, [r2, #15] 11228: e5d2600b ldrb r6, [r2, #11] 1122c: e5d2500d ldrb r5, [r2, #13] 11230: e5d2800e ldrb r8, [r2, #14] 11234: e5d2a010 ldrb sl, [r2, #16] 11238: e5d29011 ldrb r9, [r2, #17] 1123c: e5d2b012 ldrb fp, [r2, #18] 11240: e58dc03c str ip, [sp, #60] ; 0x3c 11244: e5d2c02c ldrb ip, [r2, #44] ; 0x2c 11248: e58dc02c str ip, [sp, #44] ; 0x2c 1124c: e5d2c02d ldrb ip, [r2, #45] ; 0x2d 11250: e58dc030 str ip, [sp, #48] ; 0x30 11254: e5d2c02e ldrb ip, [r2, #46] ; 0x2e 11258: e58dc01c str ip, [sp, #28] 1125c: e5d2c02f ldrb ip, [r2, #47] ; 0x2f 11260: e5d27028 ldrb r7, [r2, #40] ; 0x28 11264: e58dc020 str ip, [sp, #32] 11268: e5d2c030 ldrb ip, [r2, #48] ; 0x30 1126c: e5d22031 ldrb r2, [r2, #49] ; 0x31 11270: e58dc024 str ip, [sp, #36] ; 0x24
sc = rtems_bdbuf_release( block);
11274: e98d000a stmib sp, {r1, r3}
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
11278: e58d2028 str r2, [sp, #40] ; 0x28
sc = rtems_bdbuf_release( block);
1127c: ebfff76a bl f02c <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL)
11280: e3500000 cmp r0, #0
11284: e99d000a ldmib sp, {r1, r3}
11288: 0a000004 beq 112a0 <fat_init_volume_info+0x178>
{
close(vol->fd);
1128c: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 11290: ebffcabf bl 3d94 <close> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
11294: eb001d73 bl 18868 <__errno> <== NOT EXECUTED 11298: e3a03005 mov r3, #5 <== NOT EXECUTED 1129c: eaffffb4 b 11174 <fat_init_volume_info+0x4c> <== NOT EXECUTED
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
112a0: e1861401 orr r1, r6, r1, lsl #8
if ( (vol->bps != 512) &&
112a4: e3510b01 cmp r1, #1024 ; 0x400 112a8: 13510c02 cmpne r1, #512 ; 0x200
close(vol->fd);
rtems_set_errno_and_return_minus_one( EIO );
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
112ac: e1c410b0 strh r1, [r4]
if ( (vol->bps != 512) &&
112b0: 0a000003 beq 112c4 <fat_init_volume_info+0x19c>
(vol->bps != 1024) &&
112b4: e3510b02 cmp r1, #2048 ; 0x800 <== NOT EXECUTED 112b8: 0a000001 beq 112c4 <fat_init_volume_info+0x19c> <== NOT EXECUTED
(vol->bps != 2048) &&
112bc: e3510a01 cmp r1, #4096 ; 0x1000 <== NOT EXECUTED 112c0: 1a0000a1 bne 1154c <fat_init_volume_info+0x424> <== NOT EXECUTED
(vol->bps != 4096))
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
112c4: e3a02000 mov r2, #0 112c8: e5c42003 strb r2, [r4, #3] 112cc: e1a024a1 lsr r2, r1, #9 112d0: ea000003 b 112e4 <fat_init_volume_info+0x1bc>
i >>= 1, vol->sec_mul++);
112d4: e5d40003 ldrb r0, [r4, #3] <== NOT EXECUTED 112d8: e2800001 add r0, r0, #1 <== NOT EXECUTED 112dc: e5c40003 strb r0, [r4, #3] <== NOT EXECUTED 112e0: e1a020c2 asr r2, r2, #1 <== NOT EXECUTED
(vol->bps != 4096))
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
112e4: e3120001 tst r2, #1
112e8: 0afffff9 beq 112d4 <fat_init_volume_info+0x1ac>
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
112ec: e3a02000 mov r2, #0 112f0: e5c42002 strb r2, [r4, #2] 112f4: e1a02001 mov r2, r1 112f8: ea000002 b 11308 <fat_init_volume_info+0x1e0>
i >>= 1, vol->sec_log2++);
112fc: e2866001 add r6, r6, #1 11300: e5c46002 strb r6, [r4, #2] 11304: e1a020c2 asr r2, r2, #1
close(vol->fd);
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;
11308: e3120001 tst r2, #1 1130c: e5d46002 ldrb r6, [r4, #2]
11310: 0afffff9 beq 112fc <fat_init_volume_info+0x1d4>
i >>= 1, vol->sec_log2++);
vol->bytes_per_block = vol->bps;
vol->bytes_per_block_log2 = vol->sec_log2;
vol->sectors_per_block = 1;
11314: e3a02001 mov r2, #1
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)
11318: e3550000 cmp r5, #0
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
i >>= 1, vol->sec_log2++);
vol->bytes_per_block = vol->bps;
vol->bytes_per_block_log2 = vol->sec_log2;
vol->sectors_per_block = 1;
1131c: e5c42009 strb r2, [r4, #9]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
11320: 13a02000 movne r2, #0
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->bytes_per_block = vol->bps;
11324: e1c410ba strh r1, [r4, #10]
vol->bytes_per_block_log2 = vol->sec_log2;
11328: e5c4600c strb r6, [r4, #12]
vol->sectors_per_block = 1;
vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
1132c: e5c45004 strb r5, [r4, #4]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
11330: 15c42005 strbne r2, [r4, #5] 11334: 11a00005 movne r0, r5
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)
11338: 1a000003 bne 1134c <fat_init_volume_info+0x224>
1133c: ea000082 b 1154c <fat_init_volume_info+0x424> <== NOT EXECUTED
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
i >>= 1, vol->spc_log2++);
11340: e2822001 add r2, r2, #1 11344: e5c42005 strb r2, [r4, #5] 11348: e1a000c0 asr r0, r0, #1
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
1134c: e3100001 tst r0, #1 11350: e5d42005 ldrb r2, [r4, #5]
11354: 0afffff9 beq 11340 <fat_init_volume_info+0x218>
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)
11358: e1a02211 lsl r2, r1, r2 1135c: e1a02802 lsl r2, r2, #16 11360: e1a02822 lsr r2, r2, #16 11364: e3520902 cmp r2, #32768 ; 0x8000 11368: e1c420b6 strh r2, [r4, #6]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
1136c: 93a00000 movls r0, #0
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)
11370: 9a000003 bls 11384 <fat_init_volume_info+0x25c>
11374: ea000074 b 1154c <fat_init_volume_info+0x424> <== NOT EXECUTED
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
11378: e5d40008 ldrb r0, [r4, #8] 1137c: e1a020c2 asr r2, r2, #1 11380: e2800001 add r0, r0, #1
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
11384: e3120001 tst r2, #1
i >>= 1, vol->bpc_log2++);
11388: e5c40008 strb r0, [r4, #8]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
1138c: 0afffff9 beq 11378 <fat_init_volume_info+0x250>
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);
11390: e1888403 orr r8, r8, r3, lsl #8
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)) /
11394: e2410001 sub r0, r1, #1
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);
11398: e189940b orr r9, r9, fp, lsl #8
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
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);
1139c: e1c481b8 strh r8, [r4, #24]
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
113a0: e5c4a00d strb sl, [r4, #13]
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
113a4: e1c492b4 strh r9, [r4, #36] ; 0x24
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
113a8: e0800289 add r0, r0, r9, lsl #5 113ac: eb005334 bl 26084 <__aeabi_idiv>
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
113b0: e1a06610 lsl r6, r0, r6
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
113b4: e28d2014 add r2, sp, #20
113b8: e8921004 ldm r2, {r2, ip}
113bc: e192340c orrs r3, r2, ip, lsl #8
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
113c0: 059d2038 ldreq r2, [sp, #56] ; 0x38 113c4: 059dc034 ldreq ip, [sp, #52] ; 0x34 113c8: 01a03802 lsleq r3, r2, #16 113cc: 059d2050 ldreq r2, [sp, #80] ; 0x50 113d0: 0183340c orreq r3, r3, ip, lsl #8 113d4: 059dc03c ldreq ip, [sp, #60] ; 0x3c 113d8: 01833002 orreq r3, r3, r2 113dc: 01833c0c orreq r3, r3, ip, lsl #24 113e0: e584301c str r3, [r4, #28]
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
113e4: e594301c ldr r3, [r4, #28] 113e8: e0288a93 mla r8, r3, sl, r8
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
113ec: e28d200c add r2, sp, #12
113f0: e8921004 ldm r2, {r2, ip}
113f4: e192340c orrs r3, r2, ip, lsl #8
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
113f8: 059d2048 ldreq r2, [sp, #72] ; 0x48 113fc: 059dc044 ldreq ip, [sp, #68] ; 0x44 11400: 01a03802 lsleq r3, r2, #16 11404: 059d2040 ldreq r2, [sp, #64] ; 0x40 11408: 0183340c orreq r3, r3, ip, lsl #8 1140c: 059dc04c ldreq ip, [sp, #76] ; 0x4c 11410: 01833002 orreq r3, r3, r2 11414: 01833c0c orreq r3, r3, ip, lsl #24 11418: e5843030 str r3, [r4, #48] ; 0x30
data_secs = vol->tot_secs - vol->data_fsec;
1141c: e5943030 ldr r3, [r4, #48] ; 0x30
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)) /
11420: e5840028 str r0, [r4, #40] ; 0x28
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 +
11424: e0800008 add r0, r0, r8 11428: e5840034 str r0, [r4, #52] ; 0x34
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
1142c: e584602c str r6, [r4, #44] ; 0x2c
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;
11430: e0600003 rsb r0, r0, r3
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
11434: e5848020 str r8, [r4, #32]
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;
11438: e1a01005 mov r1, r5 1143c: ebffc207 bl 1c60 <__aeabi_uidiv>
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
11440: e59f336c ldr r3, [pc, #876] ; 117b4 <fat_init_volume_info+0x68c> 11444: e1500003 cmp r0, r3
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;
11448: e5840038 str r0, [r4, #56] ; 0x38
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
{
vol->type = FAT_FAT12;
1144c: 93a03001 movls r3, #1 11450: 95c4300e strbls r3, [r4, #14]
vol->mask = FAT_FAT12_MASK;
11454: 959f335c ldrls r3, [pc, #860] ; 117b8 <fat_init_volume_info+0x690>
11458: 9a000005 bls 11474 <fat_init_volume_info+0x34c>
vol->eoc_val = FAT_FAT12_EOC;
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
1145c: e59f3358 ldr r3, [pc, #856] ; 117bc <fat_init_volume_info+0x694> 11460: e1500003 cmp r0, r3
11464: 8a000005 bhi 11480 <fat_init_volume_info+0x358>
{
vol->type = FAT_FAT16;
11468: e3a03002 mov r3, #2 1146c: e5c4300e strb r3, [r4, #14]
vol->mask = FAT_FAT16_MASK;
11470: e59f3348 ldr r3, [pc, #840] ; 117c0 <fat_init_volume_info+0x698> 11474: e5843010 str r3, [r4, #16]
vol->eoc_val = FAT_FAT16_EOC;
11478: e2433007 sub r3, r3, #7 1147c: ea000004 b 11494 <fat_init_volume_info+0x36c>
}
else
{
vol->type = FAT_FAT32;
11480: e3a03004 mov r3, #4 11484: e5c4300e strb r3, [r4, #14]
vol->mask = FAT_FAT32_MASK;
11488: e3e0320f mvn r3, #-268435456 ; 0xf0000000 1148c: e5843010 str r3, [r4, #16]
vol->eoc_val = FAT_FAT32_EOC;
11490: e3e0327f mvn r3, #-268435449 ; 0xf0000007 11494: e5843014 str r3, [r4, #20]
}
}
if (vol->type == FAT_FAT32)
11498: e5d4300e ldrb r3, [r4, #14] 1149c: e3530004 cmp r3, #4
114a0: 1a00004f bne 115e4 <fat_init_volume_info+0x4bc>
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
114a4: e59d201c ldr r2, [sp, #28] 114a8: e59dc030 ldr ip, [sp, #48] ; 0x30 114ac: e1a03802 lsl r3, r2, #16 114b0: e59d202c ldr r2, [sp, #44] ; 0x2c 114b4: e183340c orr r3, r3, ip, lsl #8 114b8: e59dc020 ldr ip, [sp, #32] 114bc: e1833002 orr r3, r3, r2 114c0: e1833c0c orr r3, r3, ip, lsl #24 114c4: e584303c str r3, [r4, #60] ; 0x3c
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
114c8: e2073080 and r3, r7, #128 ; 0x80
if (vol->mirror)
114cc: e3530000 cmp r3, #0
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);
114d0: e28d2024 add r2, sp, #36 ; 0x24
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
if (vol->mirror)
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
else
vol->afat = 0;
114d4: 05c4305c strbeq r3, [r4, #92] ; 0x5c
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
114d8: e5c43054 strb r3, [r4, #84] ; 0x54
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);
114dc: e892000c ldm r2, {r2, r3}
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
if (vol->mirror)
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
114e0: 1207700f andne r7, r7, #15
else
vol->afat = 0;
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
114e4: e1821403 orr r1, r2, r3, lsl #8
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
if (vol->mirror)
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
114e8: 15c4705c strbne r7, [r4, #92] ; 0x5c
else
vol->afat = 0;
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
if( vol->info_sec == 0 )
114ec: e3510000 cmp r1, #0
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);
114f0: e1c414b0 strh r1, [r4, #64] ; 0x40
if( vol->info_sec == 0 )
114f4: 0a000014 beq 1154c <fat_init_volume_info+0x424>
rtems_set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(fs_info, vol->info_sec , 0,
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
114f8: e28d509c add r5, sp, #156 ; 0x9c
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(fs_info, vol->info_sec , 0,
114fc: e1a00004 mov r0, r4 11500: e3a02000 mov r2, #0 11504: e3a03004 mov r3, #4 11508: e58d5000 str r5, [sp] 1150c: ebfffe3b bl 10e00 <_fat_block_read>
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
11510: e3500000 cmp r0, #0
11514: ba00001b blt 11588 <fat_init_volume_info+0x460>
{
close(vol->fd);
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
11518: e5dd209e ldrb r2, [sp, #158] ; 0x9e 1151c: e5dd309d ldrb r3, [sp, #157] ; 0x9d 11520: e1a02802 lsl r2, r2, #16 11524: e1822403 orr r2, r2, r3, lsl #8 11528: e5dd309c ldrb r3, [sp, #156] ; 0x9c 1152c: e1822003 orr r2, r2, r3 11530: e5dd309f ldrb r3, [sp, #159] ; 0x9f 11534: e1822c03 orr r2, r2, r3, lsl #24 11538: e59f3284 ldr r3, [pc, #644] ; 117c4 <fat_init_volume_info+0x69c> 1153c: e1520003 cmp r2, r3
11540: 0a000006 beq 11560 <fat_init_volume_info+0x438>
* 0 on success, or -1 if error occured and errno set appropriately
*/
int
_fat_block_release(fat_fs_info_t *fs_info)
{
return fat_buf_release(fs_info);
11544: e1a00004 mov r0, r4 <== NOT EXECUTED 11548: ebfffd9e bl 10bc8 <fat_buf_release> <== NOT EXECUTED
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
FAT_FSINFO_LEAD_SIGNATURE_VALUE)
{
_fat_block_release(fs_info);
close(vol->fd);
1154c: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 11550: ebffca0f bl 3d94 <close> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
11554: eb001cc3 bl 18868 <__errno> <== NOT EXECUTED 11558: e3a03016 mov r3, #22 <== NOT EXECUTED 1155c: eaffff04 b 11174 <fat_init_volume_info+0x4c> <== NOT EXECUTED
}
else
{
ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
11560: e1d414b0 ldrh r1, [r4, #64] ; 0x40 11564: e1a00004 mov r0, r4 11568: e3a02f79 mov r2, #484 ; 0x1e4 1156c: e3a0300c mov r3, #12 11570: e58d5000 str r5, [sp] 11574: ebfffe21 bl 10e00 <_fat_block_read>
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
11578: e3500000 cmp r0, #0
1157c: aa000004 bge 11594 <fat_init_volume_info+0x46c>
* 0 on success, or -1 if error occured and errno set appropriately
*/
int
_fat_block_release(fat_fs_info_t *fs_info)
{
return fat_buf_release(fs_info);
11580: e1a00004 mov r0, r4 <== NOT EXECUTED 11584: ebfffd8f bl 10bc8 <fat_buf_release> <== NOT EXECUTED
ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
{
_fat_block_release(fs_info);
close(vol->fd);
11588: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 1158c: ebffca00 bl 3d94 <close> <== NOT EXECUTED 11590: eafffef8 b 11178 <fat_init_volume_info+0x50> <== NOT EXECUTED
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
11594: e5dd30a2 ldrb r3, [sp, #162] ; 0xa2 11598: e5dd20a1 ldrb r2, [sp, #161] ; 0xa1 1159c: e1a03803 lsl r3, r3, #16 115a0: e1833402 orr r3, r3, r2, lsl #8 115a4: e5dd20a0 ldrb r2, [sp, #160] ; 0xa0 115a8: e1833002 orr r3, r3, r2 115ac: e5dd20a3 ldrb r2, [sp, #163] ; 0xa3 115b0: e1833c02 orr r3, r3, r2, lsl #24
_fat_block_release(fs_info);
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
115b4: e5843048 str r3, [r4, #72] ; 0x48
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->free_cls = vol->free_cls_in_fs_info;
115b8: e5843044 str r3, [r4, #68] ; 0x44
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
115bc: e5dd30a6 ldrb r3, [sp, #166] ; 0xa6 115c0: e5dd20a5 ldrb r2, [sp, #165] ; 0xa5 115c4: e1a03803 lsl r3, r3, #16 115c8: e1833402 orr r3, r3, r2, lsl #8 115cc: e5dd20a4 ldrb r2, [sp, #164] ; 0xa4 115d0: e1833002 orr r3, r3, r2 115d4: e5dd20a7 ldrb r2, [sp, #167] ; 0xa7 115d8: e1833c02 orr r3, r3, r2, lsl #24
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
115dc: e5843050 str r3, [r4, #80] ; 0x50 115e0: ea000005 b 115fc <fat_init_volume_info+0x4d4>
}
}
}
else
{
vol->rdir_cl = 0;
115e4: e3a03000 mov r3, #0 115e8: e584303c str r3, [r4, #60] ; 0x3c
vol->mirror = 0;
115ec: e5c43054 strb r3, [r4, #84] ; 0x54
vol->afat = 0;
115f0: e5c4305c strb r3, [r4, #92] ; 0x5c
vol->free_cls = FAT_UNDEFINED_VALUE;
115f4: e3e03000 mvn r3, #0 115f8: e5843044 str r3, [r4, #68] ; 0x44
vol->next_cl = FAT_UNDEFINED_VALUE;
115fc: e584304c str r3, [r4, #76] ; 0x4c
* 0 on success, or -1 if error occured and errno set appropriately
*/
int
_fat_block_release(fat_fs_info_t *fs_info)
{
return fat_buf_release(fs_info);
11600: e1a00004 mov r0, r4 11604: ebfffd6f bl 10bc8 <fat_buf_release>
vol->next_cl = FAT_UNDEFINED_VALUE;
}
_fat_block_release(fs_info);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
11608: e594101c ldr r1, [r4, #28] 1160c: e5d4305c ldrb r3, [r4, #92] ; 0x5c 11610: e1d421b8 ldrh r2, [r4, #24] 11614: e0232391 mla r3, r1, r3, r2
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
11618: e3a00002 mov r0, #2
vol->next_cl = FAT_UNDEFINED_VALUE;
}
_fat_block_release(fs_info);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
1161c: e5843058 str r3, [r4, #88] ; 0x58
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
11620: e3a0100c mov r1, #12 11624: ebffc9c8 bl 3d4c <calloc>
if ( fs_info->vhash == NULL )
11628: e3500000 cmp r0, #0
_fat_block_release(fs_info);
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));
1162c: e584006c str r0, [r4, #108] ; 0x6c
if ( fs_info->vhash == NULL )
11630: 0a000010 beq 11678 <fat_init_volume_info+0x550>
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
11634: e2803004 add r3, r0, #4
head->next = tail;
11638: e5803000 str r3, [r0]
head->previous = NULL;
1163c: e3a05000 mov r5, #0
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
11640: e280300c add r3, r0, #12 11644: e2802010 add r2, r0, #16
head->next = tail;
head->previous = NULL;
11648: e5805004 str r5, [r0, #4]
tail->previous = head;
1164c: e5800008 str r0, [r0, #8]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
11650: e580200c str r2, [r0, #12]
head->previous = NULL;
11654: e5805010 str r5, [r0, #16]
tail->previous = head;
11658: e5803014 str r3, [r0, #20]
}
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));
1165c: e3a0100c mov r1, #12 11660: e3a00002 mov r0, #2 11664: ebffc9b8 bl 3d4c <calloc>
if ( fs_info->rhash == NULL )
11668: e1500005 cmp r0, r5
}
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));
1166c: e5840070 str r0, [r4, #112] ; 0x70
if ( fs_info->rhash == NULL )
11670: 1a000003 bne 11684 <fat_init_volume_info+0x55c>
11674: ea000018 b 116dc <fat_init_volume_info+0x5b4> <== 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 )
{
close(vol->fd);
11678: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 1167c: ebffc9c4 bl 3d94 <close> <== NOT EXECUTED 11680: ea00002d b 1173c <fat_init_volume_info+0x614> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
11684: e2803004 add r3, r0, #4
head->next = tail;
head->previous = NULL;
11688: e8800028 stm r0, {r3, r5}
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
1168c: e2802010 add r2, r0, #16 11690: e280300c add r3, r0, #12
head->next = tail;
11694: e580200c str r2, [r0, #12]
head->previous = NULL; tail->previous = head;
11698: e5800008 str r0, [r0, #8]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
1169c: e5805010 str r5, [r0, #16]
tail->previous = head;
116a0: e5803014 str r3, [r0, #20]
}
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;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
116a4: e5942030 ldr r2, [r4, #48] ; 0x30 116a8: e5d43003 ldrb r3, [r4, #3] 116ac: e1a03312 lsl r3, r2, r3
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;
116b0: e3a00c01 mov r0, #256 ; 0x100
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
116b4: e1a03203 lsl r3, r3, #4
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;
116b8: e584007c str r0, [r4, #124] ; 0x7c
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
116bc: e5843080 str r3, [r4, #128] ; 0x80
fs_info->index = 0;
116c0: e5845078 str r5, [r4, #120] ; 0x78
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
116c4: e3a01001 mov r1, #1 116c8: ebffc99f bl 3d4c <calloc>
if ( fs_info->uino == NULL )
116cc: e3500000 cmp r0, #0
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));
116d0: e5840074 str r0, [r4, #116] ; 0x74
if ( fs_info->uino == NULL )
116d4: 1a00000a bne 11704 <fat_init_volume_info+0x5dc>
116d8: ea000003 b 116ec <fat_init_volume_info+0x5c4> <== 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 )
{
close(vol->fd);
116dc: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 116e0: ebffc9ab bl 3d94 <close> <== NOT EXECUTED
free(fs_info->vhash);
116e4: e594006c ldr r0, [r4, #108] ; 0x6c <== NOT EXECUTED 116e8: ea000012 b 11738 <fat_init_volume_info+0x610> <== 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 )
{
close(vol->fd);
116ec: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 116f0: ebffc9a7 bl 3d94 <close> <== NOT EXECUTED
free(fs_info->vhash);
116f4: e594006c ldr r0, [r4, #108] ; 0x6c <== NOT EXECUTED 116f8: ebffca47 bl 401c <free> <== NOT EXECUTED
free(fs_info->rhash);
116fc: e5940070 ldr r0, [r4, #112] ; 0x70 <== NOT EXECUTED 11700: ea00000c b 11738 <fat_init_volume_info+0x610> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
11704: e1d400b0 ldrh r0, [r4] 11708: e3a01001 mov r1, #1 1170c: ebffc98e bl 3d4c <calloc>
if (fs_info->sec_buf == NULL)
11710: e3500000 cmp r0, #0
close(vol->fd);
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));
11714: e5840090 str r0, [r4, #144] ; 0x90
if (fs_info->sec_buf == NULL)
11718: 1a00000a bne 11748 <fat_init_volume_info+0x620>
{
close(vol->fd);
1171c: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 11720: ebffc99b bl 3d94 <close> <== NOT EXECUTED
free(fs_info->vhash);
11724: e594006c ldr r0, [r4, #108] ; 0x6c <== NOT EXECUTED 11728: ebffca3b bl 401c <free> <== NOT EXECUTED
free(fs_info->rhash);
1172c: e5940070 ldr r0, [r4, #112] ; 0x70 <== NOT EXECUTED 11730: ebffca39 bl 401c <free> <== NOT EXECUTED
free(fs_info->uino);
11734: e5940074 ldr r0, [r4, #116] ; 0x74 <== NOT EXECUTED 11738: ebffca37 bl 401c <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
1173c: eb001c49 bl 18868 <__errno> <== NOT EXECUTED 11740: e3a0300c mov r3, #12 <== NOT EXECUTED 11744: eafffe8a b 11174 <fat_init_volume_info+0x4c> <== NOT EXECUTED
return bytes_written;
}
static bool is_cluster_aligned(const fat_vol_t *vol, uint32_t sec_num)
{
return (sec_num & (vol->spc - 1)) == 0;
11748: e5d43004 ldrb r3, [r4, #4] 1174c: e5940034 ldr r0, [r4, #52] ; 0x34 11750: e2433001 sub r3, r3, #1
/*
* If possible we will use the cluster size as bdbuf block size for faster
* file access. This requires that certain sectors are aligned to cluster
* borders.
*/
if (is_cluster_aligned(vol, vol->data_fsec)
11754: e0130000 ands r0, r3, r0
vol->bytes_per_block_log2 = vol->bpc_log2;
vol->sectors_per_block = vol->spc;
}
}
return RC_OK;
11758: 11a00005 movne r0, r5
/*
* If possible we will use the cluster size as bdbuf block size for faster
* file access. This requires that certain sectors are aligned to cluster
* borders.
*/
if (is_cluster_aligned(vol, vol->data_fsec)
1175c: 1a000011 bne 117a8 <fat_init_volume_info+0x680>
&& (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
11760: e5d4200e ldrb r2, [r4, #14] 11764: e3520004 cmp r2, #4
11768: 0a000002 beq 11778 <fat_init_volume_info+0x650>
return bytes_written;
}
static bool is_cluster_aligned(const fat_vol_t *vol, uint32_t sec_num)
{
return (sec_num & (vol->spc - 1)) == 0;
1176c: e5942020 ldr r2, [r4, #32]
* If possible we will use the cluster size as bdbuf block size for faster
* file access. This requires that certain sectors are aligned to cluster
* borders.
*/
if (is_cluster_aligned(vol, vol->data_fsec)
&& (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
11770: e1130002 tst r3, r2
11774: 1a00000b bne 117a8 <fat_init_volume_info+0x680>
{
sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true);
11778: e5940064 ldr r0, [r4, #100] ; 0x64 1177c: e1d410b6 ldrh r1, [r4, #6] 11780: e3a02001 mov r2, #1 11784: ebfff73e bl f484 <rtems_bdbuf_set_block_size>
if (sc == RTEMS_SUCCESSFUL)
11788: e3500000 cmp r0, #0
{
vol->bytes_per_block = vol->bpc;
1178c: 01d430b6 ldrheq r3, [r4, #6] 11790: 01c430ba strheq r3, [r4, #10]
vol->bytes_per_block_log2 = vol->bpc_log2;
11794: 05d43008 ldrbeq r3, [r4, #8] 11798: 05c4300c strbeq r3, [r4, #12]
vol->sectors_per_block = vol->spc;
1179c: 05d43004 ldrbeq r3, [r4, #4] 117a0: 05c43009 strbeq r3, [r4, #9]
}
}
return RC_OK;
117a4: 13a00000 movne r0, #0
}
117a8: e28dd0ac add sp, sp, #172 ; 0xac
117ac: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00016e84 <fat_scan_fat_for_free_clusters>:
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl,
bool zero_fill
)
{
16e84: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
uint32_t i = 2;
ssize_t bytes_written;
*cls_added = 0;
if (count == 0)
16e88: e3520000 cmp r2, #0
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl,
bool zero_fill
)
{
16e8c: e24dd014 sub sp, sp, #20 16e90: e1a06003 mov r6, r3
int rc = RC_OK;
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;
16e94: e590b038 ldr fp, [r0, #56] ; 0x38
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl,
bool zero_fill
)
{
16e98: e5dd303c ldrb r3, [sp, #60] ; 0x3c
uint32_t i = 2;
ssize_t bytes_written;
*cls_added = 0;
if (count == 0)
16e9c: e58d2008 str r2, [sp, #8]
bool zero_fill
)
{
int rc = RC_OK;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
16ea0: e3a0a000 mov sl, #0
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl,
bool zero_fill
)
{
16ea4: e1a04000 mov r4, r0 16ea8: e1a08001 mov r8, r1 16eac: e58d300c str r3, [sp, #12]
int rc = RC_OK;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
16eb0: e58da010 str sl, [sp, #16]
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
16eb4: e28bb002 add fp, fp, #2
uint32_t i = 2;
ssize_t bytes_written;
*cls_added = 0;
16eb8: e586a000 str sl, [r6]
if (count == 0)
return rc;
16ebc: 059d7008 ldreq r7, [sp, #8]
uint32_t i = 2;
ssize_t bytes_written;
*cls_added = 0;
if (count == 0)
16ec0: 0a00006e beq 17080 <fat_scan_fat_for_free_clusters+0x1fc>
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
16ec4: e590504c ldr r5, [r0, #76] ; 0x4c
uint32_t *last_cl,
bool zero_fill
)
{
int rc = RC_OK;
uint32_t cl4find = 2;
16ec8: e3750001 cmn r5, #1 16ecc: 03a05002 moveq r5, #2
}
}
i++;
cl4find++;
if (cl4find >= data_cls_val)
cl4find = 2;
16ed0: e3a09002 mov r9, #2 16ed4: ea00004e b 17014 <fat_scan_fat_for_free_clusters+0x190>
* 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(fs_info, cl4find, &next_cln);
16ed8: e1a00004 mov r0, r4 16edc: e1a01005 mov r1, r5 16ee0: e28d2010 add r2, sp, #16 16ee4: ebfffee3 bl 16a78 <fat_get_fat_cluster>
if ( rc != RC_OK )
16ee8: e2507000 subs r7, r0, #0
16eec: 0a000006 beq 16f0c <fat_scan_fat_for_free_clusters+0x88>
{
if (*cls_added != 0)
16ef0: e5963000 ldr r3, [r6] <== NOT EXECUTED 16ef4: e3530000 cmp r3, #0 <== NOT EXECUTED 16ef8: 0a000060 beq 17080 <fat_scan_fat_for_free_clusters+0x1fc> <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
16efc: e1a00004 mov r0, r4 <== NOT EXECUTED 16f00: e5981000 ldr r1, [r8] <== NOT EXECUTED 16f04: ebffffb1 bl 16dd0 <fat_free_fat_clusters_chain> <== NOT EXECUTED 16f08: ea00005c b 17080 <fat_scan_fat_for_free_clusters+0x1fc> <== NOT EXECUTED
return rc;
}
if (next_cln == FAT_GENFAT_FREE)
16f0c: e59d3010 ldr r3, [sp, #16] 16f10: e3530000 cmp r3, #0
16f14: 1a00003a bne 17004 <fat_scan_fat_for_free_clusters+0x180>
/*
* 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)
16f18: e5963000 ldr r3, [r6] 16f1c: e3530000 cmp r3, #0
16f20: 1a000007 bne 16f44 <fat_scan_fat_for_free_clusters+0xc0>
{
*chain = cl4find;
16f24: e5885000 str r5, [r8]
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
16f28: e1a00004 mov r0, r4 16f2c: e1a01005 mov r1, r5 16f30: e3e02000 mvn r2, #0 16f34: ebffff23 bl 16bc8 <fat_set_fat_cluster>
if ( rc != RC_OK )
16f38: e3500000 cmp r0, #0
16f3c: 0a000012 beq 16f8c <fat_scan_fat_for_free_clusters+0x108>
16f40: ea00004d b 1707c <fat_scan_fat_for_free_clusters+0x1f8> <== NOT EXECUTED
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
16f44: e1a00004 mov r0, r4 16f48: e1a01005 mov r1, r5 16f4c: e3e02000 mvn r2, #0 16f50: ebffff1c bl 16bc8 <fat_set_fat_cluster>
if ( rc != RC_OK )
16f54: e2503000 subs r3, r0, #0
{
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
16f58: e1a00004 mov r0, r4
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
if ( rc != RC_OK )
16f5c: 0a000005 beq 16f78 <fat_scan_fat_for_free_clusters+0xf4>
{
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
16f60: e5981000 ldr r1, [r8] <== NOT EXECUTED 16f64: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 16f68: ebffff98 bl 16dd0 <fat_free_fat_clusters_chain> <== NOT EXECUTED
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
16f6c: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 16f70: e1a07003 mov r7, r3 <== NOT EXECUTED
if ( rc != RC_OK )
{
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
return rc;
16f74: ea000041 b 17080 <fat_scan_fat_for_free_clusters+0x1fc> <== NOT EXECUTED
}
rc = fat_set_fat_cluster(fs_info, save_cln, cl4find);
16f78: e1a0100a mov r1, sl 16f7c: e1a02005 mov r2, r5 16f80: ebffff10 bl 16bc8 <fat_set_fat_cluster>
if ( rc != RC_OK )
16f84: e250a000 subs sl, r0, #0
16f88: 1a000030 bne 17050 <fat_scan_fat_for_free_clusters+0x1cc>
goto cleanup;
}
if (zero_fill)
16f8c: e59d200c ldr r2, [sp, #12] 16f90: e3520000 cmp r2, #0
16f94: 0a000008 beq 16fbc <fat_scan_fat_for_free_clusters+0x138>
{
bytes_written = fat_cluster_set (fs_info, cl4find, 0, fs_info->vol.bpc, 0);
16f98: e1d430b6 ldrh r3, [r4, #6] 16f9c: e3a02000 mov r2, #0 16fa0: e1a00004 mov r0, r4 16fa4: e1a01005 mov r1, r5 16fa8: e58d2000 str r2, [sp] 16fac: ebffe7dd bl 10f28 <fat_cluster_set>
if (fs_info->vol.bpc != bytes_written)
16fb0: e1d430b6 ldrh r3, [r4, #6] 16fb4: e1530000 cmp r3, r0
16fb8: 1a000023 bne 1704c <fat_scan_fat_for_free_clusters+0x1c8>
goto cleanup;
}
}
save_cln = cl4find;
(*cls_added)++;
16fbc: e5963000 ldr r3, [r6]
/* have we satisfied request ? */
if (*cls_added == count)
16fc0: e59d2008 ldr r2, [sp, #8]
goto cleanup;
}
}
save_cln = cl4find;
(*cls_added)++;
16fc4: e2833001 add r3, r3, #1
/* have we satisfied request ? */
if (*cls_added == count)
16fc8: e1530002 cmp r3, r2
goto cleanup;
}
}
save_cln = cl4find;
(*cls_added)++;
16fcc: e5863000 str r3, [r6]
/* have we satisfied request ? */
if (*cls_added == count)
16fd0: 1a00000a bne 17000 <fat_scan_fat_for_free_clusters+0x17c>
{
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
16fd4: e5943044 ldr r3, [r4, #68] ; 0x44
(*cls_added)++;
/* have we satisfied request ? */
if (*cls_added == count)
{
fs_info->vol.next_cl = save_cln;
16fd8: e584504c str r5, [r4, #76] ; 0x4c
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
16fdc: e3730001 cmn r3, #1
fs_info->vol.free_cls -= (*cls_added);
16fe0: 15962000 ldrne r2, [r6] 16fe4: 10623003 rsbne r3, r2, r3 16fe8: 15843044 strne r3, [r4, #68] ; 0x44
*last_cl = save_cln;
16fec: e59d3038 ldr r3, [sp, #56] ; 0x38
fat_buf_release(fs_info);
16ff0: e1a00004 mov r0, r4
if (*cls_added == count)
{
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
fs_info->vol.free_cls -= (*cls_added);
*last_cl = save_cln;
16ff4: e5835000 str r5, [r3]
fat_buf_release(fs_info);
16ff8: ebffe6f2 bl 10bc8 <fat_buf_release>
return rc;
16ffc: ea00001f b 17080 <fat_scan_fat_for_free_clusters+0x1fc>
save_cln = cl4find;
(*cls_added)++;
/* have we satisfied request ? */
if (*cls_added == count)
17000: e1a0a005 mov sl, r5
fat_buf_release(fs_info);
return rc;
}
}
i++;
cl4find++;
17004: e2855001 add r5, r5, #1
if (cl4find >= data_cls_val)
cl4find = 2;
17008: e155000b cmp r5, fp
*last_cl = save_cln;
fat_buf_release(fs_info);
return rc;
}
}
i++;
1700c: e2899001 add r9, r9, #1
cl4find++;
if (cl4find >= data_cls_val)
cl4find = 2;
17010: 23a05002 movcs r5, #2
/*
* 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)
17014: e159000b cmp r9, fp
17018: 3affffae bcc 16ed8 <fat_scan_fat_for_free_clusters+0x54>
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
1701c: e5943044 ldr r3, [r4, #68] ; 0x44 <== NOT EXECUTED
cl4find++;
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
17020: e584a04c str sl, [r4, #76] ; 0x4c <== NOT EXECUTED
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
17024: e3730001 cmn r3, #1 <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
17028: 15962000 ldrne r2, [r6] <== NOT EXECUTED 1702c: 10623003 rsbne r3, r2, r3 <== NOT EXECUTED
*last_cl = save_cln;
17030: e59d2038 ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
fs_info->vol.free_cls -= (*cls_added);
17034: 15843044 strne r3, [r4, #68] ; 0x44 <== NOT EXECUTED
*last_cl = save_cln;
fat_buf_release(fs_info);
17038: e1a00004 mov r0, r4 <== NOT EXECUTED
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
fs_info->vol.free_cls -= (*cls_added);
*last_cl = save_cln;
1703c: e582a000 str sl, [r2] <== NOT EXECUTED
fat_buf_release(fs_info);
17040: ebffe6e0 bl 10bc8 <fat_buf_release> <== NOT EXECUTED
return RC_OK;
17044: e3a07000 mov r7, #0 <== NOT EXECUTED 17048: ea00000c b 17080 <fat_scan_fat_for_free_clusters+0x1fc> <== NOT EXECUTED
if (zero_fill)
{
bytes_written = fat_cluster_set (fs_info, cl4find, 0, fs_info->vol.bpc, 0);
if (fs_info->vol.bpc != bytes_written)
{
rc = -1;
1704c: e3e0a000 mvn sl, #0 <== NOT EXECUTED
return RC_OK;
cleanup:
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
17050: e5981000 ldr r1, [r8] <== NOT EXECUTED 17054: e1a00004 mov r0, r4 <== NOT EXECUTED 17058: ebffff5c bl 16dd0 <fat_free_fat_clusters_chain> <== NOT EXECUTED
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
1705c: e1a01005 mov r1, r5 <== NOT EXECUTED 17060: e3a02000 mov r2, #0 <== NOT EXECUTED 17064: e1a00004 mov r0, r4 <== NOT EXECUTED 17068: ebfffed6 bl 16bc8 <fat_set_fat_cluster> <== NOT EXECUTED
fat_buf_release(fs_info);
1706c: e1a00004 mov r0, r4 <== NOT EXECUTED 17070: ebffe6d4 bl 10bc8 <fat_buf_release> <== NOT EXECUTED
return rc;
17074: e1a0700a mov r7, sl <== NOT EXECUTED 17078: ea000000 b 17080 <fat_scan_fat_for_free_clusters+0x1fc> <== NOT EXECUTED
* wouldn't work properly
*/
if (*cls_added == 0)
{
*chain = cl4find;
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
1707c: e1a07000 mov r7, r0 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
fat_buf_release(fs_info);
return rc;
}
17080: e1a00007 mov r0, r7
17084: e28dd014 add sp, sp, #20
17088: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00010e88 <fat_sector_write>:
fat_fs_info_t *fs_info,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
10e88: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
10e8c: e1a05000 mov r5, r0
10e90: e1a06003 mov r6, r3
int rc = RC_OK;
ssize_t cmpltd = 0;
uint32_t sec_num = start;
uint32_t ofs = offset;
10e94: e1a09002 mov r9, r2
uint32_t count,
const void *buff)
{
int rc = RC_OK;
ssize_t cmpltd = 0;
uint32_t sec_num = start;
10e98: e1a08001 mov r8, r1
uint32_t offset,
uint32_t count,
const void *buff)
{
int rc = RC_OK;
ssize_t cmpltd = 0;
10e9c: e3a04000 mov r4, #0
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bytes_per_block)
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
10ea0: e3a0b001 mov fp, #1
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
10ea4: ea000019 b 10f10 <fat_sector_write+0x88>
{
c = MIN(count, (fs_info->vol.bps - ofs));
10ea8: e1d570b0 ldrh r7, [r5]
if (c == fs_info->vol.bytes_per_block)
10eac: e1d530ba ldrh r3, [r5, #10]
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
{
c = MIN(count, (fs_info->vol.bps - ofs));
10eb0: e0697007 rsb r7, r9, r7 10eb4: e1570006 cmp r7, r6 10eb8: 21a07006 movcs r7, r6
if (c == fs_info->vol.bytes_per_block)
10ebc: e1570003 cmp r7, r3
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
10ec0: 03a02002 moveq r2, #2
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
10ec4: 13a02001 movne r2, #1
while(count > 0)
{
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bytes_per_block)
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
10ec8: e1a00005 mov r0, r5 10ecc: e1a01008 mov r1, r8
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
10ed0: e1a0300d mov r3, sp 10ed4: ebffff9e bl 10d54 <fat_buf_access>
if (rc != RC_OK)
10ed8: e3500000 cmp r0, #0
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bytes_per_block)
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
10edc: e1a0a000 mov sl, r0
if (rc != RC_OK)
10ee0: 1a00000d bne 10f1c <fat_sector_write+0x94>
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
10ee4: e59d0000 ldr r0, [sp] 10ee8: e59d3028 ldr r3, [sp, #40] ; 0x28 10eec: e0800009 add r0, r0, r9 10ef0: e0831004 add r1, r3, r4 10ef4: e1a02007 mov r2, r7 10ef8: eb002101 bl 19304 <memcpy>
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
10efc: e5c5b088 strb fp, [r5, #136] ; 0x88
fat_buf_mark_modified(fs_info);
count -= c;
10f00: e0676006 rsb r6, r7, r6
cmpltd +=c;
10f04: e0874004 add r4, r7, r4
sec_num++;
10f08: e2888001 add r8, r8, #1
ofs = 0;
10f0c: e1a0900a mov r9, sl
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
10f10: e3560000 cmp r6, #0
10f14: 1affffe3 bne 10ea8 <fat_sector_write+0x20>
10f18: ea000000 b 10f20 <fat_sector_write+0x98>
if (c == fs_info->vol.bytes_per_block)
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return -1;
10f1c: e3e04000 mvn r4, #0 <== NOT EXECUTED
cmpltd +=c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
10f20: e1a00004 mov r0, r4
10f24: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
00016bc8 <fat_set_fat_cluster>:
fat_set_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t in_val
)
{
16bc8: e92d47f1 push {r0, r4, r5, r6, r7, r8, r9, sl, lr}
int rc = RC_OK;
uint32_t sec = 0;
uint32_t ofs = 0;
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
uint8_t *sec_buf = NULL;
16bcc: e3a03000 mov r3, #0
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
16bd0: e3510001 cmp r1, #1
fat_set_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t in_val
)
{
16bd4: e1a04000 mov r4, r0 16bd8: e1a05001 mov r5, r1 16bdc: e1a09002 mov r9, r2
int rc = RC_OK;
uint32_t sec = 0;
uint32_t ofs = 0;
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
uint8_t *sec_buf = NULL;
16be0: e58d3000 str r3, [sp]
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
16be4: 9a000074 bls 16dbc <fat_set_fat_cluster+0x1f4>
16be8: e5903038 ldr r3, [r0, #56] ; 0x38 16bec: e2833001 add r3, r3, #1 16bf0: e1510003 cmp r1, r3
16bf4: 8a000070 bhi 16dbc <fat_set_fat_cluster+0x1f4>
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
16bf8: e5d0300e ldrb r3, [r0, #14] 16bfc: e2131001 ands r1, r3, #1 16c00: 108520a5 addne r2, r5, r5, lsr #1
16c04: 1a000002 bne 16c14 <fat_set_fat_cluster+0x4c>
16c08: e3130002 tst r3, #2 16c0c: 11a02085 lslne r2, r5, #1 16c10: 01a02105 lsleq r2, r5, #2 16c14: e5d48002 ldrb r8, [r4, #2] 16c18: e5940058 ldr r0, [r4, #88] ; 0x58
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
16c1c: e3510000 cmp r1, #0
/* 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) +
16c20: e0808832 add r8, r0, r2, lsr r8
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
16c24: 108560a5 addne r6, r5, r5, lsr #1
16c28: 1a000002 bne 16c38 <fat_set_fat_cluster+0x70>
16c2c: e3130002 tst r3, #2 16c30: 11a06085 lslne r6, r5, #1 16c34: 01a06105 lsleq r6, r5, #2
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
16c38: e1a00004 mov r0, r4 16c3c: e1a01008 mov r1, r8 16c40: e3a02001 mov r2, #1 16c44: e1a0300d mov r3, sp
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);
16c48: e1d470b0 ldrh r7, [r4]
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
16c4c: ebffe840 bl 10d54 <fat_buf_access>
if (rc != RC_OK)
16c50: e3500000 cmp r0, #0
16c54: 1a00005c bne 16dcc <fat_set_fat_cluster+0x204>
return rc;
switch ( fs_info->vol.type )
16c58: e5d4a00e ldrb sl, [r4, #14]
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);
16c5c: e2477001 sub r7, r7, #1
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
16c60: e35a0002 cmp sl, #2
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);
16c64: e0066007 and r6, r6, r7
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
16c68: 0a000047 beq 16d8c <fat_set_fat_cluster+0x1c4>
16c6c: e35a0004 cmp sl, #4
16c70: 0a000048 beq 16d98 <fat_set_fat_cluster+0x1d0>
16c74: e35a0001 cmp sl, #1
16c78: 1a00004f bne 16dbc <fat_set_fat_cluster+0x1f4>
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
16c7c: e3150001 tst r5, #1 16c80: e1a09a09 lsl r9, r9, #20
16c84: 0a000019 beq 16cf0 <fat_set_fat_cluster+0x128>
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*(sec_buf + ofs) &= 0x0F;
16c88: e59d3000 ldr r3, [sp] 16c8c: e7d32006 ldrb r2, [r3, r6] 16c90: e202200f and r2, r2, #15 16c94: e7c32006 strb r2, [r3, r6]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);
16c98: e59d3000 ldr r3, [sp] 16c9c: e7d32006 ldrb r2, [r3, r6] 16ca0: e1822829 orr r2, r2, r9, lsr #16 16ca4: e7c32006 strb r2, [r3, r6]
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
16ca8: e1d430b0 ldrh r3, [r4] 16cac: e2433001 sub r3, r3, #1 16cb0: e1560003 cmp r6, r3
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0x00;
16cb4: 159d3000 ldrne r3, [sp] 16cb8: 12866001 addne r6, r6, #1
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
16cbc: e5c4a088 strb sl, [r4, #136] ; 0x88 16cc0: 17c30006 strbne r0, [r3, r6]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
16cc4: 1a00002b bne 16d78 <fat_set_fat_cluster+0x1b0>
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
16cc8: e1a0300d mov r3, sp <== NOT EXECUTED 16ccc: e1a00004 mov r0, r4 <== NOT EXECUTED 16cd0: e2881001 add r1, r8, #1 <== NOT EXECUTED 16cd4: e1a0200a mov r2, sl <== NOT EXECUTED 16cd8: ebffe81d bl 10d54 <fat_buf_access> <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
16cdc: e3500000 cmp r0, #0 <== NOT EXECUTED
return rc;
*sec_buf &= 0x00;
16ce0: 059d3000 ldreq r3, [sp] <== NOT EXECUTED 16ce4: 05c30000 strbeq r0, [r3] <== NOT EXECUTED
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&sec_buf);
if (rc != RC_OK)
16ce8: 0a000017 beq 16d4c <fat_set_fat_cluster+0x184> <== NOT EXECUTED 16cec: ea000036 b 16dcc <fat_set_fat_cluster+0x204> <== NOT EXECUTED
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*(sec_buf + ofs) &= 0x00;
16cf0: e59d3000 ldr r3, [sp] 16cf4: e7c30006 strb r0, [r3, r6]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
16cf8: e59d3000 ldr r3, [sp] 16cfc: e7d32006 ldrb r2, [r3, r6]
*(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8);
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
16d00: e1a09229 lsr r9, r9, #4
*(sec_buf + ofs) &= 0x00;
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
16d04: e1822829 orr r2, r2, r9, lsr #16 16d08: e7c32006 strb r2, [r3, r6]
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
16d0c: e1d430b0 ldrh r3, [r4] 16d10: e2433001 sub r3, r3, #1 16d14: e1560003 cmp r6, r3 16d18: e5c4a088 strb sl, [r4, #136] ; 0x88
16d1c: 1a000010 bne 16d64 <fat_set_fat_cluster+0x19c>
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
16d20: e1a00004 mov r0, r4 <== NOT EXECUTED 16d24: e2881001 add r1, r8, #1 <== NOT EXECUTED 16d28: e1a0200a mov r2, sl <== NOT EXECUTED 16d2c: e1a0300d mov r3, sp <== NOT EXECUTED 16d30: ebffe807 bl 10d54 <fat_buf_access> <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
16d34: e3500000 cmp r0, #0 <== NOT EXECUTED 16d38: 1a000023 bne 16dcc <fat_set_fat_cluster+0x204> <== NOT EXECUTED
return rc;
*sec_buf &= 0xF0;
16d3c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 16d40: e5d32000 ldrb r2, [r3] <== NOT EXECUTED 16d44: e3c2200f bic r2, r2, #15 <== NOT EXECUTED 16d48: e5c32000 strb r2, [r3] <== NOT EXECUTED
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
16d4c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 16d50: e5d32000 ldrb r2, [r3] <== NOT EXECUTED 16d54: e1829c29 orr r9, r2, r9, lsr #24 <== NOT EXECUTED 16d58: e5c39000 strb r9, [r3] <== NOT EXECUTED 16d5c: e5c4a088 strb sl, [r4, #136] ; 0x88 <== NOT EXECUTED 16d60: ea000019 b 16dcc <fat_set_fat_cluster+0x204> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0xF0;
16d64: e59d3000 ldr r3, [sp] 16d68: e2866001 add r6, r6, #1 16d6c: e7d32006 ldrb r2, [r3, r6] 16d70: e3c2200f bic r2, r2, #15 16d74: e7c32006 strb r2, [r3, r6]
*(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
16d78: e59d3000 ldr r3, [sp] 16d7c: e7d32006 ldrb r2, [r3, r6] 16d80: e1829c29 orr r9, r2, r9, lsr #24 16d84: e7c39006 strb r9, [r3, r6] 16d88: ea00000f b 16dcc <fat_set_fat_cluster+0x204>
}
}
break;
case FAT_FAT16:
*((uint16_t *)(sec_buf + ofs)) =
16d8c: e59d3000 ldr r3, [sp]
(uint16_t )(CT_LE_W(in_val));
16d90: e18390b6 strh r9, [r3, r6] 16d94: ea000005 b 16db0 <fat_set_fat_cluster+0x1e8>
break;
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
*((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
16d98: e59d3000 ldr r3, [sp] 16d9c: e7932006 ldr r2, [r3, r6]
(uint16_t )(CT_LE_W(in_val));
fat_buf_mark_modified(fs_info);
break;
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
16da0: e3c9920f bic r9, r9, #-268435456 ; 0xf0000000
*((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
16da4: e202220f and r2, r2, #-268435456 ; 0xf0000000
*((uint32_t *)(sec_buf + ofs)) |= fat32_clv;
16da8: e1829009 orr r9, r2, r9 16dac: e7839006 str r9, [r3, r6] 16db0: e3a03001 mov r3, #1 16db4: e5c43088 strb r3, [r4, #136] ; 0x88 16db8: ea000003 b 16dcc <fat_set_fat_cluster+0x204>
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
16dbc: eb0006a9 bl 18868 <__errno> <== NOT EXECUTED 16dc0: e3a03005 mov r3, #5 <== NOT EXECUTED 16dc4: e5803000 str r3, [r0] <== NOT EXECUTED 16dc8: e3e00000 mvn r0, #0 <== NOT EXECUTED
break;
}
return RC_OK;
}
16dcc: e8bd87f8 pop {r3, r4, r5, r6, r7, r8, r9, sl, pc}
00011878 <fat_shutdown_drive>:
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_shutdown_drive(fat_fs_info_t *fs_info)
{
11878: e92d41f0 push {r4, r5, r6, r7, r8, lr}
1187c: e1a04000 mov r4, r0
int rc = RC_OK;
int i = 0;
rc = fat_sync(fs_info);
11880: ebffffd0 bl 117c8 <fat_sync>
if ( rc != RC_OK )
rc = -1;
11884: e2505000 subs r5, r0, #0 11888: 13e05000 mvnne r5, #0 1188c: e3a07000 mov r7, #0
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
11890: e594806c ldr r8, [r4, #108] ; 0x6c 11894: e0888007 add r8, r8, r7
while ( (node = rtems_chain_get(the_chain)) != NULL )
11898: ea000000 b 118a0 <fat_shutdown_drive+0x28>
free(node);
1189c: ebffc9de bl 401c <free> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
118a0: e1a00008 mov r0, r8 118a4: ebffdc9b bl 8b18 <_Chain_Get>
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 )
118a8: e2506000 subs r6, r0, #0
118ac: 1afffffa bne 1189c <fat_shutdown_drive+0x24>
118b0: e287700c add r7, r7, #12
rc = fat_sync(fs_info);
if ( rc != RC_OK )
rc = -1;
for (i = 0; i < FAT_HASH_SIZE; i++)
118b4: e3570018 cmp r7, #24
118b8: 1afffff4 bne 11890 <fat_shutdown_drive+0x18>
}
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
118bc: e5947070 ldr r7, [r4, #112] ; 0x70 118c0: e0877006 add r7, r7, r6
while ( (node = rtems_chain_get(the_chain)) != NULL )
118c4: ea000000 b 118cc <fat_shutdown_drive+0x54>
free(node);
118c8: ebffc9d3 bl 401c <free> <== NOT EXECUTED
118cc: e1a00007 mov r0, r7 118d0: ebffdc90 bl 8b18 <_Chain_Get>
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 )
118d4: e3500000 cmp r0, #0
118d8: 1afffffa bne 118c8 <fat_shutdown_drive+0x50>
118dc: e286600c add r6, r6, #12
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
for (i = 0; i < FAT_HASH_SIZE; i++)
118e0: e3560018 cmp r6, #24
118e4: 1afffff4 bne 118bc <fat_shutdown_drive+0x44>
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
118e8: e594006c ldr r0, [r4, #108] ; 0x6c 118ec: ebffc9ca bl 401c <free>
free(fs_info->rhash);
118f0: e5940070 ldr r0, [r4, #112] ; 0x70 118f4: ebffc9c8 bl 401c <free>
free(fs_info->uino);
118f8: e5940074 ldr r0, [r4, #116] ; 0x74 118fc: ebffc9c6 bl 401c <free>
free(fs_info->sec_buf);
11900: e5940090 ldr r0, [r4, #144] ; 0x90 11904: ebffc9c4 bl 401c <free>
close(fs_info->vol.fd);
11908: e5940060 ldr r0, [r4, #96] ; 0x60 1190c: ebffc920 bl 3d94 <close>
if (rc)
11910: e3550000 cmp r5, #0
11914: 0a000002 beq 11924 <fat_shutdown_drive+0xac>
errno = EIO;
11918: eb001bd2 bl 18868 <__errno> <== NOT EXECUTED 1191c: e3a03005 mov r3, #5 <== NOT EXECUTED 11920: e5803000 str r3, [r0] <== NOT EXECUTED
return rc;
}
11924: e1a00005 mov r0, r5
11928: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
000117c8 <fat_sync>:
return RC_OK;
}
int
fat_sync(fat_fs_info_t *fs_info)
{
117c8: e92d4073 push {r0, r1, r4, r5, r6, lr}
static int
fat_fat32_update_fsinfo_sector(fat_fs_info_t *fs_info)
{
ssize_t ret1 = 0, ret2 = 0;
if (fs_info->vol.type == FAT_FAT32)
117cc: e5d0300e ldrb r3, [r0, #14] 117d0: e3530004 cmp r3, #4
return RC_OK;
}
int
fat_sync(fat_fs_info_t *fs_info)
{
117d4: e1a04000 mov r4, r0
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
static int
fat_fat32_update_fsinfo_sector(fat_fs_info_t *fs_info)
{
ssize_t ret1 = 0, ret2 = 0;
117d8: 13a00000 movne r0, #0 117dc: 11a05000 movne r5, r0
if (fs_info->vol.type == FAT_FAT32)
117e0: 1a000019 bne 1184c <fat_sync+0x84>
{
uint32_t free_count = fs_info->vol.free_cls;
uint32_t next_free = fs_info->vol.next_cl;
if (free_count != fs_info->vol.free_cls_in_fs_info)
117e4: e2841044 add r1, r4, #68 ; 0x44
117e8: e8910046 ldm r1, {r1, r2, r6}
117ec: e1510002 cmp r1, r2
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
static int
fat_fat32_update_fsinfo_sector(fat_fs_info_t *fs_info)
{
ssize_t ret1 = 0, ret2 = 0;
117f0: 03a05000 moveq r5, #0
if (fs_info->vol.type == FAT_FAT32)
{
uint32_t free_count = fs_info->vol.free_cls;
uint32_t next_free = fs_info->vol.next_cl;
if (free_count != fs_info->vol.free_cls_in_fs_info)
117f4: 0a000007 beq 11818 <fat_sync+0x50>
{
uint32_t le_free_count = CT_LE_L(free_count);
117f8: e28d2008 add r2, sp, #8 <== NOT EXECUTED 117fc: e5221004 str r1, [r2, #-4]! <== NOT EXECUTED
fs_info->vol.free_cls_in_fs_info = free_count;
11800: e5841048 str r1, [r4, #72] ; 0x48 <== NOT EXECUTED
ret1 = fat_sector_write(fs_info,
11804: e58d2000 str r2, [sp] <== NOT EXECUTED 11808: e1d414b0 ldrh r1, [r4, #64] ; 0x40 <== NOT EXECUTED 1180c: e3a02f7a mov r2, #488 ; 0x1e8 <== NOT EXECUTED 11810: ebfffd9c bl 10e88 <fat_sector_write> <== NOT EXECUTED 11814: e1a05000 mov r5, r0 <== NOT EXECUTED
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
sizeof(le_free_count),
&le_free_count);
}
if (next_free != fs_info->vol.next_cl_in_fs_info)
11818: e5943050 ldr r3, [r4, #80] ; 0x50 1181c: e1560003 cmp r6, r3
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
static int
fat_fat32_update_fsinfo_sector(fat_fs_info_t *fs_info)
{
ssize_t ret1 = 0, ret2 = 0;
11820: 03a00000 moveq r0, #0
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
sizeof(le_free_count),
&le_free_count);
}
if (next_free != fs_info->vol.next_cl_in_fs_info)
11824: 0a000008 beq 1184c <fat_sync+0x84>
{
uint32_t le_next_free = CT_LE_L(next_free);
11828: e28d3008 add r3, sp, #8 1182c: e5236004 str r6, [r3, #-4]!
fs_info->vol.next_cl_in_fs_info = next_free;
11830: e5846050 str r6, [r4, #80] ; 0x50
ret2 = fat_sector_write(fs_info,
11834: e58d3000 str r3, [sp] 11838: e1d414b0 ldrh r1, [r4, #64] ; 0x40 1183c: e1a00004 mov r0, r4 11840: e3a02f7b mov r2, #492 ; 0x1ec 11844: e3a03004 mov r3, #4 11848: ebfffd8e bl 10e88 <fat_sector_write>
sizeof(le_next_free),
&le_next_free);
}
}
if ( (ret1 < 0) || (ret2 < 0) )
1184c: e1a05fa5 lsr r5, r5, #31
{
int rc = RC_OK;
rc = fat_fat32_update_fsinfo_sector(fs_info);
if ( rc != RC_OK )
rc = -1;
11850: e1955fa0 orrs r5, r5, r0, lsr #31
fat_buf_release(fs_info);
11854: e1a00004 mov r0, r4
{
int rc = RC_OK;
rc = fat_fat32_update_fsinfo_sector(fs_info);
if ( rc != RC_OK )
rc = -1;
11858: 13e05000 mvnne r5, #0
fat_buf_release(fs_info);
1185c: ebfffcd9 bl 10bc8 <fat_buf_release>
if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)
11860: e5940064 ldr r0, [r4, #100] ; 0x64 11864: ebfff681 bl f270 <rtems_bdbuf_syncdev>
rc = -1;
11868: e3500000 cmp r0, #0
return rc;
}
1186c: 01a00005 moveq r0, r5
11870: 13e00000 mvnne r0, #0
11874: e8bd807c pop {r2, r3, r4, r5, r6, pc}
00020478 <fchmod>:
int fchmod( int fd, mode_t mode )
{
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
20478: e59f309c ldr r3, [pc, #156] ; 2051c <fchmod+0xa4> 2047c: e5933000 ldr r3, [r3] 20480: e1500003 cmp r0, r3
/**
* POSIX 1003.1b 5.6.4 - Change File Modes
*/
int fchmod( int fd, mode_t mode )
{
20484: e92d4030 push {r4, r5, lr}
20488: e1a05001 mov r5, r1
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2048c: 2a000006 bcs 204ac <fchmod+0x34>
iop = rtems_libio_iop( fd );
20490: e59f3088 ldr r3, [pc, #136] ; 20520 <fchmod+0xa8> 20494: e5933000 ldr r3, [r3] 20498: e3a04030 mov r4, #48 ; 0x30 2049c: e0243490 mla r4, r0, r4, r3
rtems_libio_check_is_open(iop);
204a0: e594300c ldr r3, [r4, #12] 204a4: e3130c01 tst r3, #256 ; 0x100
204a8: 1a000002 bne 204b8 <fchmod+0x40>
204ac: eb004506 bl 318cc <__errno> 204b0: e3a03009 mov r3, #9 204b4: ea000014 b 2050c <fchmod+0x94>
if (iop->pathinfo.mt_entry->writeable) {
204b8: e5940024 ldr r0, [r4, #36] ; 0x24 204bc: e5d03029 ldrb r3, [r0, #41] ; 0x29 204c0: e3530000 cmp r3, #0
204c4: 0a00000e beq 20504 <fchmod+0x8c>
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
(*mt_entry->ops->lock_h)( mt_entry );
204c8: e590300c ldr r3, [r0, #12] 204cc: e1a0e00f mov lr, pc 204d0: e593f000 ldr pc, [r3]
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode );
204d4: e5943024 ldr r3, [r4, #36] ; 0x24 204d8: e1a01005 mov r1, r5 204dc: e593300c ldr r3, [r3, #12] 204e0: e2840010 add r0, r4, #16 204e4: e1a0e00f mov lr, pc 204e8: e593f020 ldr pc, [r3, #32] 204ec: e1a05000 mov r5, r0
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
204f0: e5940024 ldr r0, [r4, #36] ; 0x24
(*mt_entry->ops->unlock_h)( mt_entry );
204f4: e590300c ldr r3, [r0, #12] 204f8: e1a0e00f mov lr, pc 204fc: e593f004 ldr pc, [r3, #4] 20500: ea000003 b 20514 <fchmod+0x9c>
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
20504: eb0044f0 bl 318cc <__errno> <== NOT EXECUTED 20508: e3a0301e mov r3, #30 <== NOT EXECUTED
2050c: e5803000 str r3, [r0]
rv = -1;
20510: e3e05000 mvn r5, #0
}
return rv;
}
20514: e1a00005 mov r0, r5
20518: e8bd8030 pop {r4, r5, pc}
00020524 <fchown>:
int fchown( int fd, uid_t owner, gid_t group )
{
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
20524: e59f30ac ldr r3, [pc, #172] ; 205d8 <fchown+0xb4> 20528: e5933000 ldr r3, [r3]
/**
* POSIX 1003.1b 5.6.5 - Change Owner and Group of a File
*/
int fchown( int fd, uid_t owner, gid_t group )
{
2052c: e1a01801 lsl r1, r1, #16 20530: e1a02802 lsl r2, r2, #16
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
20534: e1500003 cmp r0, r3
/**
* POSIX 1003.1b 5.6.5 - Change Owner and Group of a File
*/
int fchown( int fd, uid_t owner, gid_t group )
{
20538: e92d4070 push {r4, r5, r6, lr}
2053c: e1a06821 lsr r6, r1, #16
20540: e1a05822 lsr r5, r2, #16
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
20544: 2a000006 bcs 20564 <fchown+0x40>
iop = rtems_libio_iop( fd );
20548: e59f308c ldr r3, [pc, #140] ; 205dc <fchown+0xb8> 2054c: e5933000 ldr r3, [r3] 20550: e3a04030 mov r4, #48 ; 0x30 20554: e0243490 mla r4, r0, r4, r3
rtems_libio_check_is_open(iop);
20558: e594300c ldr r3, [r4, #12] 2055c: e3130c01 tst r3, #256 ; 0x100
20560: 1a000002 bne 20570 <fchown+0x4c>
20564: eb0044d8 bl 318cc <__errno> 20568: e3a03009 mov r3, #9 2056c: ea000015 b 205c8 <fchown+0xa4>
if (iop->pathinfo.mt_entry->writeable) {
20570: e5940024 ldr r0, [r4, #36] ; 0x24 20574: e5d03029 ldrb r3, [r0, #41] ; 0x29 20578: e3530000 cmp r3, #0
2057c: 0a00000f beq 205c0 <fchown+0x9c>
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
(*mt_entry->ops->lock_h)( mt_entry );
20580: e590300c ldr r3, [r0, #12] 20584: e1a0e00f mov lr, pc 20588: e593f000 ldr pc, [r3]
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->chown_h)(
2058c: e5943024 ldr r3, [r4, #36] ; 0x24 20590: e1a02005 mov r2, r5 20594: e593300c ldr r3, [r3, #12] 20598: e2840010 add r0, r4, #16 2059c: e1a01006 mov r1, r6 205a0: e1a0e00f mov lr, pc 205a4: e593f024 ldr pc, [r3, #36] ; 0x24 205a8: e1a05000 mov r5, r0
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
205ac: e5940024 ldr r0, [r4, #36] ; 0x24
(*mt_entry->ops->unlock_h)( mt_entry );
205b0: e590300c ldr r3, [r0, #12] 205b4: e1a0e00f mov lr, pc 205b8: e593f004 ldr pc, [r3, #4] 205bc: ea000003 b 205d0 <fchown+0xac>
owner,
group
);
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
205c0: eb0044c1 bl 318cc <__errno> <== NOT EXECUTED 205c4: e3a0301e mov r3, #30 <== NOT EXECUTED
205c8: e5803000 str r3, [r0]
rv = -1;
205cc: e3e05000 mvn r5, #0
}
return rv;
}
205d0: e1a00005 mov r0, r5
205d4: e8bd8070 pop {r4, r5, r6, pc}
0002d150 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
2d150: e92d000e push {r1, r2, r3}
2d154: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr}
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
2d158: e59f21d8 ldr r2, [pc, #472] ; 2d338 <bsp_section_text_size+0x3c> 2d15c: e5922000 ldr r2, [r2]
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
2d160: e28d3020 add r3, sp, #32
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
2d164: e1500002 cmp r0, r2
int fcntl(
int fd,
int cmd,
...
)
{
2d168: e59d601c ldr r6, [sp, #28]
int ret; va_list ap; va_start( ap, cmd );
2d16c: e58d3000 str r3, [sp]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
2d170: 2a000006 bcs 2d190 <fcntl+0x40>
iop = rtems_libio_iop( fd );
2d174: e59f21c0 ldr r2, [pc, #448] ; 2d33c <bsp_section_text_size+0x40> 2d178: e5922000 ldr r2, [r2] 2d17c: e3a04030 mov r4, #48 ; 0x30 2d180: e0242490 mla r4, r0, r4, r2
rtems_libio_check_is_open(iop);
2d184: e594000c ldr r0, [r4, #12] 2d188: e3100c01 tst r0, #256 ; 0x100
2d18c: 1a000002 bne 2d19c <fcntl+0x4c>
2d190: ebffc10f bl 1d5d4 <__errno> 2d194: e3a03009 mov r3, #9 2d198: ea000054 b 2d2f0 <fcntl+0x1a0>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
2d19c: e3560009 cmp r6, #9 2d1a0: 979ff106 ldrls pc, [pc, r6, lsl #2] 2d1a4: ea00004f b 2d2e8 <fcntl+0x198> 2d1a8: 0002d1d0 .word 0x0002d1d0
2d1ac: 0002d274 .word 0x0002d274 <== NOT EXECUTED 2d1b0: 0002d284 .word 0x0002d284 <== NOT EXECUTED 2d1b4: 0002d2a4 .word 0x0002d2a4 <== NOT EXECUTED 2d1b8: 0002d2b0 .word 0x0002d2b0 <== NOT EXECUTED 2d1bc: 0002d2dc .word 0x0002d2dc <== NOT EXECUTED 2d1c0: 0002d2dc .word 0x0002d2dc <== NOT EXECUTED 2d1c4: 0002d2dc .word 0x0002d2dc <== NOT EXECUTED 2d1c8: 0002d2dc .word 0x0002d2dc <== NOT EXECUTED 2d1cc: 0002d2dc .word 0x0002d2dc <== NOT EXECUTED
/*
* FIXME: We ignore the start value fd2 for the file descriptor search. This
* is not POSIX conform.
*/
rtems_libio_t *diop = rtems_libio_allocate();
2d1d0: ebff6672 bl 6ba0 <rtems_libio_allocate>
if (diop != NULL) {
2d1d4: e2505000 subs r5, r0, #0
2d1d8: 0a000051 beq 2d324 <bsp_section_text_size+0x28>
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
2d1dc: e594000c ldr r0, [r4, #12] 2d1e0: ebff665d bl 6b5c <rtems_libio_to_fcntl_flags>
oflag &= ~O_CREAT;
2d1e4: e3c07c02 bic r7, r0, #512 ; 0x200
diop->flags |= rtems_libio_fcntl_flags( oflag );
2d1e8: e1a00007 mov r0, r7 2d1ec: e595800c ldr r8, [r5, #12] 2d1f0: ebff664c bl 6b28 <rtems_libio_fcntl_flags> 2d1f4: e1800008 orr r0, r0, r8 2d1f8: e585000c str r0, [r5, #12]
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
2d1fc: e5940024 ldr r0, [r4, #36] ; 0x24
(*mt_entry->ops->lock_h)( mt_entry );
2d200: e590300c ldr r3, [r0, #12] 2d204: e1a0e00f mov lr, pc 2d208: e593f000 ldr pc, [r3]
rtems_filesystem_instance_lock( &iop->pathinfo );
rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
2d20c: e2841010 add r1, r4, #16 2d210: e2850010 add r0, r5, #16 2d214: ebff9ca3 bl 144a8 <rtems_filesystem_location_clone>
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
2d218: e5940024 ldr r0, [r4, #36] ; 0x24
(*mt_entry->ops->unlock_h)( mt_entry );
2d21c: e590300c ldr r3, [r0, #12] 2d220: e1a0e00f mov lr, pc 2d224: e593f004 ldr pc, [r3, #4]
/*
* XXX: We call the open handler here to have a proper open and close pair.
*
* FIXME: What to do with the path?
*/
rv = (*diop->pathinfo.handlers->open_h)( diop, NULL, oflag, 0 );
2d228: e3a01000 mov r1, #0 2d22c: e1a02007 mov r2, r7 2d230: e595c020 ldr ip, [r5, #32] 2d234: e1a00005 mov r0, r5 2d238: e1a03001 mov r3, r1 2d23c: e1a0e00f mov lr, pc 2d240: e59cf000 ldr pc, [ip]
if ( rv == 0 ) {
2d244: e2507000 subs r7, r0, #0
2d248: 1a000006 bne 2d268 <fcntl+0x118>
rv = diop - rtems_libio_iops;
2d24c: e59f30e8 ldr r3, [pc, #232] ; 2d33c <bsp_section_text_size+0x40> 2d250: e5937000 ldr r7, [r3] 2d254: e0675005 rsb r5, r7, r5 2d258: e59f70e0 ldr r7, [pc, #224] ; 2d340 <bsp_section_text_size+0x44> 2d25c: e1a05245 asr r5, r5, #4 2d260: e0070795 mul r7, r5, r7 2d264: ea000023 b 2d2f8 <fcntl+0x1a8>
} else {
rtems_libio_free( diop );
2d268: e1a00005 mov r0, r5 <== NOT EXECUTED 2d26c: ebff6660 bl 6bf4 <rtems_libio_free> <== NOT EXECUTED 2d270: ea000020 b 2d2f8 <fcntl+0x1a8> <== NOT EXECUTED
fd2 = va_arg( ap, int );
ret = duplicate_iop( iop, fd2 );
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
2d274: e3100b02 tst r0, #2048 ; 0x800 2d278: 03a07000 moveq r7, #0 2d27c: 13a07001 movne r7, #1 2d280: ea00001e b 2d300 <bsp_section_text_size+0x4>
* 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 ) )
2d284: e5937000 ldr r7, [r3] 2d288: e3570000 cmp r7, #0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
2d28c: 13800b02 orrne r0, r0, #2048 ; 0x800
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
2d290: 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;
2d294: 1584000c strne r0, [r4, #12]
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
2d298: 0584000c streq r0, [r4, #12]
* 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 ) )
2d29c: 0a000017 beq 2d300 <bsp_section_text_size+0x4>
2d2a0: ea00000b b 2d2d4 <fcntl+0x184>
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
2d2a4: ebff662c bl 6b5c <rtems_libio_to_fcntl_flags> 2d2a8: e1a07000 mov r7, r0 2d2ac: ea000011 b 2d2f8 <fcntl+0x1a8>
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
2d2b0: e5930000 ldr r0, [r3] 2d2b4: ebff661b bl 6b28 <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
2d2b8: e594200c ldr r2, [r4, #12] 2d2bc: e59f3080 ldr r3, [pc, #128] ; 2d344 <bsp_section_text_size+0x48> 2d2c0: e3c22c02 bic r2, r2, #512 ; 0x200 2d2c4: e0003003 and r3, r0, r3 2d2c8: e3c22001 bic r2, r2, #1 2d2cc: e1833002 orr r3, r3, r2 2d2d0: e584300c str r3, [r4, #12]
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
2d2d4: e3a07000 mov r7, #0 2d2d8: ea000008 b 2d300 <bsp_section_text_size+0x4>
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
2d2dc: ebffc0bc bl 1d5d4 <__errno> 2d2e0: e3a03086 mov r3, #134 ; 0x86 2d2e4: ea000001 b 2d2f0 <fcntl+0x1a0>
ret = -1;
break;
default:
errno = EINVAL;
2d2e8: ebffc0b9 bl 1d5d4 <__errno> 2d2ec: e3a03016 mov r3, #22 2d2f0: e5803000 str r3, [r0] 2d2f4: ea00000a b 2d324 <bsp_section_text_size+0x28>
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
2d2f8: e3570000 cmp r7, #0
2d2fc: ba000009 blt 2d328 <bsp_section_text_size+0x2c>
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
2d300: e5943020 ldr r3, [r4, #32] 2d304: e1a00004 mov r0, r4 2d308: e1a01006 mov r1, r6 2d30c: e1a0e00f mov lr, pc 2d310: e593f028 ldr pc, [r3, #40] ; 0x28
if (err) {
2d314: e2504000 subs r4, r0, #0
2d318: 0a000002 beq 2d328 <bsp_section_text_size+0x2c>
errno = err;
2d31c: ebffc0ac bl 1d5d4 <__errno> <== NOT EXECUTED 2d320: e5804000 str r4, [r0] <== NOT EXECUTED
ret = -1;
2d324: e3e07000 mvn r7, #0
va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; }
2d328: e1a00007 mov r0, r7
2d32c: e8bd41f8 pop {r3, r4, r5, r6, r7, r8, lr}
2d330: e28dd00c add sp, sp, #12
2d334: e12fff1e bx lr
0000bffc <fifo_open>:
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
bffc: e92d41f7 push {r0, r1, r2, r4, r5, r6, r7, r8, lr}
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
c000: e59f83ac ldr r8, [pc, #940] ; c3b4 <fifo_open+0x3b8>
c004: e5985000 ldr r5, [r8]
c008: e3550000 cmp r5, #0
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
c00c: e1a06000 mov r6, r0
c010: e1a07001 mov r7, r1
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
c014: 1a000011 bne c060 <fifo_open+0x64>
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
c018: e59f4398 ldr r4, [pc, #920] ; c3b8 <fifo_open+0x3bc>
c01c: e1a01005 mov r1, r5
c020: e5940000 ldr r0, [r4]
c024: e1a02005 mov r2, r5
c028: ebffeddb bl 779c <rtems_semaphore_obtain>
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
c02c: e5983000 ldr r3, [r8]
c030: e3530000 cmp r3, #0
c034: 1a000005 bne c050 <fifo_open+0x54>
sc = rtems_semaphore_create(
c038: e59f037c ldr r0, [pc, #892] ; c3bc <fifo_open+0x3c0>
c03c: e3a01001 mov r1, #1
c040: e3a02054 mov r2, #84 ; 0x54
c044: e58d8000 str r8, [sp]
c048: ebffed44 bl 7560 <rtems_semaphore_create>
c04c: e1a05000 mov r5, r0
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
c050: e5940000 ldr r0, [r4]
c054: ebffee17 bl 78b8 <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
c058: e3550000 cmp r5, #0
c05c: 1a0000d1 bne c3a8 <fifo_open+0x3ac>
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
c060: e59f334c ldr r3, [pc, #844] ; c3b4 <fifo_open+0x3b8>
c064: e3a01000 mov r1, #0
c068: e5930000 ldr r0, [r3]
c06c: e1a02001 mov r2, r1
c070: ebffedc9 bl 779c <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
c074: e2508000 subs r8, r0, #0
c078: 1a0000ca bne c3a8 <fifo_open+0x3ac>
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
c07c: e5964000 ldr r4, [r6]
if (pipe == NULL) {
c080: e3540000 cmp r4, #0
c084: 1a000049 bne c1b0 <fifo_open+0x1b4>
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
c088: e3a00034 mov r0, #52 ; 0x34
c08c: ebffde46 bl 39ac <malloc>
if (pipe == NULL)
c090: e2504000 subs r4, r0, #0
c094: 0a000043 beq c1a8 <fifo_open+0x1ac>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
c098: e1a01008 mov r1, r8
c09c: e3a02034 mov r2, #52 ; 0x34
c0a0: eb0011b5 bl 1077c <memset>
pipe->Size = PIPE_BUF;
c0a4: e3a00c02 mov r0, #512 ; 0x200
c0a8: e5840004 str r0, [r4, #4]
pipe->Buffer = malloc(pipe->Size);
c0ac: ebffde3e bl 39ac <malloc>
if (! pipe->Buffer)
c0b0: e3500000 cmp r0, #0
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
pipe->Size = PIPE_BUF;
pipe->Buffer = malloc(pipe->Size);
c0b4: e5840000 str r0, [r4]
if (! pipe->Buffer)
c0b8: 0a000038 beq c1a0 <fifo_open+0x1a4>
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
c0bc: e59f52fc ldr r5, [pc, #764] ; c3c0 <fifo_open+0x3c4>
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
c0c0: e59f02fc ldr r0, [pc, #764] ; c3c4 <fifo_open+0x3c8>
rtems_build_name ('P', 'I', 'r', c),
c0c4: e5d53000 ldrb r3, [r5]
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
c0c8: e1a01008 mov r1, r8
c0cc: e1830000 orr r0, r3, r0
c0d0: e1a02008 mov r2, r8
c0d4: e284302c add r3, r4, #44 ; 0x2c
c0d8: eb0005a1 bl d764 <rtems_barrier_create>
c0dc: e2501000 subs r1, r0, #0
c0e0: 1a00002c bne c198 <fifo_open+0x19c>
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'w', c),
c0e4: e5d53000 ldrb r3, [r5]
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
c0e8: e59f02d8 ldr r0, [pc, #728] ; c3c8 <fifo_open+0x3cc>
c0ec: e1a02001 mov r2, r1
c0f0: e1830000 orr r0, r3, r0
c0f4: e2843030 add r3, r4, #48 ; 0x30
c0f8: eb000599 bl d764 <rtems_barrier_create>
c0fc: e2503000 subs r3, r0, #0
c100: 1a000022 bne c190 <fifo_open+0x194>
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
rtems_build_name ('P', 'I', 's', c), 1,
c104: e5d52000 ldrb r2, [r5]
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
c108: e59f02bc ldr r0, [pc, #700] ; c3cc <fifo_open+0x3d0>
c10c: e2841028 add r1, r4, #40 ; 0x28
c110: e58d1000 str r1, [sp]
c114: e1820000 orr r0, r2, r0
c118: e3a01001 mov r1, #1
c11c: e3a02010 mov r2, #16
c120: ebffed0e bl 7560 <rtems_semaphore_create>
c124: e3500000 cmp r0, #0
c128: 1a000016 bne c188 <fifo_open+0x18c>
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
c12c: e594102c ldr r1, [r4, #44] ; 0x2c
c130: e28d2008 add r2, sp, #8
c134: e59f0294 ldr r0, [pc, #660] ; c3d0 <fifo_open+0x3d4>
c138: ebfff3cf bl 907c <_Objects_Get>
static void pipe_interruptible(pipe_control_t *pipe)
{
Objects_Locations location;
_Barrier_Get(pipe->readBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
c13c: e590304c ldr r3, [r0, #76] ; 0x4c
c140: e3833201 orr r3, r3, #268435456 ; 0x10000000
c144: e580304c str r3, [r0, #76] ; 0x4c
_Thread_Enable_dispatch();
c148: ebfff736 bl 9e28 <_Thread_Enable_dispatch>
c14c: e28d2008 add r2, sp, #8
c150: e5941030 ldr r1, [r4, #48] ; 0x30
c154: e59f0274 ldr r0, [pc, #628] ; c3d0 <fifo_open+0x3d4>
c158: ebfff3c7 bl 907c <_Objects_Get>
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
c15c: e590304c ldr r3, [r0, #76] ; 0x4c
c160: e3833201 orr r3, r3, #268435456 ; 0x10000000
c164: e580304c str r3, [r0, #76] ; 0x4c
_Thread_Enable_dispatch();
c168: ebfff72e bl 9e28 <_Thread_Enable_dispatch>
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
c16c: e5d53000 ldrb r3, [r5]
c170: e353007a cmp r3, #122 ; 0x7a
c174: e2832001 add r2, r3, #1
c = 'a';
c178: 03a03061 moveq r3, #97 ; 0x61
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
c17c: e5c52000 strb r2, [r5]
c = 'a';
c180: 05c53000 strbeq r3, [r5]
c184: ea000009 b c1b0 <fifo_open+0x1b4>
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
c188: e5940030 ldr r0, [r4, #48] ; 0x30
c18c: eb0005a2 bl d81c <rtems_barrier_delete>
err_wbar: rtems_barrier_delete(pipe->readBarrier);
c190: e594002c ldr r0, [r4, #44] ; 0x2c
c194: eb0005a0 bl d81c <rtems_barrier_delete>
err_rbar: free(pipe->Buffer);
c198: e5940000 ldr r0, [r4]
c19c: ebffdcf7 bl 3580 <free>
err_buf: free(pipe);
c1a0: e1a00004 mov r0, r4
c1a4: ebffdcf5 bl 3580 <free>
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
c1a8: e3e0500b mvn r5, #11
c1ac: ea00000d b c1e8 <fifo_open+0x1ec>
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
c1b0: e3a01000 mov r1, #0
c1b4: e5940028 ldr r0, [r4, #40] ; 0x28
c1b8: e1a02001 mov r2, r1
c1bc: ebffed76 bl 779c <rtems_semaphore_obtain>
err = -EINTR;
if (*pipep == NULL) {
c1c0: e5963000 ldr r3, [r6]
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
c1c4: e3500000 cmp r0, #0
c1c8: 01a05000 moveq r5, r0
c1cc: 13e05003 mvnne r5, #3
err = -EINTR;
if (*pipep == NULL) {
c1d0: e3530000 cmp r3, #0
c1d4: 1a000003 bne c1e8 <fifo_open+0x1ec>
if (err)
c1d8: e3550000 cmp r5, #0
pipe_free(pipe);
else
*pipep = pipe;
c1dc: 05864000 streq r4, [r6]
if (! PIPE_LOCK(pipe))
err = -EINTR;
if (*pipep == NULL) {
if (err)
pipe_free(pipe);
c1e0: 11a00004 movne r0, r4
c1e4: 1bffff48 blne bf0c <pipe_free>
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
c1e8: e59f31c4 ldr r3, [pc, #452] ; c3b4 <fifo_open+0x3b8>
c1ec: e5930000 ldr r0, [r3]
c1f0: ebffedb0 bl 78b8 <rtems_semaphore_release>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
c1f4: e3550000 cmp r5, #0
c1f8: 1a00006b bne c3ac <fifo_open+0x3b0>
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
c1fc: e597300c ldr r3, [r7, #12]
c200: e2033006 and r3, r3, #6
c204: e3530004 cmp r3, #4
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
c208: e5964000 ldr r4, [r6]
switch (LIBIO_ACCMODE(iop)) {
c20c: 0a000024 beq c2a4 <fifo_open+0x2a8>
c210: e3530006 cmp r3, #6
c214: 0a000047 beq c338 <fifo_open+0x33c>
c218: e3530002 cmp r3, #2
c21c: 1a000059 bne c388 <fifo_open+0x38c>
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
c220: e5943020 ldr r3, [r4, #32]
c224: e2833001 add r3, r3, #1
c228: e5843020 str r3, [r4, #32]
if (pipe->Readers ++ == 0)
c22c: e5943010 ldr r3, [r4, #16]
c230: e2832001 add r2, r3, #1
c234: e3530000 cmp r3, #0
c238: e5842010 str r2, [r4, #16]
PIPE_WAKEUPWRITERS(pipe);
c23c: 05940030 ldreq r0, [r4, #48] ; 0x30
c240: 028d1004 addeq r1, sp, #4
c244: 0b00059a bleq d8b4 <rtems_barrier_release>
if (pipe->Writers == 0) {
c248: e5943014 ldr r3, [r4, #20]
c24c: e3530000 cmp r3, #0
c250: 1a00004c bne c388 <fifo_open+0x38c>
/* Not an error */
if (LIBIO_NODELAY(iop))
c254: e597300c ldr r3, [r7, #12]
c258: e3130001 tst r3, #1
c25c: 1a000049 bne c388 <fifo_open+0x38c>
break;
prevCounter = pipe->writerCounter;
c260: e5948024 ldr r8, [r4, #36] ; 0x24
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
c264: e5940028 ldr r0, [r4, #40] ; 0x28
c268: ebffed92 bl 78b8 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
c26c: e3a01000 mov r1, #0
c270: e594002c ldr r0, [r4, #44] ; 0x2c
c274: eb0005a4 bl d90c <rtems_barrier_wait>
c278: e2501000 subs r1, r0, #0
c27c: 1a000044 bne c394 <fifo_open+0x398>
goto out_error;
if (! PIPE_LOCK(pipe))
c280: e5940028 ldr r0, [r4, #40] ; 0x28
c284: e1a02001 mov r2, r1
c288: ebffed43 bl 779c <rtems_semaphore_obtain>
c28c: e3500000 cmp r0, #0
c290: 1a00003f bne c394 <fifo_open+0x398>
goto out_error;
} while (prevCounter == pipe->writerCounter);
c294: e5943024 ldr r3, [r4, #36] ; 0x24
c298: e1580003 cmp r8, r3
c29c: 0afffff0 beq c264 <fifo_open+0x268>
c2a0: ea000038 b c388 <fifo_open+0x38c>
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
c2a4: e5943024 ldr r3, [r4, #36] ; 0x24
c2a8: e2833001 add r3, r3, #1
c2ac: e5843024 str r3, [r4, #36] ; 0x24
if (pipe->Writers ++ == 0)
c2b0: e5943014 ldr r3, [r4, #20]
c2b4: e2832001 add r2, r3, #1
c2b8: e3530000 cmp r3, #0
c2bc: e5842014 str r2, [r4, #20]
PIPE_WAKEUPREADERS(pipe);
c2c0: 0594002c ldreq r0, [r4, #44] ; 0x2c
c2c4: 028d1004 addeq r1, sp, #4
c2c8: 0b000579 bleq d8b4 <rtems_barrier_release>
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
c2cc: e5943010 ldr r3, [r4, #16]
c2d0: e3530000 cmp r3, #0
c2d4: 1a00002b bne c388 <fifo_open+0x38c>
c2d8: e597300c ldr r3, [r7, #12]
c2dc: e3130001 tst r3, #1
err = -ENXIO;
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
c2e0: 05948020 ldreq r8, [r4, #32]
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
c2e4: 0a000003 beq c2f8 <fifo_open+0x2fc>
PIPE_UNLOCK(pipe);
c2e8: e5940028 ldr r0, [r4, #40] ; 0x28
c2ec: ebffed71 bl 78b8 <rtems_semaphore_release>
err = -ENXIO;
c2f0: e3e05005 mvn r5, #5
goto out_error;
c2f4: ea000027 b c398 <fifo_open+0x39c>
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
c2f8: e5940028 ldr r0, [r4, #40] ; 0x28
c2fc: ebffed6d bl 78b8 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
c300: e3a01000 mov r1, #0
c304: e5940030 ldr r0, [r4, #48] ; 0x30
c308: eb00057f bl d90c <rtems_barrier_wait>
c30c: e2501000 subs r1, r0, #0
c310: 1a00001f bne c394 <fifo_open+0x398>
goto out_error;
if (! PIPE_LOCK(pipe))
c314: e5940028 ldr r0, [r4, #40] ; 0x28
c318: e1a02001 mov r2, r1
c31c: ebffed1e bl 779c <rtems_semaphore_obtain>
c320: e3500000 cmp r0, #0
c324: 1a00001a bne c394 <fifo_open+0x398>
goto out_error;
} while (prevCounter == pipe->readerCounter);
c328: e5943020 ldr r3, [r4, #32]
c32c: e1580003 cmp r8, r3
c330: 0afffff0 beq c2f8 <fifo_open+0x2fc>
c334: ea000013 b c388 <fifo_open+0x38c>
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
c338: e5943020 ldr r3, [r4, #32]
c33c: e2833001 add r3, r3, #1
c340: e5843020 str r3, [r4, #32]
if (pipe->Readers ++ == 0)
c344: e5943010 ldr r3, [r4, #16]
c348: e2832001 add r2, r3, #1
c34c: e3530000 cmp r3, #0
c350: e5842010 str r2, [r4, #16]
PIPE_WAKEUPWRITERS(pipe);
c354: 05940030 ldreq r0, [r4, #48] ; 0x30
c358: 028d1004 addeq r1, sp, #4
c35c: 0b000554 bleq d8b4 <rtems_barrier_release>
pipe->writerCounter ++;
c360: e5943024 ldr r3, [r4, #36] ; 0x24
c364: e2833001 add r3, r3, #1
c368: e5843024 str r3, [r4, #36] ; 0x24
if (pipe->Writers ++ == 0)
c36c: e5943014 ldr r3, [r4, #20]
c370: e2832001 add r2, r3, #1
c374: e3530000 cmp r3, #0
c378: e5842014 str r2, [r4, #20]
PIPE_WAKEUPREADERS(pipe);
c37c: 0594002c ldreq r0, [r4, #44] ; 0x2c
c380: 028d1004 addeq r1, sp, #4
c384: 0b00054a bleq d8b4 <rtems_barrier_release>
break;
}
PIPE_UNLOCK(pipe);
c388: e5940028 ldr r0, [r4, #40] ; 0x28
c38c: ebffed49 bl 78b8 <rtems_semaphore_release>
return 0;
c390: ea000005 b c3ac <fifo_open+0x3b0>
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
c394: e3e05003 mvn r5, #3 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
c398: e1a00006 mov r0, r6
c39c: e1a01007 mov r1, r7
c3a0: ebfffee6 bl bf40 <pipe_release>
return err;
c3a4: ea000000 b c3ac <fifo_open+0x3b0>
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
}
if (sc == RTEMS_SUCCESSFUL) {
c3a8: e3e0500b mvn r5, #11
return 0;
out_error:
pipe_release(pipep, iop);
return err;
}
c3ac: e1a00005 mov r0, r5
c3b0: e8bd81fe pop {r1, r2, r3, r4, r5, r6, r7, r8, pc}
0000809c <fpathconf>:
{
long return_value;
rtems_libio_t *iop;
const rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
809c: e59f30f4 ldr r3, [pc, #244] ; 8198 <fpathconf+0xfc>
80a0: e5933000 ldr r3, [r3]
80a4: e1500003 cmp r0, r3
*/
long fpathconf(
int fd,
int name
)
{
80a8: e52de004 push {lr} ; (str lr, [sp, #-4]!)
long return_value;
rtems_libio_t *iop;
const rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
80ac: 2a000006 bcs 80cc <fpathconf+0x30>
iop = rtems_libio_iop(fd);
80b0: e59f30e4 ldr r3, [pc, #228] ; 819c <fpathconf+0x100>
80b4: e5933000 ldr r3, [r3]
80b8: e3a02030 mov r2, #48 ; 0x30
80bc: e0203092 mla r0, r2, r0, r3
rtems_libio_check_is_open(iop);
80c0: e590300c ldr r3, [r0, #12]
80c4: e3130c01 tst r3, #256 ; 0x100
80c8: 1a000004 bne 80e0 <fpathconf+0x44>
80cc: eb0008b8 bl a3b4 <__errno>
80d0: e3a03009 mov r3, #9
80d4: e5803000 str r3, [r0]
80d8: e3e00000 mvn r0, #0
80dc: e49df004 pop {pc} ; (ldr pc, [sp], #4)
/*
* Now process the information request.
*/
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
80e0: e5903024 ldr r3, [r0, #36] ; 0x24
80e4: e593302c ldr r3, [r3, #44] ; 0x2c
switch ( name ) {
80e8: e351000b cmp r1, #11
80ec: 979ff101 ldrls pc, [pc, r1, lsl #2]
80f0: ea000023 b 8184 <fpathconf+0xe8>
80f4: 00008124 .word 0x00008124
80f8: 0000812c .word 0x0000812c <== NOT EXECUTED
80fc: 00008134 .word 0x00008134 <== NOT EXECUTED
8100: 0000813c .word 0x0000813c <== NOT EXECUTED
8104: 00008144 .word 0x00008144 <== NOT EXECUTED
8108: 0000814c .word 0x0000814c <== NOT EXECUTED
810c: 00008154 .word 0x00008154 <== NOT EXECUTED
8110: 0000815c .word 0x0000815c <== NOT EXECUTED
8114: 00008164 .word 0x00008164 <== NOT EXECUTED
8118: 0000816c .word 0x0000816c <== NOT EXECUTED
811c: 00008174 .word 0x00008174 <== NOT EXECUTED
8120: 0000817c .word 0x0000817c <== NOT EXECUTED
case _PC_LINK_MAX:
return_value = the_limits->link_max;
8124: e5930000 ldr r0, [r3]
break;
8128: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
812c: e5930004 ldr r0, [r3, #4]
break;
8130: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
8134: e5930008 ldr r0, [r3, #8]
break;
8138: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_NAME_MAX:
return_value = the_limits->name_max;
813c: e593000c ldr r0, [r3, #12]
break;
8140: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PATH_MAX:
return_value = the_limits->path_max;
8144: e5930010 ldr r0, [r3, #16]
break;
8148: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
814c: e5930014 ldr r0, [r3, #20]
break;
8150: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
8154: e593001c ldr r0, [r3, #28]
break;
8158: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
815c: e5930020 ldr r0, [r3, #32]
break;
8160: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
8164: e593002c ldr r0, [r3, #44] ; 0x2c
break;
8168: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
816c: e5930018 ldr r0, [r3, #24]
break;
8170: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
8174: e5930024 ldr r0, [r3, #36] ; 0x24
break;
8178: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
817c: e5930028 ldr r0, [r3, #40] ; 0x28
break;
8180: e49df004 pop {pc} ; (ldr pc, [sp], #4)
default:
rtems_set_errno_and_return_minus_one( EINVAL );
8184: eb00088a bl a3b4 <__errno>
8188: e3a03016 mov r3, #22
818c: e5803000 str r3, [r0]
8190: e3e00000 mvn r0, #0
break;
}
return return_value;
}
8194: e49df004 pop {pc} ; (ldr pc, [sp], #4)
000188ec <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
188ec: e92d4030 push {r4, r5, lr}
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
188f0: e2515000 subs r5, r1, #0
188f4: 1a000002 bne 18904 <fstat+0x18>
rtems_set_errno_and_return_minus_one( EFAULT );
188f8: ebffd38d bl d734 <__errno> <== NOT EXECUTED 188fc: e3a0300e mov r3, #14 <== NOT EXECUTED 18900: ea00000c b 18938 <fstat+0x4c> <== NOT EXECUTED
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
18904: e59f3060 ldr r3, [pc, #96] ; 1896c <fstat+0x80> 18908: e5933000 ldr r3, [r3] 1890c: e1500003 cmp r0, r3
18910: 2a000006 bcs 18930 <fstat+0x44>
18914: e59f3054 ldr r3, [pc, #84] ; 18970 <fstat+0x84> 18918: e5933000 ldr r3, [r3] 1891c: e3a04030 mov r4, #48 ; 0x30 18920: e0243490 mla r4, r0, r4, r3
rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop);
18924: e594300c ldr r3, [r4, #12] 18928: e3130c01 tst r3, #256 ; 0x100
1892c: 1a000004 bne 18944 <fstat+0x58>
18930: ebffd37f bl d734 <__errno>
18934: e3a03009 mov r3, #9
18938: e5803000 str r3, [r0]
1893c: e3e00000 mvn r0, #0
18940: 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) );
18944: e1a00005 mov r0, r5 18948: e3a01000 mov r1, #0 1894c: e3a02048 mov r2, #72 ; 0x48 18950: ebffd5e7 bl e0f4 <memset>
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
18954: e5943020 ldr r3, [r4, #32] 18958: e2840010 add r0, r4, #16 1895c: e1a01005 mov r1, r5 18960: e1a0e00f mov lr, pc 18964: e593f018 ldr pc, [r3, #24]
}
18968: e8bd8030 pop {r4, r5, pc}
00002268 <get_disk_entry>:
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major < disktab_size && disktab != NULL) {
2268: e59f3074 ldr r3, [pc, #116] ; 22e4 <get_disk_entry+0x7c>
226c: e593c000 ldr ip, [r3]
2270: e150000c cmp r0, ip
2274: 2a000016 bcs 22d4 <get_disk_entry+0x6c>
2278: e5933004 ldr r3, [r3, #4]
227c: e3530000 cmp r3, #0
return dd;
}
}
return NULL;
2280: 01a00003 moveq r0, 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 && disktab != NULL) {
2284: 012fff1e bxeq lr
rtems_disk_device_table *dtab = disktab + major;
2288: e083c180 add ip, r3, r0, lsl #3
if (minor < dtab->size && dtab->minor != NULL) {
228c: e59cc004 ldr ip, [ip, #4]
2290: e151000c cmp r1, ip
2294: 2a00000e bcs 22d4 <get_disk_entry+0x6c>
2298: e7930180 ldr r0, [r3, r0, lsl #3]
229c: e3500000 cmp r0, #0
22a0: 012fff1e bxeq lr
rtems_disk_device *dd = dtab->minor [minor];
22a4: e7900101 ldr r0, [r0, r1, lsl #2]
if (dd != NULL && !lookup_only) {
22a8: e3500000 cmp r0, #0
22ac: 012fff1e bxeq lr
22b0: e3520000 cmp r2, #0
22b4: 112fff1e bxne lr
if (!dd->deleted) {
22b8: e5d03040 ldrb r3, [r0, #64] ; 0x40
22bc: e3530000 cmp r3, #0
++dd->uses;
22c0: 05903014 ldreq r3, [r0, #20]
22c4: 02833001 addeq r3, r3, #1
22c8: 05803014 streq r3, [r0, #20]
if (minor < dtab->size && dtab->minor != NULL) {
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && !lookup_only) {
if (!dd->deleted) {
22cc: 012fff1e bxeq lr
22d0: ea000001 b 22dc <get_disk_entry+0x74>
return dd;
}
}
return NULL;
22d4: e3a00000 mov r0, #0 <== NOT EXECUTED
22d8: e12fff1e bx lr <== NOT EXECUTED
if (dd != NULL && !lookup_only) {
if (!dd->deleted) {
++dd->uses;
} else {
dd = NULL;
22dc: e1a00002 mov r0, r2
return dd;
}
}
return NULL;
}
22e0: e12fff1e bx lr
0000357c <get_sector>:
*/
static rtems_status_code
get_sector(int fd,
uint32_t sector_num,
rtems_sector_data_t **sector)
{
357c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
rtems_sector_data_t *s;
ssize_t n;
off_t off;
off_t new_off;
if (sector == NULL)
3580: e2528000 subs r8, r2, #0
*/
static rtems_status_code
get_sector(int fd,
uint32_t sector_num,
rtems_sector_data_t **sector)
{
3584: e1a05000 mov r5, r0
3588: e1a04001 mov r4, r1
off_t off;
off_t new_off;
if (sector == NULL)
{
return RTEMS_INTERNAL_ERROR;
358c: 03a00019 moveq r0, #25
rtems_sector_data_t *s;
ssize_t n;
off_t off;
off_t new_off;
if (sector == NULL)
3590: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
{
return RTEMS_INTERNAL_ERROR;
}
off = sector_num * RTEMS_IDE_SECTOR_SIZE;
3594: e1a03481 lsl r3, r1, #9
3598: e3a07000 mov r7, #0
359c: e1a06003 mov r6, r3
new_off = lseek(fd, off, SEEK_SET);
35a0: e1a01003 mov r1, r3
35a4: e1a02007 mov r2, r7
35a8: e1a03007 mov r3, r7
35ac: eb0004ab bl 4860 <lseek>
if (new_off != off) {
35b0: e1510007 cmp r1, r7
35b4: 01500006 cmpeq r0, r6
35b8: 1a000011 bne 3604 <get_sector+0x88>
return RTEMS_IO_ERROR;
}
s = (rtems_sector_data_t *) malloc(sizeof(rtems_sector_data_t) + RTEMS_IDE_SECTOR_SIZE);
35bc: e3a00f81 mov r0, #516 ; 0x204
35c0: eb00050b bl 49f4 <malloc>
if (s == NULL)
35c4: e2506000 subs r6, r0, #0
{
return RTEMS_NO_MEMORY;
35c8: 03a0001a moveq r0, #26
if (new_off != off) {
return RTEMS_IO_ERROR;
}
s = (rtems_sector_data_t *) malloc(sizeof(rtems_sector_data_t) + RTEMS_IDE_SECTOR_SIZE);
if (s == NULL)
35cc: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
{
return RTEMS_NO_MEMORY;
}
n = read(fd, s->data, RTEMS_IDE_SECTOR_SIZE);
35d0: e1a00005 mov r0, r5
35d4: e2861004 add r1, r6, #4
35d8: e3a02c02 mov r2, #512 ; 0x200
35dc: eb00079c bl 5454 <read>
if (n != RTEMS_IDE_SECTOR_SIZE)
35e0: e3500c02 cmp r0, #512 ; 0x200
{
free(s);
return RTEMS_IO_ERROR;
}
s->sector_num = sector_num;
35e4: 05864000 streq r4, [r6]
*sector = s;
return RTEMS_SUCCESSFUL;
35e8: 03a00000 moveq r0, #0
return RTEMS_IO_ERROR;
}
s->sector_num = sector_num;
*sector = s;
35ec: 05886000 streq r6, [r8]
{
return RTEMS_NO_MEMORY;
}
n = read(fd, s->data, RTEMS_IDE_SECTOR_SIZE);
if (n != RTEMS_IDE_SECTOR_SIZE)
35f0: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
{
free(s);
35f4: e1a00006 mov r0, r6 <== NOT EXECUTED
35f8: eb00038d bl 4434 <free> <== NOT EXECUTED
return RTEMS_IO_ERROR;
35fc: e3a0001b mov r0, #27 <== NOT EXECUTED
3600: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
}
off = sector_num * RTEMS_IDE_SECTOR_SIZE;
new_off = lseek(fd, off, SEEK_SET);
if (new_off != off) {
return RTEMS_IO_ERROR;
3604: e3a0001b mov r0, #27 <== NOT EXECUTED
s->sector_num = sector_num;
*sector = s;
return RTEMS_SUCCESSFUL;
}
3608: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00004cb4 <iproc>:
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
if (tty->termios.c_iflag & ISTRIP)
4cb4: e5913030 ldr r3, [r1, #48] ; 0x30
4cb8: e3130020 tst r3, #32
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
4cbc: e92d4030 push {r4, r5, lr}
4cc0: e20050ff and r5, r0, #255 ; 0xff
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
4cc4: 1200507f andne r5, r0, #127 ; 0x7f
if (tty->termios.c_iflag & IUCLC)
4cc8: e3130c02 tst r3, #512 ; 0x200
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
4ccc: e1a04001 mov r4, r1
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
4cd0: 0a000007 beq 4cf4 <iproc+0x40>
c = tolower (c);
4cd4: e59f2164 ldr r2, [pc, #356] ; 4e40 <iproc+0x18c>
4cd8: e5922000 ldr r2, [r2]
4cdc: e0822005 add r2, r2, r5
4ce0: e5d22001 ldrb r2, [r2, #1]
4ce4: e2022003 and r2, r2, #3
4ce8: e3520001 cmp r2, #1
4cec: 02855020 addeq r5, r5, #32
4cf0: e20550ff and r5, r5, #255 ; 0xff
if (c == '\r') {
4cf4: e355000d cmp r5, #13
4cf8: 1a000005 bne 4d14 <iproc+0x60>
if (tty->termios.c_iflag & IGNCR)
4cfc: e3130080 tst r3, #128 ; 0x80
4d00: 1a000048 bne 4e28 <iproc+0x174>
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
4d04: e3130c01 tst r3, #256 ; 0x100
4d08: 03a0500d moveq r5, #13
4d0c: 13a0500a movne r5, #10
4d10: ea000007 b 4d34 <iproc+0x80>
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
4d14: e355000a cmp r5, #10
4d18: 1a000003 bne 4d2c <iproc+0x78>
c = '\r';
4d1c: e3130040 tst r3, #64 ; 0x40
4d20: 03a0500a moveq r5, #10
4d24: 13a0500d movne r5, #13
4d28: ea000001 b 4d34 <iproc+0x80>
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
4d2c: e3550000 cmp r5, #0
4d30: 0a00002c beq 4de8 <iproc+0x134>
4d34: e594303c ldr r3, [r4, #60] ; 0x3c
4d38: e3130002 tst r3, #2
4d3c: 0a000029 beq 4de8 <iproc+0x134>
if (c == tty->termios.c_cc[VERASE]) {
4d40: e5d42043 ldrb r2, [r4, #67] ; 0x43
4d44: e1520005 cmp r2, r5
erase (tty, 0);
4d48: 01a00004 moveq r0, r4
4d4c: 03a01000 moveq r1, #0
} 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]) {
4d50: 0a000004 beq 4d68 <iproc+0xb4>
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
4d54: e5d42044 ldrb r2, [r4, #68] ; 0x44
4d58: e1520005 cmp r2, r5
4d5c: 1a000003 bne 4d70 <iproc+0xbc>
erase (tty, 1);
4d60: e1a00004 mov r0, r4
4d64: e3a01001 mov r1, #1
4d68: ebffff60 bl 4af0 <erase>
4d6c: ea00002d b 4e28 <iproc+0x174>
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
4d70: e5d42045 ldrb r2, [r4, #69] ; 0x45
4d74: e1520005 cmp r2, r5
4d78: 0a00002c beq 4e30 <iproc+0x17c>
return 1;
} else if (c == '\n') {
4d7c: e355000a cmp r5, #10
4d80: 1a000008 bne 4da8 <iproc+0xf4>
if (tty->termios.c_lflag & (ECHO | ECHONL))
4d84: e3130048 tst r3, #72 ; 0x48
echo (c, tty);
4d88: 11a00005 movne r0, r5
4d8c: 11a01004 movne r1, r4
4d90: 1bffff33 blne 4a64 <echo>
tty->cbuf[tty->ccount++] = c;
4d94: e284201c add r2, r4, #28
4d98: e892000c ldm r2, {r2, r3}
4d9c: e3a0100a mov r1, #10
4da0: e7c21003 strb r1, [r2, r3]
4da4: ea00000c b 4ddc <iproc+0x128>
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
4da8: e5d4204c ldrb r2, [r4, #76] ; 0x4c
4dac: e1520005 cmp r2, r5
4db0: 0a000002 beq 4dc0 <iproc+0x10c>
4db4: e5d42051 ldrb r2, [r4, #81] ; 0x51
4db8: e1520005 cmp r2, r5
4dbc: 1a000009 bne 4de8 <iproc+0x134>
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
4dc0: e3130008 tst r3, #8 <== NOT EXECUTED
echo (c, tty);
4dc4: 11a00005 movne r0, r5 <== NOT EXECUTED
4dc8: 11a01004 movne r1, r4 <== NOT EXECUTED
4dcc: 1bffff24 blne 4a64 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
4dd0: e284201c add r2, r4, #28 <== NOT EXECUTED
4dd4: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
4dd8: e7c25003 strb r5, [r2, r3] <== NOT EXECUTED
4ddc: e2833001 add r3, r3, #1
4de0: e5843020 str r3, [r4, #32]
4de4: ea000011 b 4e30 <iproc+0x17c>
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
4de8: e59f3054 ldr r3, [pc, #84] ; 4e44 <iproc+0x190>
4dec: e5933008 ldr r3, [r3, #8]
4df0: e5942020 ldr r2, [r4, #32]
4df4: e2433001 sub r3, r3, #1
4df8: e1520003 cmp r2, r3
4dfc: 2a00000d bcs 4e38 <iproc+0x184>
if (tty->termios.c_lflag & ECHO)
4e00: e594303c ldr r3, [r4, #60] ; 0x3c
4e04: e3130008 tst r3, #8
echo (c, tty);
4e08: 11a00005 movne r0, r5
4e0c: 11a01004 movne r1, r4
4e10: 1bffff13 blne 4a64 <echo>
tty->cbuf[tty->ccount++] = c;
4e14: e284201c add r2, r4, #28
4e18: e892000c ldm r2, {r2, r3}
4e1c: e7c25003 strb r5, [r2, r3]
4e20: e2833001 add r3, r3, #1
4e24: e5843020 str r3, [r4, #32]
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
return 0;
4e28: e3a00000 mov r0, #0
4e2c: e8bd8030 pop {r4, r5, pc}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
4e30: e3a00001 mov r0, #1
4e34: e8bd8030 pop {r4, r5, pc}
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
4e38: e3a00000 mov r0, #0 <== NOT EXECUTED
}
4e3c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
0000c9a0 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode
)
{
c9a0: e92d4011 push {r0, r4, lr}
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
c9a4: e590c018 ldr ip, [r0, #24]
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & LIBIO_FLAGS_WRITE)
c9a8: e590000c ldr r0, [r0, #12]
c9ac: e2100004 ands r0, r0, #4
c9b0: 0a000017 beq ca14 <memfile_open+0x74>
c9b4: e59c304c ldr r3, [ip, #76] ; 0x4c
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
c9b8: e5933000 ldr r3, [r3]
c9bc: e3530005 cmp r3, #5
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
return -1;
}
return 0;
c9c0: 13a00000 movne r0, #0
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & LIBIO_FLAGS_WRITE)
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
c9c4: 1a000012 bne ca14 <memfile_open+0x74>
uint32_t count = the_jnode->info.linearfile.size;
c9c8: e59c0050 ldr r0, [ip, #80] ; 0x50 <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->control = &IMFS_node_control_memfile;
c9cc: e59f2044 ldr r2, [pc, #68] ; ca18 <memfile_open+0x78> <== NOT EXECUTED
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
c9d0: e3a04000 mov r4, #0 <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_WRITE)
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->control = &IMFS_node_control_memfile;
c9d4: e58c204c str r2, [ip, #76] ; 0x4c <== NOT EXECUTED
the_jnode->info.file.size = 0;
c9d8: e3a01000 mov r1, #0 <== NOT EXECUTED
c9dc: e3a02000 mov r2, #0 <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
c9e0: e1500004 cmp r0, r4 <== NOT EXECUTED
* Perform 'copy on write' for linear files
*/
if ((iop->flags & LIBIO_FLAGS_WRITE)
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
c9e4: e59c3058 ldr r3, [ip, #88] ; 0x58 <== NOT EXECUTED
the_jnode->control = &IMFS_node_control_memfile;
the_jnode->info.file.size = 0;
c9e8: e58c1050 str r1, [ip, #80] ; 0x50 <== NOT EXECUTED
c9ec: e58c2054 str r2, [ip, #84] ; 0x54 <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
c9f0: e58c4058 str r4, [ip, #88] ; 0x58 <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
c9f4: e58c405c str r4, [ip, #92] ; 0x5c <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
c9f8: e58c4060 str r4, [ip, #96] ; 0x60 <== NOT EXECUTED
if ((count != 0)
c9fc: 0a000004 beq ca14 <memfile_open+0x74> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
ca00: e58d0000 str r0, [sp] <== NOT EXECUTED
ca04: e1a0000c mov r0, ip <== NOT EXECUTED
ca08: ebffff68 bl c7b0 <IMFS_memfile_write> <== NOT EXECUTED
ca0c: e3700001 cmn r0, #1 <== NOT EXECUTED
return -1;
}
return 0;
ca10: 11a00004 movne r0, r4 <== NOT EXECUTED
}
ca14: e8bd8018 pop {r3, r4, pc}
00002824 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
2824: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
int rv = 0;
if (
2828: e3530001 cmp r3, #1
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
282c: e24dd060 sub sp, sp, #96 ; 0x60
2830: e1a05000 mov r5, r0
2834: e1a06001 mov r6, r1
2838: e1a09002 mov r9, r2
283c: e58d3008 str r3, [sp, #8]
int rv = 0;
if (
2840: 8a0000a7 bhi 2ae4 <mount+0x2c0>
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
2844: e1a00002 mov r0, r2
2848: eb001f5d bl a5c4 <rtems_filesystem_get_mount_handler>
rtems_filesystem_get_mount_handler( filesystemtype );
if ( fsmount_me_h != NULL ) {
284c: e3500000 cmp r0, #0
2850: e58d000c str r0, [sp, #12]
2854: 0a0000a2 beq 2ae4 <mount+0x2c0>
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
2858: e3560000 cmp r6, #0
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
285c: e1a00009 mov r0, r9
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
2860: e59fb2a4 ldr fp, [pc, #676] ; 2b0c <mount+0x2e8>
2864: 11a0b006 movne fp, r6
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
2868: eb00316d bl ee24 <strlen>
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
286c: e3550000 cmp r5, #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;
2870: e1a0a000 mov sl, r0
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
2874: 01a07005 moveq r7, r5
2878: 0a000002 beq 2888 <mount+0x64>
287c: e1a00005 mov r0, r5
2880: eb003167 bl ee24 <strlen>
2884: e2807001 add r7, r0, #1
size_t target_size = strlen( target ) + 1;
2888: e1a0000b mov r0, fp
288c: eb003164 bl ee24 <strlen>
2890: e2800001 add r0, r0, #1
2894: e58d0000 str r0, [sp]
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
+ sizeof( rtems_filesystem_global_location_t );
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
2898: e59d3000 ldr r3, [sp]
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
289c: e28a1065 add r1, sl, #101 ; 0x65
28a0: e0811007 add r1, r1, r7
+ sizeof( rtems_filesystem_global_location_t );
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
28a4: e3a00001 mov r0, #1
28a8: e0811003 add r1, r1, r3
28ac: ebfffe07 bl 20d0 <calloc>
if ( mt_entry != NULL ) {
28b0: e2504000 subs r4, r0, #0
28b4: 0a000091 beq 2b00 <mount+0x2dc>
rtems_filesystem_global_location_t *mt_fs_root =
(rtems_filesystem_global_location_t *)
((char *) mt_entry + sizeof( *mt_entry ));
char *str = (char *) mt_fs_root + sizeof( *mt_fs_root );
28b8: e2848064 add r8, r4, #100 ; 0x64
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;
28bc: e28aa001 add sl, sl, #1
+ filesystemtype_size + source_size + target_size
+ sizeof( rtems_filesystem_global_location_t );
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
if ( mt_entry != NULL ) {
rtems_filesystem_global_location_t *mt_fs_root =
28c0: e2843040 add r3, r4, #64 ; 0x40
(rtems_filesystem_global_location_t *)
((char *) mt_entry + sizeof( *mt_entry ));
char *str = (char *) mt_fs_root + sizeof( *mt_fs_root );
memcpy( str, filesystemtype, filesystemtype_size );
28c4: e1a00008 mov r0, r8
28c8: e1a01009 mov r1, r9
28cc: e1a0200a mov r2, sl
+ filesystemtype_size + source_size + target_size
+ sizeof( rtems_filesystem_global_location_t );
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
if ( mt_entry != NULL ) {
rtems_filesystem_global_location_t *mt_fs_root =
28d0: e58d3004 str r3, [sp, #4]
(rtems_filesystem_global_location_t *)
((char *) mt_entry + sizeof( *mt_entry ));
char *str = (char *) mt_fs_root + sizeof( *mt_fs_root );
memcpy( str, filesystemtype, filesystemtype_size );
28d4: eb002dd0 bl e01c <memcpy>
mt_entry->type = str;
str += filesystemtype_size;
if ( source_or_null != NULL ) {
28d8: e3550000 cmp r5, #0
(rtems_filesystem_global_location_t *)
((char *) mt_entry + sizeof( *mt_entry ));
char *str = (char *) mt_fs_root + sizeof( *mt_fs_root );
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
28dc: e5848034 str r8, [r4, #52] ; 0x34
str += filesystemtype_size;
28e0: e088800a add r8, r8, sl
if ( source_or_null != NULL ) {
28e4: 0a000005 beq 2900 <mount+0xdc>
memcpy( str, source_or_null, source_size );
28e8: e1a00008 mov r0, r8
28ec: e1a01005 mov r1, r5
28f0: e1a02007 mov r2, r7
28f4: eb002dc8 bl e01c <memcpy>
mt_entry->dev = str;
28f8: e5848038 str r8, [r4, #56] ; 0x38
str += source_size;
28fc: e0888007 add r8, r8, r7
}
memcpy( str, target, target_size );
2900: e1a0100b mov r1, fp
2904: e59d2000 ldr r2, [sp]
2908: e1a00008 mov r0, r8
290c: eb002dc2 bl e01c <memcpy>
mt_entry->target = str;
str += target_size;
mt_entry->mounted = true;
mt_entry->mt_fs_root = mt_fs_root;
2910: e59d3004 ldr r3, [sp, #4]
2914: e5843024 str r3, [r4, #36] ; 0x24
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
2918: e59f31f0 ldr r3, [pc, #496] ; 2b10 <mount+0x2ec>
memcpy( str, target, target_size );
mt_entry->target = str;
str += target_size;
mt_entry->mounted = true;
291c: e3a02001 mov r2, #1
2920: e5c42028 strb r2, [r4, #40] ; 0x28
mt_entry->mt_fs_root = mt_fs_root;
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
2924: e584302c str r3, [r4, #44] ; 0x2c
mt_fs_root->location.mt_entry = mt_entry;
mt_fs_root->reference_count = 1;
2928: e5842058 str r2, [r4, #88] ; 0x58
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
_Chain_Initialize( the_chain, starting_address, number_nodes, node_size );
292c: e2840014 add r0, r4, #20
2930: e59d1004 ldr r1, [sp, #4]
2934: e3a03024 mov r3, #36 ; 0x24
mt_entry->dev = str;
str += source_size;
}
memcpy( str, target, target_size );
mt_entry->target = str;
2938: e5848030 str r8, [r4, #48] ; 0x30
mt_entry->mounted = true;
mt_entry->mt_fs_root = mt_fs_root;
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
mt_fs_root->location.mt_entry = mt_entry;
293c: e5844054 str r4, [r4, #84] ; 0x54
2940: eb00103d bl 6a3c <_Chain_Initialize>
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
2944: e59d3008 ldr r3, [sp, #8]
rv = (*fsmount_me_h)( mt_entry, data );
2948: e1a00004 mov r0, r4
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
294c: e5c43029 strb r3, [r4, #41] ; 0x29
rv = (*fsmount_me_h)( mt_entry, data );
2950: e59d1084 ldr r1, [sp, #132] ; 0x84
2954: e59d300c ldr r3, [sp, #12]
2958: e1a0e00f mov lr, pc
295c: e12fff13 bx r3
if ( rv == 0 ) {
2960: e2505000 subs r5, r0, #0
2964: 1a00005b bne 2ad8 <mount+0x2b4>
if ( target != NULL ) {
2968: e3560000 cmp r6, #0
296c: 0a000030 beq 2a34 <mount+0x210>
{
int rv = 0;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_PERMS_RWX
| RTEMS_FS_FOLLOW_LINK;
rtems_filesystem_location_info_t *currentloc =
2970: e1a01006 mov r1, r6
2974: e3a0201f mov r2, #31
2978: e28d0010 add r0, sp, #16
297c: eb000318 bl 35e4 <rtems_filesystem_eval_path_start>
static inline bool rtems_filesystem_location_is_instance_root(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
2980: e5902014 ldr r2, [r0, #20]
return (*mt_entry->ops->are_nodes_equal_h)(
2984: e592300c ldr r3, [r2, #12]
2988: e5921024 ldr r1, [r2, #36] ; 0x24
298c: e1a0e00f mov lr, pc
2990: e593f010 ldr pc, [r3, #16]
rtems_filesystem_eval_path_start( &ctx, target, eval_flags );
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
2994: e3500000 cmp r0, #0
2998: 1a00001c bne 2a10 <mount+0x1ec>
static inline void rtems_filesystem_eval_path_extract_currentloc(
rtems_filesystem_eval_path_context_t *ctx,
rtems_filesystem_location_info_t *get
)
{
rtems_filesystem_location_copy_and_detach(
299c: e28d1028 add r1, sp, #40 ; 0x28
29a0: e28d0048 add r0, sp, #72 ; 0x48
29a4: eb0003d2 bl 38f4 <rtems_filesystem_location_copy_and_detach>
rtems_filesystem_location_info_t targetloc;
rtems_filesystem_global_location_t *mt_point_node;
rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc );
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
29a8: e28d0048 add r0, sp, #72 ; 0x48
29ac: eb000441 bl 3ab8 <rtems_filesystem_location_transform_to_global>
mt_entry->mt_point_node = mt_point_node;
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
29b0: e5903014 ldr r3, [r0, #20]
rtems_filesystem_location_info_t targetloc;
rtems_filesystem_global_location_t *mt_point_node;
rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc );
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
mt_entry->mt_point_node = mt_point_node;
29b4: e5840020 str r0, [r4, #32]
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
rtems_filesystem_location_info_t targetloc;
rtems_filesystem_global_location_t *mt_point_node;
rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc );
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
29b8: e1a06000 mov r6, r0
mt_entry->mt_point_node = mt_point_node;
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
29bc: e593300c ldr r3, [r3, #12]
29c0: e1a00004 mov r0, r4
29c4: e1a0e00f mov lr, pc
29c8: e593f030 ldr pc, [r3, #48] ; 0x30
if ( rv == 0 ) {
29cc: e2505000 subs r5, r0, #0
29d0: 1a00000b bne 2a04 <mount+0x1e0>
rtems_filesystem_mt_lock();
29d4: ebffff8c bl 280c <rtems_filesystem_mt_lock>
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
29d8: e59f3134 ldr r3, [pc, #308] ; 2b14 <mount+0x2f0>
29dc: e5932008 ldr r2, [r3, #8]
the_node->next = tail;
29e0: e2831004 add r1, r3, #4
tail->previous = the_node;
29e4: e5834008 str r4, [r3, #8]
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
29e8: e59f3128 ldr r3, [pc, #296] ; 2b18 <mount+0x2f4>
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
29ec: e5841000 str r1, [r4]
tail->previous = the_node; old_last->next = the_node; the_node->previous = old_last;
29f0: e5842004 str r2, [r4, #4]
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
old_last->next = the_node;
29f4: e5824000 str r4, [r2]
29f8: e5930000 ldr r0, [r3]
29fc: eb000daf bl 60c0 <rtems_semaphore_release>
2a00: ea000006 b 2a20 <mount+0x1fc>
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
rtems_filesystem_mt_unlock();
} else {
rtems_filesystem_global_location_release( mt_point_node );
2a04: e1a00006 mov r0, r6
2a08: eb0003db bl 397c <rtems_filesystem_global_location_release>
2a0c: ea000003 b 2a20 <mount+0x1fc>
}
} else {
rtems_filesystem_eval_path_error( &ctx, EBUSY );
2a10: e28d0010 add r0, sp, #16
2a14: e3a01010 mov r1, #16
2a18: eb00023c bl 3310 <rtems_filesystem_eval_path_error>
rv = -1;
2a1c: e3e05000 mvn r5, #0
}
rtems_filesystem_eval_path_cleanup( &ctx );
2a20: e28d0010 add r0, sp, #16
2a24: eb0002f6 bl 3604 <rtems_filesystem_eval_path_cleanup>
rv = register_subordinate_file_system( mt_entry, target );
} else {
rv = register_root_file_system( mt_entry );
}
if ( rv != 0 ) {
2a28: e3550000 cmp r5, #0
2a2c: 0a000030 beq 2af4 <mount+0x2d0>
2a30: ea000024 b 2ac8 <mount+0x2a4>
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
int rv = 0;
rtems_filesystem_mt_lock();
2a34: ebffff74 bl 280c <rtems_filesystem_mt_lock>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
2a38: e59f30d4 ldr r3, [pc, #212] ; 2b14 <mount+0x2f0>
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
2a3c: e5931000 ldr r1, [r3]
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
2a40: e2832004 add r2, r3, #4
2a44: e1510002 cmp r1, r2
2a48: 1a000005 bne 2a64 <mount+0x240>
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
2a4c: e5932008 ldr r2, [r3, #8]
the_node->next = tail;
2a50: e5841000 str r1, [r4]
tail->previous = the_node;
2a54: e5834008 str r4, [r3, #8]
old_last->next = the_node;
2a58: e5824000 str r4, [r2]
the_node->previous = old_last;
2a5c: e5842004 str r2, [r4, #4]
2a60: ea000003 b 2a74 <mount+0x250>
rtems_chain_append_unprotected(
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
} else {
errno = EINVAL;
2a64: eb002b32 bl d734 <__errno> <== NOT EXECUTED
2a68: e3a03016 mov r3, #22 <== NOT EXECUTED
2a6c: e5803000 str r3, [r0] <== NOT EXECUTED
rv = -1;
2a70: e3e05000 mvn r5, #0 <== NOT EXECUTED
2a74: e59f309c ldr r3, [pc, #156] ; 2b18 <mount+0x2f4>
2a78: e5930000 ldr r0, [r3]
2a7c: eb000d8f bl 60c0 <rtems_semaphore_release>
}
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
2a80: e3550000 cmp r5, #0
2a84: 1a00000f bne 2ac8 <mount+0x2a4>
rtems_filesystem_global_location_t *new_fs_root =
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
2a88: e2844024 add r4, r4, #36 ; 0x24
rv = -1;
}
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
rtems_filesystem_global_location_t *new_fs_root =
2a8c: e1a00004 mov r0, r4
2a90: eb0003d9 bl 39fc <rtems_filesystem_global_location_obtain>
2a94: e1a07000 mov r7, r0
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_t *new_fs_current =
2a98: e1a00004 mov r0, r4
2a9c: eb0003d6 bl 39fc <rtems_filesystem_global_location_obtain>
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
2aa0: e59f4074 ldr r4, [pc, #116] ; 2b1c <mount+0x2f8>
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
rtems_filesystem_global_location_t *new_fs_root =
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_t *new_fs_current =
2aa4: e1a06000 mov r6, r0
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
2aa8: e5940000 ldr r0, [r4]
2aac: e1a01007 mov r1, r7
2ab0: e2800004 add r0, r0, #4
2ab4: eb0003c6 bl 39d4 <rtems_filesystem_global_location_assign>
&rtems_filesystem_root,
new_fs_root
);
rtems_filesystem_global_location_assign(
2ab8: e5940000 ldr r0, [r4]
2abc: e1a01006 mov r1, r6
2ac0: eb0003c3 bl 39d4 <rtems_filesystem_global_location_assign>
2ac4: ea00000a b 2af4 <mount+0x2d0>
} else {
rv = register_root_file_system( mt_entry );
}
if ( rv != 0 ) {
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
2ac8: e594300c ldr r3, [r4, #12]
2acc: e1a00004 mov r0, r4
2ad0: e1a0e00f mov lr, pc
2ad4: e593f03c ldr pc, [r3, #60] ; 0x3c
}
}
if ( rv != 0 ) {
free( mt_entry );
2ad8: e1a00004 mov r0, r4
2adc: ebfffe11 bl 2328 <free>
2ae0: ea000003 b 2af4 <mount+0x2d0>
} else {
errno = EINVAL;
rv = -1;
}
} else {
errno = EINVAL;
2ae4: eb002b12 bl d734 <__errno>
2ae8: e3a03016 mov r3, #22
2aec: e5803000 str r3, [r0]
rv = -1;
2af0: e3e05000 mvn r5, #0
}
return rv;
}
2af4: e1a00005 mov r0, r5
2af8: e28dd060 add sp, sp, #96 ; 0x60
2afc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if ( rv != 0 ) {
free( mt_entry );
}
} else {
errno = ENOMEM;
2b00: eb002b0b bl d734 <__errno> <== NOT EXECUTED
2b04: e3a0300c mov r3, #12 <== NOT EXECUTED
2b08: eafffff7 b 2aec <mount+0x2c8> <== NOT EXECUTED
00015004 <msdos_creat_node>:
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
15004: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
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;
15008: e3a05000 mov r5, #0
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
1500c: e24dd0ac sub sp, sp, #172 ; 0xac 15010: e1a09003 mov r9, r3
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
15014: e5903014 ldr r3, [r0, #20]
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
15018: e58d200c str r2, [sp, #12]
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;
1501c: e590a008 ldr sl, [r0, #8]
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
15020: e3e08000 mvn r8, #0
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
15024: e3a02020 mov r2, #32
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
15028: e1a07000 mov r7, r0 1502c: e1a06001 mov r6, r1
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
15030: e28d0054 add r0, sp, #84 ; 0x54 15034: e1a01005 mov r1, r5
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;
15038: e5934008 ldr r4, [r3, #8]
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
fat_file_fd_t *fat_fd = NULL;
1503c: e58d50a4 str r5, [sp, #164] ; 0xa4
time_t time_ret = 0;
uint16_t time_val = 0;
15040: e1cd5ab8 strh r5, [sp, #168] ; 0xa8
uint16_t date = 0;
15044: e1cd5aba strh r5, [sp, #170] ; 0xaa
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
15048: e58d5094 str r5, [sp, #148] ; 0x94
dir_pos->sname.ofs = 0;
1504c: e58d5098 str r5, [sp, #152] ; 0x98
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
15050: e58d809c str r8, [sp, #156] ; 0x9c
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
15054: e58d80a0 str r8, [sp, #160] ; 0xa0
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
15058: eb0010df bl 193dc <memset>
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
1505c: e28d0014 add r0, sp, #20 15060: e1a01005 mov r1, r5 15064: e3a02040 mov r2, #64 ; 0x40 15068: eb0010db bl 193dc <memset>
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
1506c: e3590f41 cmp r9, #260 ; 0x104
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;
time_t time_ret = 0;
uint16_t time_val = 0;
15070: e1a0b005 mov fp, r5
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
15074: da000002 ble 15084 <msdos_creat_node+0x80>
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
15078: eb000dfa bl 18868 <__errno> <== NOT EXECUTED 1507c: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED 15080: ea000009 b 150ac <msdos_creat_node+0xa8> <== NOT EXECUTED
}
name_type = msdos_long_to_short (name, name_len,
15084: e59d000c ldr r0, [sp, #12] 15088: e1a01009 mov r1, r9 1508c: e28d2054 add r2, sp, #84 ; 0x54 15090: e3a0300b mov r3, #11 15094: eb000107 bl 154b8 <msdos_long_to_short>
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
if (name_type == MSDOS_NAME_INVALID) {
15098: e3500000 cmp r0, #0 1509c: e58d0010 str r0, [sp, #16]
150a0: 1a000003 bne 150b4 <msdos_creat_node+0xb0>
rtems_set_errno_and_return_minus_one(EINVAL);
150a4: eb000def bl 18868 <__errno> <== NOT EXECUTED 150a8: e3a03016 mov r3, #22 <== NOT EXECUTED 150ac: e5803000 str r3, [r0] <== NOT EXECUTED 150b0: ea0000a9 b 1535c <msdos_creat_node+0x358> <== 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);
150b4: e1a00005 mov r0, r5
if (name_type == MSDOS_NAME_INVALID) {
rtems_set_errno_and_return_minus_one(EINVAL);
}
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
150b8: e5cd5060 strb r5, [sp, #96] ; 0x60
/* set up last write date and time */
time_ret = time(NULL);
150bc: eb00219b bl 1d730 <time>
if ( time_ret == -1 )
150c0: e3700001 cmn r0, #1
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
/* set up last write date and time */
time_ret = time(NULL);
150c4: e1a08000 mov r8, r0
if ( time_ret == -1 )
150c8: 0a0000a3 beq 1535c <msdos_creat_node+0x358>
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
150cc: e28d20a8 add r2, sp, #168 ; 0xa8 150d0: e28d10aa add r1, sp, #170 ; 0xaa 150d4: eb000a38 bl 179bc <msdos_date_unix2dos>
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
150d8: e1dd3aba ldrh r3, [sp, #170] ; 0xaa
*MSDOS_DIR_LAST_ACCESS_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) {
150dc: e3560000 cmp r6, #0
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
150e0: e1dd2ab8 ldrh r2, [sp, #168] ; 0xa8
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
150e4: e1cd36b4 strh r3, [sp, #100] ; 0x64
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
150e8: e1cd36bc strh r3, [sp, #108] ; 0x6c
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
150ec: e1cd36b6 strh r3, [sp, #102] ; 0x66
/* 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;
150f0: 05dd305f ldrbeq r3, [sp, #95] ; 0x5f
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
150f4: e1cd26b2 strh r2, [sp, #98] ; 0x62
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
150f8: e1cd26ba strh r2, [sp, #106] ; 0x6a
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
150fc: e58d5070 str r5, [sp, #112] ; 0x70
if (type == MSDOS_DIRECTORY) {
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
15100: 03833010 orreq r3, r3, #16
*MSDOS_DIR_LAST_ACCESS_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) {
15104: 0a00002b beq 151b8 <msdos_creat_node+0x1b4>
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
}
else if (type == MSDOS_HARD_LINK) {
15108: e3560002 cmp r6, #2
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
}
else { /* regular file... */
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
1510c: 15dd305f ldrbne r3, [sp, #95] ; 0x5f
*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) {
15110: 1a000027 bne 151b4 <msdos_creat_node+0x1b0>
* node to the newly created
*/
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat,
15114: e59d20d4 ldr r2, [sp, #212] ; 0xd4 <== NOT EXECUTED 15118: e5921020 ldr r1, [r2, #32] <== NOT EXECUTED
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
1511c: e3510000 cmp r1, #0 <== NOT EXECUTED 15120: 1a000003 bne 15134 <msdos_creat_node+0x130> <== NOT EXECUTED 15124: e5d4300e ldrb r3, [r4, #14] <== NOT EXECUTED 15128: e3130003 tst r3, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
1512c: 15941020 ldrne r1, [r4, #32] <== NOT EXECUTED
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
15130: 1a000003 bne 15144 <msdos_creat_node+0x140> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
15134: e5d42005 ldrb r2, [r4, #5] <== NOT EXECUTED 15138: e5943034 ldr r3, [r4, #52] ; 0x34 <== NOT EXECUTED 1513c: e2411002 sub r1, r1, #2 <== NOT EXECUTED 15140: e0831211 add r1, r3, r1, lsl r2 <== NOT EXECUTED
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
15144: e59d20d4 ldr r2, [sp, #212] ; 0xd4 <== NOT EXECUTED 15148: e5923024 ldr r3, [r2, #36] ; 0x24 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
1514c: e1d420b0 ldrh r2, [r4] <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
15150: e5d4c002 ldrb ip, [r4, #2] <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ret = _fat_block_read(&fs_info->fat,
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
15154: e28d0074 add r0, sp, #116 ; 0x74 <== NOT EXECUTED
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
15158: e2422001 sub r2, r2, #1 <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
1515c: e58d0000 str r0, [sp] <== NOT EXECUTED 15160: e0811c33 add r1, r1, r3, lsr ip <== NOT EXECUTED 15164: e0022003 and r2, r2, r3 <== NOT EXECUTED 15168: e1a00004 mov r0, r4 <== NOT EXECUTED 1516c: e3a03020 mov r3, #32 <== NOT EXECUTED 15170: ebffef22 bl 10e00 <_fat_block_read> <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
15174: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
15178: b3e08000 mvnlt r8, #0 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ret = _fat_block_read(&fs_info->fat,
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
1517c: ba000076 blt 1535c <msdos_creat_node+0x358> <== 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);
15180: e5dd2081 ldrb r2, [sp, #129] ; 0x81 <== NOT EXECUTED 15184: e5cd2061 strb r2, [sp, #97] ; 0x61 <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
15188: e1dd28b2 ldrh r2, [sp, #130] ; 0x82 <== NOT EXECUTED 1518c: e1cd26b2 strh r2, [sp, #98] ; 0x62 <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
15190: e1dd28b4 ldrh r2, [sp, #132] ; 0x84 <== NOT EXECUTED 15194: e1cd26b4 strh r2, [sp, #100] ; 0x64 <== NOT EXECUTED
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
15198: e59d2090 ldr r2, [sp, #144] ; 0x90 <== NOT EXECUTED 1519c: e58d2070 str r2, [sp, #112] ; 0x70 <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
151a0: e1dd28be ldrh r2, [sp, #142] ; 0x8e <== NOT EXECUTED 151a4: e1cd26be strh r2, [sp, #110] ; 0x6e <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
151a8: e1dd28b8 ldrh r2, [sp, #136] ; 0x88 <== NOT EXECUTED
return -1;
}
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
151ac: e5dd307f ldrb r3, [sp, #127] ; 0x7f <== 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) =
151b0: e1cd26b8 strh r2, [sp, #104] ; 0x68 <== NOT EXECUTED
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
}
else { /* regular file... */
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
151b4: e3833020 orr r3, r3, #32 151b8: e5cd305f strb r3, [sp, #95] ; 0x5f
/*
* 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,
151bc: e59d3010 ldr r3, [sp, #16] 151c0: e28db094 add fp, sp, #148 ; 0x94 151c4: e58d3000 str r3, [sp]
name_type, &dir_pos, short_node);
151c8: e28d5054 add r5, sp, #84 ; 0x54
/*
* 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,
151cc: e1a00007 mov r0, r7 151d0: e3a01001 mov r1, #1 151d4: e59d200c ldr r2, [sp, #12] 151d8: e1a03009 mov r3, r9 151dc: e58db004 str fp, [sp, #4] 151e0: e58d5008 str r5, [sp, #8] 151e4: eb00052c bl 1669c <msdos_get_name_node>
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
151e8: e2508000 subs r8, r0, #0
151ec: 1a00005a bne 1535c <msdos_creat_node+0x358>
/*
* if we create a new file we are done, if directory there are more steps
* to do
*/
if (type == MSDOS_DIRECTORY)
151f0: e3560000 cmp r6, #0
151f4: 1a000058 bne 1535c <msdos_creat_node+0x358>
{
/* open new directory as fat-file */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
151f8: e1a00004 mov r0, r4 151fc: e1a0100b mov r1, fp 15200: e28d20a4 add r2, sp, #164 ; 0xa4 15204: ebffebbf bl 10108 <fat_file_open>
if (rc != RC_OK)
15208: e2508000 subs r8, r0, #0
1520c: 1a00004e bne 1534c <msdos_creat_node+0x348>
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
15210: e59d80a4 ldr r8, [sp, #164] ; 0xa4
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
15214: e3a03602 mov r3, #2097152 ; 0x200000
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
15218: e5886018 str r6, [r8, #24]
fat_fd->fat_file_type = FAT_DIRECTORY;
1521c: e5886010 str r6, [r8, #16]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
15220: e5883014 str r3, [r8, #20]
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
15224: e1a0c005 mov ip, r5
15228: e8bc000f ldm ip!, {r0, r1, r2, r3}
1522c: e28de014 add lr, sp, #20
15230: e8ae000f stmia lr!, {r0, r1, r2, r3}
15234: e89c000f ldm ip, {r0, r1, r2, r3}
15238: e88e000f stm lr, {r0, r1, r2, r3}
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
1523c: e8b5000f ldm r5!, {r0, r1, r2, r3}
15240: e28de034 add lr, sp, #52 ; 0x34
15244: e8ae000f stmia lr!, {r0, r1, r2, r3}
15248: e89c000f ldm ip, {r0, r1, r2, r3}
1524c: e88e000f stm lr, {r0, r1, r2, r3}
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
15250: e59f3110 ldr r3, [pc, #272] ; 15368 <msdos_creat_node+0x364> 15254: e3a0200b mov r2, #11 15258: e5931000 ldr r1, [r3] 1525c: e28d0014 add r0, sp, #20 15260: eb001027 bl 19304 <memcpy>
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
15264: e59f3100 ldr r3, [pc, #256] ; 1536c <msdos_creat_node+0x368> 15268: e28d0034 add r0, sp, #52 ; 0x34 1526c: e5931000 ldr r1, [r3] 15270: e3a0200b mov r2, #11 15274: eb001022 bl 19304 <memcpy>
/*
* 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)) &&
15278: e59a3020 ldr r3, [sl, #32] 1527c: e3530001 cmp r3, #1
15280: 1a000007 bne 152a4 <msdos_creat_node+0x2a0>
15284: e59a3024 ldr r3, [sl, #36] ; 0x24 15288: e3530000 cmp r3, #0
1528c: 1a000004 bne 152a4 <msdos_creat_node+0x2a0>
(fs_info->fat.vol.type & FAT_FAT32))
15290: e5d4300e ldrb r3, [r4, #14]
/*
* 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)) &&
15294: e3130004 tst r3, #4
(fs_info->fat.vol.type & FAT_FAT32))
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
15298: 11cd64be strhne r6, [sp, #78] ; 0x4e
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
1529c: 11cd64b8 strhne r6, [sp, #72] ; 0x48
/*
* 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)) &&
152a0: 1a000003 bne 152b4 <msdos_creat_node+0x2b0>
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
152a4: e59a301c ldr r3, [sl, #28] 152a8: e1cd34be strh r3, [sp, #78] ; 0x4e
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
152ac: e1a03823 lsr r3, r3, #16 152b0: e1cd34b8 strh r3, [sp, #72] ; 0x48
* 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(&fs_info->fat, fat_fd, 0,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
152b4: e28d5014 add r5, sp, #20
/*
* 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(&fs_info->fat, fat_fd, 0,
152b8: e1a00004 mov r0, r4 152bc: e1a01008 mov r1, r8 152c0: e3a02000 mov r2, #0 152c4: e3a03040 mov r3, #64 ; 0x40 152c8: e58d5000 str r5, [sp] 152cc: ebffed66 bl 1086c <fat_file_write>
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
152d0: e3500000 cmp r0, #0
152d4: ba000018 blt 1533c <msdos_creat_node+0x338>
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
152d8: e59d10a4 ldr r1, [sp, #164] ; 0xa4 152dc: e1d430b6 ldrh r3, [r4, #6] 152e0: e5912018 ldr r2, [r1, #24] 152e4: e0823003 add r3, r2, r3 152e8: e5813018 str r3, [r1, #24]
/* 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));
152ec: e591301c ldr r3, [r1, #28] 152f0: e1cd32be strh r3, [sp, #46] ; 0x2e
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
152f4: e1a03823 lsr r3, r3, #16 152f8: e1cd32b8 strh r3, [sp, #40] ; 0x28
/* rewrite dot entry */
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
152fc: e1a00004 mov r0, r4 15300: e3a02000 mov r2, #0 15304: e3a03020 mov r3, #32 15308: e58d5000 str r5, [sp] 1530c: ebffed56 bl 1086c <fat_file_write>
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
15310: e3500000 cmp r0, #0
15314: ba000008 blt 1533c <msdos_creat_node+0x338>
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);
15318: e5970014 ldr r0, [r7, #20] 1531c: e59d10a4 ldr r1, [sp, #164] ; 0xa4 15320: eb00010f bl 15764 <msdos_set_first_cluster_num>
if (rc != RC_OK)
15324: e2508000 subs r8, r0, #0
15328: 1a000004 bne 15340 <msdos_creat_node+0x33c>
goto error;
fat_file_close(&fs_info->fat, fat_fd);
1532c: e1a00004 mov r0, r4 15330: e59d10a4 ldr r1, [sp, #164] ; 0xa4 15334: ebffec6d bl 104f0 <fat_file_close> 15338: ea000007 b 1535c <msdos_creat_node+0x358>
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
{
rc = -1;
1533c: e3e08000 mvn r8, #0 <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
}
return RC_OK;
error:
fat_file_close(&fs_info->fat, fat_fd);
15340: e1a00004 mov r0, r4 <== NOT EXECUTED 15344: e59d10a4 ldr r1, [sp, #164] ; 0xa4 <== NOT EXECUTED 15348: ebffec68 bl 104f0 <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);
1534c: e5970014 ldr r0, [r7, #20] <== NOT EXECUTED 15350: e28d1094 add r1, sp, #148 ; 0x94 <== NOT EXECUTED 15354: e3a020e5 mov r2, #229 ; 0xe5 <== NOT EXECUTED 15358: eb000141 bl 15864 <msdos_set_first_char4file_name> <== NOT EXECUTED
return rc;
}
1535c: e1a00008 mov r0, r8
15360: e28dd0ac add sp, sp, #172 ; 0xac
15364: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00017af8 <msdos_date_dos2unix>:
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
17af8: e2012e7e and r2, r1, #2016 ; 0x7e0 17afc: e3a0301e mov r3, #30 17b00: e1a022a2 lsr r2, r2, #5 17b04: e0020293 mul r2, r3, r2
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
17b08: e201cb3e and ip, r1, #63488 ; 0xf800 17b0c: e59f30d8 ldr r3, [pc, #216] ; 17bec <msdos_date_dos2unix+0xf4> 17b10: e1a0c5ac lsr ip, ip, #11 17b14: e023239c mla r3, ip, r3, r2
uint32_t m, month;
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
17b18: e201101f and r1, r1, #31
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60 + ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
17b1c: e0831001 add r1, r3, r1
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
17b20: e59f30c8 ldr r3, [pc, #200] ; 17bf0 <msdos_date_dos2unix+0xf8> 17b24: e1d320be ldrh r2, [r3, #14] 17b28: e1520000 cmp r2, r0
* 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)
{
17b2c: e92d40f0 push {r4, r5, r6, r7, lr}
uint32_t m, month;
uint32_t y, year;
uint32_t days;
uint16_t *months;
seconds = 2 * ((dt & MSDOS_DT_2SECONDS_MASK) >> MSDOS_DT_2SECONDS_SHIFT)
17b30: e1a01081 lsl r1, r1, #1
+ ((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) {
17b34: 0a000028 beq 17bdc <msdos_date_dos2unix+0xe4>
lastdosdate = dd;
17b38: e1c300be strh r0, [r3, #14]
days = 0; year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
17b3c: e2007cfe and r7, r0, #65024 ; 0xfe00
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
17b40: e3a03000 mov r3, #0
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
17b44: e1a074a7 lsr r7, r7, #9
for (y = 0; y < year; y++)
17b48: e1a02003 mov r2, r3
days += y & 0x03 ? 365 : 366;
17b4c: e59f60a0 ldr r6, [pc, #160] ; 17bf4 <msdos_date_dos2unix+0xfc> 17b50: e59f50a0 ldr r5, [pc, #160] ; 17bf8 <msdos_date_dos2unix+0x100>
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
17b54: ea000004 b 17b6c <msdos_date_dos2unix+0x74>
days += y & 0x03 ? 365 : 366;
17b58: e3540000 cmp r4, #0 17b5c: 01a04006 moveq r4, r6 17b60: 11a04005 movne r4, r5 17b64: e0833004 add r3, r3, r4
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
17b68: e2822001 add r2, r2, #1 17b6c: e1520007 cmp r2, r7 17b70: e2024003 and r4, r2, #3
17b74: 1afffff7 bne 17b58 <msdos_date_dos2unix+0x60> months = year & 0x03 ? regyear : leapyear; /* * Prevent going from 0 to 0xffffffff in the following * loop. */ month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
17b78: e2002e1e and r2, r0, #480 ; 0x1e0
if (month == 0) {
month = 1;
17b7c: e3520000 cmp r2, #0 17b80: 11a052a2 lsrne r5, r2, #5
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
17b84: e59f2070 ldr r2, [pc, #112] ; 17bfc <msdos_date_dos2unix+0x104>
month = 1;
17b88: 03a05001 moveq r5, #1
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
17b8c: e3540000 cmp r4, #0 17b90: e282c018 add ip, r2, #24
month = 1; } for (m = 0; m < month - 1; m++)
17b94: e2454001 sub r4, r5, #1
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
17b98: 11a0c002 movne ip, r2
month = 1; } for (m = 0; m < month - 1; m++)
17b9c: e3a02000 mov r2, #0 17ba0: ea000002 b 17bb0 <msdos_date_dos2unix+0xb8>
days += months[m];
17ba4: e0dc50b2 ldrh r5, [ip], #2 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
17ba8: e2822001 add r2, r2, #1 <== NOT EXECUTED
days += months[m];
17bac: 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++)
17bb0: e1520004 cmp r2, r4
17bb4: 3afffffa bcc 17ba4 <msdos_date_dos2unix+0xac> days += months[m]; days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
17bb8: e200001f and r0, r0, #31
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
17bbc: e59f203c ldr r2, [pc, #60] ; 17c00 <msdos_date_dos2unix+0x108>
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
17bc0: e2400001 sub r0, r0, #1 17bc4: e0803003 add r3, r0, r3
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
17bc8: e0030392 mul r3, r2, r3 17bcc: e59f2030 ldr r2, [pc, #48] ; 17c04 <msdos_date_dos2unix+0x10c> 17bd0: e0832002 add r2, r3, r2 17bd4: e59f3014 ldr r3, [pc, #20] ; 17bf0 <msdos_date_dos2unix+0xf8> 17bd8: e5832010 str r2, [r3, #16]
} return seconds + lastseconds;
17bdc: e59f300c ldr r3, [pc, #12] ; 17bf0 <msdos_date_dos2unix+0xf8> 17be0: e5933010 ldr r3, [r3, #16]
}
17be4: e0810003 add r0, r1, r3
17be8: e8bd80f0 pop {r4, r5, r6, r7, pc}
000179bc <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)
{
179bc: e92d41f0 push {r4, r5, r6, r7, r8, lr}
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
179c0: e59f6114 ldr r6, [pc, #276] ; 17adc <msdos_date_unix2dos+0x120> 179c4: e5963000 ldr r3, [r6] 179c8: e1530000 cmp r3, r0
* 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)
{
179cc: e1a04000 mov r4, r0 179d0: e1a05001 mov r5, r1 179d4: e1a07002 mov r7, r2
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
179d8: 0a000039 beq 17ac4 <msdos_date_unix2dos+0x108>
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
179dc: e3a0103c mov r1, #60 ; 0x3c
/*
* 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;
179e0: e5860000 str r0, [r6]
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT) + (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
179e4: ebffa89d bl 1c60 <__aeabi_uidiv> 179e8: e3a0103c mov r1, #60 ; 0x3c 179ec: ebffa8e1 bl 1d78 <__umodsi3>
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
179f0: e3a01ee1 mov r1, #3600 ; 0xe10
* 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)
179f4: e1a08280 lsl r8, r0, #5
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT) + (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
179f8: e1a00004 mov r0, r4 179fc: ebffa897 bl 1c60 <__aeabi_uidiv> 17a00: e3a01018 mov r1, #24 17a04: ebffa8db bl 1d78 <__umodsi3>
* 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)
17a08: e3a0103c mov r1, #60 ; 0x3c 17a0c: e0888580 add r8, r8, r0, lsl #11 17a10: e1a00004 mov r0, r4 17a14: ebffa8d7 bl 1d78 <__umodsi3> 17a18: e08800a0 add r0, r8, r0, lsr #1 17a1c: e1c600b4 strh r0, [r6, #4]
/* * 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);
17a20: e59f10b8 ldr r1, [pc, #184] ; 17ae0 <msdos_date_unix2dos+0x124> 17a24: e1a00004 mov r0, r4 17a28: ebffa88c bl 1c60 <__aeabi_uidiv>
if (days != lastday) {
17a2c: e5963008 ldr r3, [r6, #8] 17a30: e1500003 cmp r0, r3
17a34: 0a000022 beq 17ac4 <msdos_date_unix2dos+0x108> lastday = days;
17a38: e5860008 str r0, [r6, #8]
for (year = 1970;; year++) {
17a3c: e59f30a0 ldr r3, [pc, #160] ; 17ae4 <msdos_date_unix2dos+0x128>
inc = year & 0x03 ? 365 : 366;
17a40: e59f40a0 ldr r4, [pc, #160] ; 17ae8 <msdos_date_unix2dos+0x12c> 17a44: e59f10a0 ldr r1, [pc, #160] ; 17aec <msdos_date_unix2dos+0x130> 17a48: e213c003 ands ip, r3, #3 17a4c: 01a02004 moveq r2, r4 17a50: 11a02001 movne r2, r1
if (days < inc)
17a54: e1500002 cmp r0, r2
break; days -= inc;
17a58: 20620000 rsbcs r0, r2, r0
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
lastday = days;
for (year = 1970;; year++) {
17a5c: 22833001 addcs r3, r3, #1
inc = year & 0x03 ? 365 : 366; if (days < inc) break; days -= inc; } 17a60: 2afffff8 bcs 17a48 <msdos_date_unix2dos+0x8c> months = year & 0x03 ? regyear : leapyear;
17a64: e59f2084 ldr r2, [pc, #132] ; 17af0 <msdos_date_unix2dos+0x134> 17a68: e35c0000 cmp ip, #0 17a6c: e2821018 add r1, r2, #24 17a70: 11a01002 movne r1, r2
for (month = 0; month < 12; month++) {
17a74: e3a02000 mov r2, #0
if (days < months[month])
17a78: e0d1c0b2 ldrh ip, [r1], #2 17a7c: e150000c cmp r0, ip
17a80: 3a000003 bcc 17a94 <msdos_date_unix2dos+0xd8>
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
17a84: e2822001 add r2, r2, #1 <== NOT EXECUTED 17a88: e352000c cmp r2, #12 <== NOT EXECUTED
if (days < months[month]) break; days -= months[month];
17a8c: e06c0000 rsb r0, ip, r0 <== NOT EXECUTED
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
17a90: 1afffff8 bne 17a78 <msdos_date_unix2dos+0xbc> <== NOT EXECUTED
if (days < months[month]) break; days -= months[month]; } lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
17a94: e0802282 add r2, r0, r2, lsl #5
* 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)
17a98: e59f0054 ldr r0, [pc, #84] ; 17af4 <msdos_date_unix2dos+0x138>
for (month = 0; month < 12; month++) {
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
17a9c: e2822021 add r2, r2, #33 ; 0x21
* 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)
17aa0: e1530000 cmp r3, r0
lastddate += (year - 1980) <<
17aa4: 82433e7b subhi r3, r3, #1968 ; 0x7b0
for (month = 0; month < 12; month++) {
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
17aa8: e1a02802 lsl r2, r2, #16 17aac: e1a02822 lsr r2, r2, #16 17ab0: e59f1024 ldr r1, [pc, #36] ; 17adc <msdos_date_unix2dos+0x120>
* 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) <<
17ab4: 8243300c subhi r3, r3, #12 17ab8: 80823483 addhi r3, r2, r3, lsl #9
for (month = 0; month < 12; month++) {
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
17abc: e1c120bc strh r2, [r1, #12]
* 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) <<
17ac0: 81c130bc strhhi r3, [r1, #12]
MSDOS_DD_YEAR_SHIFT; } } *dtp = lastdtime;
17ac4: e59f3010 ldr r3, [pc, #16] ; 17adc <msdos_date_unix2dos+0x120> 17ac8: e1d320b4 ldrh r2, [r3, #4]
*ddp = lastddate;
17acc: e1d330bc ldrh r3, [r3, #12]
if (year > 1980) lastddate += (year - 1980) << MSDOS_DD_YEAR_SHIFT; } } *dtp = lastdtime;
17ad0: e1c720b0 strh r2, [r7]
*ddp = lastddate;
17ad4: e1c530b0 strh r3, [r5]
}
17ad8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
00015968 <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
)
{
15968: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
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;
1596c: e3a06000 mov r6, #0
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
15970: e5904008 ldr r4, [r0, #8]
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
15974: e1a0b001 mov fp, r1 15978: e1a05002 mov r5, r2
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;
1597c: e5c26000 strb r6, [r2]
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
15980: ea00002a b 15a30 <msdos_dir_is_empty+0xc8>
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
15984: e350001f cmp r0, #31
15988: da000034 ble 15a60 <msdos_dir_is_empty+0xf8>
return -1;
assert(ret == fs_info->fat.vol.bps);
1598c: e1d490b0 ldrh r9, [r4] 15990: e1500009 cmp r0, r9
15994: 0a000021 beq 15a20 <msdos_dir_is_empty+0xb8>
15998: e59f00d0 ldr r0, [pc, #208] ; 15a70 <msdos_dir_is_empty+0x108><== NOT EXECUTED 1599c: e59f10d0 ldr r1, [pc, #208] ; 15a74 <msdos_dir_is_empty+0x10c><== NOT EXECUTED 159a0: e59f20d0 ldr r2, [pc, #208] ; 15a78 <msdos_dir_is_empty+0x110><== NOT EXECUTED 159a4: e59f30d0 ldr r3, [pc, #208] ; 15a7c <msdos_dir_is_empty+0x114><== NOT EXECUTED 159a8: ebfff25f bl 1232c <__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;
159ac: e59430a0 ldr r3, [r4, #160] ; 0xa0
* 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)) ==
159b0: e7d38007 ldrb r8, [r3, r7] 159b4: e35800e5 cmp r8, #229 ; 0xe5
/* 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;
159b8: e083a007 add sl, r3, r7
* 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)) ==
159bc: 0a00000f beq 15a00 <msdos_dir_is_empty+0x98>
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
159c0: e5da300b ldrb r3, [sl, #11] 159c4: e203303f and r3, r3, #63 ; 0x3f
*
* Just ignore long file name entries. They must have a short entry to
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
159c8: e353000f cmp r3, #15
159cc: 0a00000b beq 15a00 <msdos_dir_is_empty+0x98>
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
159d0: e1a0000a mov r0, sl 159d4: e59f10a4 ldr r1, [pc, #164] ; 15a80 <msdos_dir_is_empty+0x118> 159d8: e3a0200b mov r2, #11 159dc: eb0014f7 bl 1adc0 <strncmp>
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
159e0: e3500000 cmp r0, #0
159e4: 0a000005 beq 15a00 <msdos_dir_is_empty+0x98>
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
159e8: e1a0000a mov r0, sl 159ec: e59f1090 ldr r1, [pc, #144] ; 15a84 <msdos_dir_is_empty+0x11c> 159f0: e3a0200b mov r2, #11 159f4: eb0014f1 bl 1adc0 <strncmp>
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
159f8: e3500000 cmp r0, #0
159fc: 1a000001 bne 15a08 <msdos_dir_is_empty+0xa0>
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)
15a00: e2877020 add r7, r7, #32 15a04: ea000006 b 15a24 <msdos_dir_is_empty+0xbc>
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
15a08: e3580000 cmp r8, #0
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
15a0c: 03a03001 moveq r3, #1 15a10: 05c53000 strbeq r3, [r5]
return RC_OK;
15a14: 01a00008 moveq r0, r8
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
15a18: 0a000013 beq 15a6c <msdos_dir_is_empty+0x104>
15a1c: ea000011 b 15a68 <msdos_dir_is_empty+0x100>
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
return -1;
assert(ret == fs_info->fat.vol.bps);
15a20: e3a07000 mov r7, #0
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
15a24: e1570009 cmp r7, r9
15a28: 3affffdf bcc 159ac <msdos_dir_is_empty+0x44>
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
15a2c: 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(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
15a30: e1d430b0 ldrh r3, [r4] 15a34: e59420a0 ldr r2, [r4, #160] ; 0xa0 15a38: e1a00004 mov r0, r4 15a3c: e58d2000 str r2, [sp] 15a40: e1a0100b mov r1, fp 15a44: e0020693 mul r2, r3, r6 15a48: ebffea03 bl 1025c <fat_file_read> 15a4c: e3500000 cmp r0, #0
15a50: 1affffcb bne 15984 <msdos_dir_is_empty+0x1c>
*/
return RC_OK;
}
j++;
}
*ret_val = true;
15a54: e3a03001 mov r3, #1 <== NOT EXECUTED 15a58: e5c53000 strb r3, [r5] <== NOT EXECUTED
return RC_OK;
15a5c: ea000002 b 15a6c <msdos_dir_is_empty+0x104> <== NOT EXECUTED
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
return -1;
15a60: e3e00000 mvn r0, #0 <== NOT EXECUTED 15a64: ea000000 b 15a6c <msdos_dir_is_empty+0x104> <== NOT EXECUTED
}
/*
* Short file name entries mean not empty.
*/
return RC_OK;
15a68: e3a00000 mov r0, #0
}
j++;
}
*ret_val = true;
return RC_OK;
}
15a6c: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
00017d6c <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)
{
17d6c: 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;
17d70: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
17d74: e590a018 ldr sl, [r0, #24] <== 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)
{
17d78: e24ddf55 sub sp, sp, #340 ; 0x154 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
17d7c: e5934008 ldr r4, [r3, #8] <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
fat_file_fd_t *tmp_fat_fd = NULL;
17d80: e3a03000 mov r3, #0 <== NOT EXECUTED 17d84: e58d314c str r3, [sp, #332] ; 0x14c <== 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;
17d88: e58d3150 str r3, [sp, #336] ; 0x150 <== NOT EXECUTED
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
17d8c: e59a3020 ldr r3, [sl, #32] <== NOT EXECUTED 17d90: e3530001 cmp r3, #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)
{
17d94: e58d0010 str r0, [sp, #16] <== NOT EXECUTED 17d98: e58d1028 str r1, [sp, #40] ; 0x28 <== NOT EXECUTED 17d9c: e1a05002 mov r5, r2 <== 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);
17da0: e1a0c000 mov ip, r0 <== NOT EXECUTED
17da4: e9900300 ldmib r0, {r8, r9} <== NOT EXECUTED
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
17da8: 1a000006 bne 17dc8 <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) &&
17dac: e59a3024 ldr r3, [sl, #36] ; 0x24 <== NOT EXECUTED 17db0: e3530000 cmp r3, #0 <== NOT EXECUTED 17db4: 1a000003 bne 17dc8 <msdos_dir_read+0x5c> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
17db8: e5d4300e ldrb r3, [r4, #14] <== 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) &&
17dbc: e3130003 tst r3, #3 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
17dc0: 159ac018 ldrne ip, [sl, #24] <== 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) &&
17dc4: 1a000000 bne 17dcc <msdos_dir_read+0x60> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
17dc8: e1d4c0b6 ldrh ip, [r4, #6] <== NOT EXECUTED
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
17dcc: e3a01000 mov r1, #0 <== NOT EXECUTED 17dd0: e594009c ldr r0, [r4, #156] ; 0x9c <== NOT EXECUTED 17dd4: e1a02001 mov r2, r1 <== NOT EXECUTED
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
17dd8: e58dc01c str ip, [sp, #28] <== NOT EXECUTED
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
17ddc: ebffc0a7 bl 8080 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
17de0: e2506000 subs r6, r0, #0 <== NOT EXECUTED 17de4: 1a00001d bne 17e60 <msdos_dir_read+0xf4> <== 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);
17de8: e3a03000 mov r3, #0 <== NOT EXECUTED 17dec: e1a00008 mov r0, r8 <== NOT EXECUTED 17df0: e1a01009 mov r1, r9 <== NOT EXECUTED 17df4: e3a02e11 mov r2, #272 ; 0x110 <== NOT EXECUTED 17df8: ebffa65d bl 1774 <__divdi3> <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
17dfc: 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);
17e00: e1a09000 mov r9, r0 <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
17e04: e1a00005 mov r0, r5 <== NOT EXECUTED 17e08: ebffa794 bl 1c60 <__aeabi_uidiv> <== NOT EXECUTED 17e0c: e3a03e11 mov r3, #272 ; 0x110 <== NOT EXECUTED 17e10: e00c0093 mul ip, r3, r0 <== NOT EXECUTED 17e14: e1a05006 mov r5, r6 <== NOT EXECUTED 17e18: e58dc014 str ip, [sp, #20] <== NOT EXECUTED 17e1c: e1a0b006 mov fp, r6 <== NOT EXECUTED 17e20: e58d6018 str r6, [sp, #24] <== NOT EXECUTED 17e24: e3e08000 mvn r8, #0 <== NOT EXECUTED 17e28: e58d600c str r6, [sp, #12] <== NOT EXECUTED 17e2c: ea0000f2 b 181fc <msdos_dir_read+0x490> <== 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(&fs_info->fat, fat_fd, (j * bts2rd),
17e30: e59430a0 ldr r3, [r4, #160] ; 0xa0 <== NOT EXECUTED 17e34: e1a00004 mov r0, r4 <== NOT EXECUTED 17e38: e58d3000 str r3, [sp] <== NOT EXECUTED 17e3c: e1a0100a mov r1, sl <== NOT EXECUTED 17e40: e1a02006 mov r2, r6 <== NOT EXECUTED 17e44: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 17e48: ebffe103 bl 1025c <fat_file_read> <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
17e4c: 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(&fs_info->fat, fat_fd, (j * bts2rd),
17e50: e58d0024 str r0, [sp, #36] ; 0x24 <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
17e54: ca0000e0 bgt 181dc <msdos_dir_read+0x470> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
17e58: e594009c ldr r0, [r4, #156] ; 0x9c <== NOT EXECUTED 17e5c: ebffc0ce bl 819c <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
17e60: eb000280 bl 18868 <__errno> <== NOT EXECUTED 17e64: e3a03005 mov r3, #5 <== NOT EXECUTED 17e68: e5803000 str r3, [r0] <== NOT EXECUTED 17e6c: e3e03000 mvn r3, #0 <== NOT EXECUTED 17e70: ea0000e7 b 18214 <msdos_dir_read+0x4a8> <== NOT EXECUTED
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
17e74: e59530a0 ldr r3, [r5, #160] ; 0xa0 <== NOT EXECUTED 17e78: e0834007 add r4, r3, r7 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
17e7c: e7d33007 ldrb r3, [r3, r7] <== NOT EXECUTED 17e80: e3530000 cmp r3, #0 <== NOT EXECUTED 17e84: 01a04005 moveq r4, r5 <== NOT EXECUTED 17e88: 0a0000de beq 18208 <msdos_dir_read+0x49c> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
/* Is the directory entry empty */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
17e8c: e35300e5 cmp r3, #229 ; 0xe5 <== NOT EXECUTED 17e90: 0a0000cf beq 181d4 <msdos_dir_read+0x468> <== NOT EXECUTED
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
17e94: e5d4200b ldrb r2, [r4, #11] <== NOT EXECUTED 17e98: e3120008 tst r2, #8 <== NOT EXECUTED 17e9c: e202203f and r2, r2, #63 ; 0x3f <== NOT EXECUTED 17ea0: 0a000001 beq 17eac <msdos_dir_read+0x140> <== NOT EXECUTED 17ea4: e352000f cmp r2, #15 <== NOT EXECUTED 17ea8: 1a0000c9 bne 181d4 <msdos_dir_read+0x468> <== 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) ==
17eac: e352000f cmp r2, #15 <== NOT EXECUTED 17eb0: 1a00002d bne 17f6c <msdos_dir_read+0x200> <== NOT EXECUTED
int q;
/*
* Is this is the first entry of a LFN ?
*/
if (lfn_start == FAT_FILE_SHORT_NAME)
17eb4: e3780001 cmn r8, #1 <== NOT EXECUTED 17eb8: 1a00000a bne 17ee8 <msdos_dir_read+0x17c> <== NOT EXECUTED
{
/*
* The first entry must have the last long entry flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
17ebc: e3130040 tst r3, #64 ; 0x40 <== NOT EXECUTED 17ec0: 0a0000c3 beq 181d4 <msdos_dir_read+0x468> <== 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);
17ec4: e5d4c00d ldrb ip, [r4, #13] <== NOT EXECUTED
/*
* Remember the start location of the long file name.
*/
lfn_start =
((j * bts2rd) + i) / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
17ec8: e0878006 add r8, r7, r6 <== NOT EXECUTED
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
17ecc: e28d003c add r0, sp, #60 ; 0x3c <== NOT EXECUTED 17ed0: e3a01000 mov r1, #0 <== NOT EXECUTED 17ed4: e3a02c01 mov r2, #256 ; 0x100 <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
17ed8: e1a082a8 lsr r8, r8, #5 <== 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) &
17edc: e203b03f and fp, r3, #63 ; 0x3f <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
17ee0: e58dc018 str ip, [sp, #24] <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
17ee4: eb00053c bl 193dc <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) &
17ee8: e5d43000 ldrb r3, [r4] <== NOT EXECUTED 17eec: e203303f and r3, r3, #63 ; 0x3f <== NOT EXECUTED 17ef0: e15b0003 cmp fp, r3 <== NOT EXECUTED 17ef4: 1a0000b5 bne 181d0 <msdos_dir_read+0x464> <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
17ef8: e5d4300d ldrb r3, [r4, #13] <== NOT EXECUTED 17efc: e59dc018 ldr ip, [sp, #24] <== NOT EXECUTED 17f00: e153000c cmp r3, ip <== NOT EXECUTED 17f04: 1a0000b1 bne 181d0 <msdos_dir_read+0x464> <== 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--;
17f08: e24bb001 sub fp, fp, #1 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
17f0c: e3a0200d mov r2, #13 <== NOT EXECUTED 17f10: e002029b mul r2, fp, 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;
17f14: e2844001 add r4, r4, #1 <== NOT EXECUTED
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
17f18: e3a03000 mov r3, #0 <== NOT EXECUTED
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
17f1c: e35200fe cmp r2, #254 ; 0xfe <== NOT EXECUTED 17f20: 8a0000a6 bhi 181c0 <msdos_dir_read+0x454> <== NOT EXECUTED
break;
tmp_dirent.d_name[o++] = *p;
17f24: e5d40000 ldrb r0, [r4] <== 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)
17f28: e28dc02c add ip, sp, #44 ; 0x2c <== NOT EXECUTED 17f2c: e08c1002 add r1, ip, r2 <== NOT EXECUTED
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
break;
tmp_dirent.d_name[o++] = *p;
17f30: e5c10010 strb r0, [r1, #16] <== NOT EXECUTED
if (*p == '\0')
17f34: e5d41000 ldrb r1, [r4] <== NOT EXECUTED 17f38: e3510000 cmp r1, #0 <== NOT EXECUTED
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
break;
tmp_dirent.d_name[o++] = *p;
17f3c: e2822001 add r2, r2, #1 <== NOT EXECUTED
if (*p == '\0')
17f40: 0a00009e beq 181c0 <msdos_dir_read+0x454> <== NOT EXECUTED
break;
switch (q)
17f44: e3530004 cmp r3, #4 <== NOT EXECUTED
{
case 4:
p += 5;
17f48: 02844005 addeq r4, r4, #5 <== NOT EXECUTED
tmp_dirent.d_name[o++] = *p;
if (*p == '\0')
break;
switch (q)
17f4c: 0a000002 beq 17f5c <msdos_dir_read+0x1f0> <== NOT EXECUTED 17f50: e353000a cmp r3, #10 <== NOT EXECUTED
break;
case 10:
p += 4;
break;
default:
p += 2;
17f54: 12844002 addne r4, r4, #2 <== NOT EXECUTED
{
case 4:
p += 5;
break;
case 10:
p += 4;
17f58: 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++)
17f5c: e2833001 add r3, r3, #1 <== NOT EXECUTED 17f60: e353000d cmp r3, #13 <== NOT EXECUTED 17f64: 1affffec bne 17f1c <msdos_dir_read+0x1b0> <== NOT EXECUTED 17f68: ea000094 b 181c0 <msdos_dir_read+0x454> <== NOT EXECUTED
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
17f6c: e3590000 cmp r9, #0 <== NOT EXECUTED
{
lfn_start = FAT_FILE_SHORT_NAME;
start--;
17f70: 12499001 subne r9, r9, #1 <== NOT EXECUTED
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
17f74: 1a000095 bne 181d0 <msdos_dir_read+0x464> <== 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(&fs_info->fat, fat_fd, F_CLU_NUM,
17f78: e28d1e15 add r1, sp, #336 ; 0x150 <== NOT EXECUTED 17f7c: e58d1000 str r1, [sp] <== NOT EXECUTED 17f80: e1a03006 mov r3, r6 <== NOT EXECUTED 17f84: e1a00005 mov r0, r5 <== NOT EXECUTED 17f88: e1a0100a mov r1, sl <== NOT EXECUTED 17f8c: e3a02001 mov r2, #1 <== NOT EXECUTED 17f90: ebffe17e bl 10590 <fat_file_ioctl> <== NOT EXECUTED
j * bts2rd, &cur_cln);
if (rc != RC_OK)
17f94: e2503000 subs r3, r0, #0 <== NOT EXECUTED 17f98: 1a000082 bne 181a8 <msdos_dir_read+0x43c> <== 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;
17f9c: e3e03000 mvn r3, #0 <== NOT EXECUTED 17fa0: e58d3144 str r3, [sp, #324] ; 0x144 <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
17fa4: e58d3148 str r3, [sp, #328] ; 0x148 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
17fa8: e59d3150 ldr r3, [sp, #336] ; 0x150 <== NOT EXECUTED
dir_pos.sname.ofs = i;
rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
17fac: e1a00005 mov r0, r5 <== NOT EXECUTED 17fb0: e28d1f4f add r1, sp, #316 ; 0x13c <== NOT EXECUTED 17fb4: e28d2f53 add r2, sp, #332 ; 0x14c <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
17fb8: e58d313c str r3, [sp, #316] ; 0x13c <== NOT EXECUTED
dir_pos.sname.ofs = i;
17fbc: e58d7140 str r7, [sp, #320] ; 0x140 <== NOT EXECUTED
rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
17fc0: ebffe050 bl 10108 <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
17fc4: e2503000 subs r3, r0, #0 <== NOT EXECUTED 17fc8: 1a000076 bne 181a8 <msdos_dir_read+0x43c> <== 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);
17fcc: e59f32a4 ldr r3, [pc, #676] ; 18278 <msdos_dir_read+0x50c> <== NOT EXECUTED 17fd0: e3a02e11 mov r2, #272 ; 0x110 <== NOT EXECUTED 17fd4: e28d1f55 add r1, sp, #340 ; 0x154 <== NOT EXECUTED 17fd8: e18120b3 strh r2, [r1, r3] <== NOT EXECUTED
tmp_dirent.d_ino = tmp_fat_fd->ino;
17fdc: e59d314c ldr r3, [sp, #332] ; 0x14c <== 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;
17fe0: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
tmp_dirent.d_ino = tmp_fat_fd->ino;
17fe4: e593300c ldr r3, [r3, #12] <== 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)
17fe8: e3780001 cmn r8, #1 <== 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;
17fec: e58dc030 str ip, [sp, #48] ; 0x30 <== NOT EXECUTED 17ff0: e58d9034 str r9, [sp, #52] ; 0x34 <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
tmp_dirent.d_ino = tmp_fat_fd->ino;
17ff4: e58d302c str r3, [sp, #44] ; 0x2c <== 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)
17ff8: 0a00000e beq 18038 <msdos_dir_read+0x2cc> <== NOT EXECUTED 17ffc: e1a02009 mov r2, r9 <== NOT EXECUTED 18000: 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;
18004: e7d40002 ldrb r0, [r4, r2] <== NOT EXECUTED 18008: e2131001 ands r1, r3, #1 <== NOT EXECUTED 1800c: 13a01080 movne r1, #128 ; 0x80 <== NOT EXECUTED 18010: 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++)
18014: e2822001 add r2, r2, #1 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
18018: 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++)
1801c: e352000b cmp r2, #11 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
18020: 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++)
18024: 1afffff6 bne 18004 <msdos_dir_read+0x298> <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
18028: e59dc018 ldr ip, [sp, #24] <== NOT EXECUTED 1802c: e35b0000 cmp fp, #0 <== NOT EXECUTED 18030: 015c0003 cmpeq ip, r3 <== NOT EXECUTED 18034: 0a000079 beq 18220 <msdos_dir_read+0x4b4> <== NOT EXECUTED 18038: e1a01004 mov r1, r4 <== 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;
1803c: e3a03008 mov r3, #8 <== NOT EXECUTED 18040: ea000002 b 18050 <msdos_dir_read+0x2e4> <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
18044: e2533001 subs r3, r3, #1 <== NOT EXECUTED
int i;
for (i = 0; i < 11; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
18048: e2411001 sub r1, r1, #1 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
1804c: 0a000004 beq 18064 <msdos_dir_read+0x2f8> <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN-1);
((i > 0) &&
18050: e5d10007 ldrb r0, [r1, #7] <== NOT EXECUTED 18054: e3500020 cmp r0, #32 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
18058: e1a02003 mov r2, r3 <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN-1);
((i > 0) &&
1805c: 0afffff8 beq 18044 <msdos_dir_read+0x2d8> <== NOT EXECUTED 18060: ea000000 b 18068 <msdos_dir_read+0x2fc> <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
18064: e1a02003 mov r2, r3 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
18068: e59f120c ldr r1, [pc, #524] ; 1827c <msdos_dir_read+0x510> <== NOT EXECUTED 1806c: e5911000 ldr r1, [r1] <== NOT EXECUTED 18070: e1a0e004 mov lr, r4 <== NOT EXECUTED 18074: e58d1020 str r1, [sp, #32] <== 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(
18078: e28dc03c add ip, sp, #60 ; 0x3c <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
1807c: e1a01003 mov r1, r3 <== NOT EXECUTED 18080: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 18084: ea000008 b 180ac <msdos_dir_read+0x340> <== NOT EXECUTED 18088: e4de0001 ldrb r0, [lr], #1 <== NOT EXECUTED 1808c: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 18090: e0838000 add r8, r3, r0 <== NOT EXECUTED 18094: e5d88001 ldrb r8, [r8, #1] <== NOT EXECUTED 18098: e2088003 and r8, r8, #3 <== NOT EXECUTED 1809c: e3580001 cmp r8, #1 <== NOT EXECUTED 180a0: 02800020 addeq r0, r0, #32 <== NOT EXECUTED 180a4: e4cc0001 strb r0, [ip], #1 <== NOT EXECUTED 180a8: e2411001 sub r1, r1, #1 <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
180ac: e3510000 cmp r1, #0 <== NOT EXECUTED 180b0: cafffff4 bgt 18088 <msdos_dir_read+0x31c> <== NOT EXECUTED 180b4: e59d3004 ldr r3, [sp, #4] <== 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)
180b8: e28d1f55 add r1, sp, #340 ; 0x154 <== NOT EXECUTED 180bc: e1c3cfc3 bic ip, r3, r3, asr #31 <== NOT EXECUTED 180c0: e081000c add r0, r1, ip <== NOT EXECUTED
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
180c4: e5d4100a ldrb r1, [r4, #10] <== NOT EXECUTED 180c8: e3510020 cmp r1, #32 <== 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)
180cc: e2400f46 sub r0, r0, #280 ; 0x118 <== NOT EXECUTED
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
180d0: 1a000058 bne 18238 <msdos_dir_read+0x4cc> <== NOT EXECUTED 180d4: e5d41009 ldrb r1, [r4, #9] <== NOT EXECUTED 180d8: e3510020 cmp r1, #32 <== NOT EXECUTED 180dc: 1a000057 bne 18240 <msdos_dir_read+0x4d4> <== NOT EXECUTED 180e0: e5d41008 ldrb r1, [r4, #8] <== NOT EXECUTED 180e4: e3510020 cmp r1, #32 <== NOT EXECUTED 180e8: 13a01001 movne r1, #1 <== NOT EXECUTED 180ec: 0a00000e beq 1812c <msdos_dir_read+0x3c0> <== NOT EXECUTED 180f0: ea000053 b 18244 <msdos_dir_read+0x4d8> <== 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++));
180f4: e4d4e001 ldrb lr, [r4], #1 <== NOT EXECUTED 180f8: e082800e add r8, r2, lr <== NOT EXECUTED 180fc: e5d88001 ldrb r8, [r8, #1] <== NOT EXECUTED 18100: e2088003 and r8, r8, #3 <== NOT EXECUTED 18104: e3580001 cmp r8, #1 <== NOT EXECUTED 18108: 028ee020 addeq lr, lr, #32 <== NOT EXECUTED 1810c: e5e0e001 strb lr, [r0, #1]! <== NOT EXECUTED 18110: e24cc001 sub ip, ip, #1 <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
18114: e35c0000 cmp ip, #0 <== NOT EXECUTED 18118: cafffff5 bgt 180f4 <msdos_dir_read+0x388> <== 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)
1811c: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED 18120: e1c12fc1 bic r2, r1, r1, asr #31 <== NOT EXECUTED 18124: e08c0002 add r0, ip, r2 <== NOT EXECUTED 18128: e0832002 add r2, r3, r2 <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
1812c: e59f314c ldr r3, [pc, #332] ; 18280 <msdos_dir_read+0x514> <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
18130: e3a01000 mov r1, #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(
18134: e28dcf55 add ip, sp, #340 ; 0x154 <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
18138: e5c01000 strb r1, [r0] <== 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(
1813c: e18c20b3 strh r2, [ip, r3] <== NOT EXECUTED 18140: e3e08000 mvn r8, #0 <== NOT EXECUTED
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
18144: e59dc028 ldr ip, [sp, #40] ; 0x28 <== NOT EXECUTED 18148: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 1814c: e3a02e11 mov r2, #272 ; 0x110 <== NOT EXECUTED 18150: e08c0001 add r0, ip, r1 <== NOT EXECUTED 18154: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 18158: eb000469 bl 19304 <memcpy> <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
1815c: e59dc010 ldr ip, [sp, #16] <== NOT EXECUTED
18160: e99c000c ldmib ip, {r2, r3} <== NOT EXECUTED
18164: e3a00e11 mov r0, #272 ; 0x110 <== NOT EXECUTED
18168: e0922000 adds r2, r2, r0 <== NOT EXECUTED
1816c: e3a01000 mov r1, #0 <== NOT EXECUTED
18170: e0a33001 adc r3, r3, r1 <== NOT EXECUTED
18174: e98c000c stmib ip, {r2, r3} <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
18178: e1a00005 mov r0, r5 <== NOT EXECUTED 1817c: e59d114c ldr r1, [sp, #332] ; 0x14c <== NOT EXECUTED 18180: ebffe0da bl 104f0 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
18184: e2503000 subs r3, r0, #0 <== NOT EXECUTED 18188: 1a000006 bne 181a8 <msdos_dir_read+0x43c> <== NOT EXECUTED
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
cmpltd += (sizeof(struct dirent));
1818c: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 18190: e28cce11 add ip, ip, #272 ; 0x110 <== NOT EXECUTED 18194: e58dc00c str ip, [sp, #12] <== NOT EXECUTED
count -= (sizeof(struct dirent));
18198: e59dc014 ldr ip, [sp, #20] <== NOT EXECUTED 1819c: e24cce11 sub ip, ip, #272 ; 0x110 <== NOT EXECUTED 181a0: e58dc014 str ip, [sp, #20] <== NOT EXECUTED 181a4: ea000005 b 181c0 <msdos_dir_read+0x454> <== NOT EXECUTED
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
181a8: e595009c ldr r0, [r5, #156] ; 0x9c <== NOT EXECUTED 181ac: e1a04005 mov r4, r5 <== NOT EXECUTED 181b0: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 181b4: ebffbff8 bl 819c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
181b8: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 181bc: ea000014 b 18214 <msdos_dir_read+0x4a8> <== NOT EXECUTED
}
}
if (count <= 0)
181c0: e59dc014 ldr ip, [sp, #20] <== NOT EXECUTED 181c4: e35c0000 cmp ip, #0 <== NOT EXECUTED 181c8: 1a000001 bne 181d4 <msdos_dir_read+0x468> <== NOT EXECUTED 181cc: ea000007 b 181f0 <msdos_dir_read+0x484> <== NOT EXECUTED
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK)) ||
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
{
lfn_start = FAT_FILE_SHORT_NAME;
181d0: e3e08000 mvn r8, #0 <== 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)
181d4: e2877020 add r7, r7, #32 <== NOT EXECUTED 181d8: ea000001 b 181e4 <msdos_dir_read+0x478> <== NOT EXECUTED
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
181dc: e3a07000 mov r7, #0 <== 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(&fs_info->fat, fat_fd, F_CLU_NUM,
181e0: e1a05004 mov r5, r4 <== 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)
181e4: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 181e8: e157000c cmp r7, ip <== NOT EXECUTED 181ec: 3affff20 bcc 17e74 <msdos_dir_read+0x108> <== NOT EXECUTED 181f0: e59dc01c ldr ip, [sp, #28] <== NOT EXECUTED 181f4: e1a04005 mov r4, r5 <== NOT EXECUTED 181f8: e086600c add r6, r6, ip <== 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)
181fc: e59dc014 ldr ip, [sp, #20] <== NOT EXECUTED 18200: e35c0000 cmp ip, #0 <== NOT EXECUTED 18204: 1affff09 bne 17e30 <msdos_dir_read+0xc4> <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
18208: e594009c ldr r0, [r4, #156] ; 0x9c <== NOT EXECUTED 1820c: ebffbfe2 bl 819c <rtems_semaphore_release> <== NOT EXECUTED
return cmpltd;
18210: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
}
18214: e1a00003 mov r0, r3 <== NOT EXECUTED
18218: e28ddf55 add sp, sp, #340 ; 0x154 <== NOT EXECUTED
1821c: 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);
18220: e28d003c add r0, sp, #60 ; 0x3c <== NOT EXECUTED 18224: eb000acd bl 1ad60 <strlen> <== NOT EXECUTED 18228: e59f3050 ldr r3, [pc, #80] ; 18280 <msdos_dir_read+0x514> <== NOT EXECUTED 1822c: e28d1f55 add r1, sp, #340 ; 0x154 <== NOT EXECUTED 18230: e18100b3 strh r0, [r1, r3] <== NOT EXECUTED 18234: eaffffc2 b 18144 <msdos_dir_read+0x3d8> <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
}
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
18238: e3a01003 mov r1, #3 <== NOT EXECUTED 1823c: ea000000 b 18244 <msdos_dir_read+0x4d8> <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
(*src_tmp == ' '));
i--,src_tmp--)
18240: e3a01002 mov r1, #2 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
18244: e28d2f55 add r2, sp, #340 ; 0x154 <== NOT EXECUTED 18248: e082c00c add ip, r2, ip <== NOT EXECUTED 1824c: e3a0202e mov r2, #46 ; 0x2e <== NOT EXECUTED 18250: e54c2118 strb r2, [ip, #-280] ; 0x118 <== NOT EXECUTED
len += i + 1; /* extension + dot */
18254: e2812001 add r2, r1, #1 <== NOT EXECUTED 18258: e0833002 add r3, r3, r2 <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
1825c: e59f2018 ldr r2, [pc, #24] ; 1827c <msdos_dir_read+0x510> <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
18260: e280c001 add ip, r0, #1 <== NOT EXECUTED 18264: e58dc020 str ip, [sp, #32] <== NOT EXECUTED
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
18268: e2844008 add r4, r4, #8 <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
1826c: e5922000 ldr r2, [r2] <== NOT EXECUTED 18270: e1a0c001 mov ip, r1 <== NOT EXECUTED 18274: eaffffa6 b 18114 <msdos_dir_read+0x3a8> <== NOT EXECUTED
00018284 <msdos_dir_stat>:
const 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;
18284: e5903014 ldr r3, [r0, #20]
int
msdos_dir_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
18288: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
1828c: e5936008 ldr r6, [r3, #8]
int
msdos_dir_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
18290: e1a04001 mov r4, r1
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,
18294: e3a01000 mov r1, #0
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;
18298: e5905008 ldr r5, [r0, #8]
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
1829c: e1a02001 mov r2, r1 182a0: e596009c ldr r0, [r6, #156] ; 0x9c 182a4: ebffbf75 bl 8080 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
182a8: e2507000 subs r7, r0, #0
182ac: 0a000004 beq 182c4 <msdos_dir_stat+0x40>
rtems_set_errno_and_return_minus_one(EIO);
182b0: eb00016c bl 18868 <__errno> <== NOT EXECUTED
182b4: e3a03005 mov r3, #5 <== NOT EXECUTED
182b8: e5803000 str r3, [r0] <== NOT EXECUTED
182bc: e3e00000 mvn r0, #0 <== NOT EXECUTED
182c0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
static inline dev_t rtems_disk_get_device_identifier(
const rtems_disk_device *dd
)
{
return dd->dev;
182c4: e5963064 ldr r3, [r6, #100] ; 0x64
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
182c8: e893000c ldm r3, {r2, r3}
182cc: e884000c stm r4, {r2, r3}
buf->st_ino = fat_fd->ino;
182d0: e595300c ldr r3, [r5, #12] 182d4: e5843008 str r3, [r4, #8]
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
182d8: e59f3044 ldr r3, [pc, #68] ; 18324 <msdos_dir_stat+0xa0>
buf->st_rdev = 0ll;
182dc: e3a02000 mov r2, #0
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
182e0: e584300c str r3, [r4, #12]
buf->st_rdev = 0ll;
182e4: e3a03000 mov r3, #0 182e8: e5842018 str r2, [r4, #24] 182ec: e584301c str r3, [r4, #28]
buf->st_size = fat_fd->fat_file_size;
182f0: e5953018 ldr r3, [r5, #24] 182f4: e5843020 str r3, [r4, #32]
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
182f8: e1a034a3 lsr r3, r3, #9 182fc: e5843044 str r3, [r4, #68] ; 0x44
buf->st_blksize = fs_info->fat.vol.bps;
18300: e1d630b0 ldrh r3, [r6] 18304: e5843040 str r3, [r4, #64] ; 0x40
buf->st_mtime = fat_fd->mtime;
18308: e5953040 ldr r3, [r5, #64] ; 0x40
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
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;
1830c: e5847024 str r7, [r4, #36] ; 0x24
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;
18310: e5843030 str r3, [r4, #48] ; 0x30
rtems_semaphore_release(fs_info->vol_sema);
18314: e596009c ldr r0, [r6, #156] ; 0x9c 18318: ebffbf9f bl 819c <rtems_semaphore_release>
return RC_OK;
1831c: e1a00007 mov r0, r7
}
18320: e8bd80f0 pop {r4, r5, r6, r7, pc}
00015384 <msdos_eval_token>:
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
15384: e3530001 cmp r3, #1
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
15388: e92d4010 push {r4, lr}
1538c: e1a04000 mov r4, r0
15390: 1a00001c bne 15408 <msdos_eval_token+0x84>
15394: e5d21000 ldrb r1, [r2] 15398: e351002e cmp r1, #46 ; 0x2e
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
1539c: 03a00000 moveq r0, #0 153a0: 0584000c streq r0, [r4, #12]
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
153a4: 1a000017 bne 15408 <msdos_eval_token+0x84>
153a8: e8bd8010 pop {r4, pc}
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;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
153ac: e5942020 ldr r2, [r4, #32]
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
153b0: e594302c ldr r3, [r4, #44] ; 0x2c
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
153b4: e5922010 ldr r2, [r2, #16]
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
153b8: e5933008 ldr r3, [r3, #8]
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
153bc: e3520000 cmp r2, #0
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
153c0: e584000c str r0, [r4, #12]
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
153c4: e5940004 ldr r0, [r4, #4]
{
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;
153c8: 05933094 ldreq r3, [r3, #148] ; 0x94
else
loc->handlers = fs_info->file_handlers;
153cc: 15933098 ldrne r3, [r3, #152] ; 0x98
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
153d0: e2700001 rsbs r0, r0, #1
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
loc->handlers = fs_info->directory_handlers;
else
loc->handlers = fs_info->file_handlers;
153d4: e5843028 str r3, [r4, #40] ; 0x28
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
153d8: 33a00000 movcc r0, #0
153dc: e8bd8010 pop {r4, pc}
rtems_filesystem_eval_path_clear_token(ctx);
msdos_set_handlers(currentloc);
if (rtems_filesystem_eval_path_has_path(ctx)) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else if (rc == MSDOS_NAME_NOT_FOUND_ERR) {
153e0: e59f303c ldr r3, [pc, #60] ; 15424 <msdos_eval_token+0xa0> 153e4: e1500003 cmp r0, r3
153e8: 0a000004 beq 15400 <msdos_eval_token+0x7c>
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
} else {
rtems_filesystem_eval_path_error(ctx, 0);
153ec: e1a00004 mov r0, r4 <== NOT EXECUTED 153f0: e3a01000 mov r1, #0 <== NOT EXECUTED 153f4: ebffbf72 bl 51c4 <rtems_filesystem_eval_path_error> <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
153f8: e3a00001 mov r0, #1 <== NOT EXECUTED
153fc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
msdos_set_handlers(currentloc);
if (rtems_filesystem_eval_path_has_path(ctx)) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else if (rc == MSDOS_NAME_NOT_FOUND_ERR) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
15400: e3a00002 mov r0, #2
rtems_filesystem_eval_path_error(ctx, 0);
}
}
return status;
}
15404: e8bd8010 pop {r4, pc}
rtems_filesystem_eval_path_clear_token(ctx);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
} else {
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc(ctx);
int rc = msdos_find_name(currentloc, token, tokenlen);
15408: e1a01002 mov r1, r2 1540c: e2840018 add r0, r4, #24 15410: e1a02003 mov r2, r3 15414: eb0004d5 bl 16770 <msdos_find_name>
if (rc == RC_OK) {
15418: e3500000 cmp r0, #0
1541c: 0affffe2 beq 153ac <msdos_eval_token+0x28>
15420: eaffffee b 153e0 <msdos_eval_token+0x5c>
00018388 <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;
18388: e5903024 ldr r3, [r0, #36] ; 0x24
* RC_OK, if file closed successfully, or -1 if error occured (errno set
* appropriately)
*/
int
msdos_file_close(rtems_libio_t *iop)
{
1838c: e92d4030 push {r4, r5, lr}
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
18390: e5934008 ldr r4, [r3, #8]
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
18394: e3a01000 mov r1, #0
* RC_OK, if file closed successfully, or -1 if error occured (errno set
* appropriately)
*/
int
msdos_file_close(rtems_libio_t *iop)
{
18398: e1a05000 mov r5, r0
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
1839c: e1a02001 mov r2, r1 183a0: e594009c ldr r0, [r4, #156] ; 0x9c 183a4: ebffbf35 bl 8080 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
183a8: e3500000 cmp r0, #0
183ac: 0a000004 beq 183c4 <msdos_file_close+0x3c>
rtems_set_errno_and_return_minus_one(EIO);
183b0: eb00012c bl 18868 <__errno> <== NOT EXECUTED 183b4: e3a03005 mov r3, #5 <== NOT EXECUTED 183b8: e5803000 str r3, [r0] <== NOT EXECUTED 183bc: e3e05000 mvn r5, #0 <== NOT EXECUTED 183c0: ea000004 b 183d8 <msdos_file_close+0x50> <== NOT EXECUTED
rc = msdos_file_update(iop);
183c4: e1a00005 mov r0, r5 183c8: ebffffd6 bl 18328 <msdos_file_update> 183cc: e1a05000 mov r5, r0
rtems_semaphore_release(fs_info->vol_sema);
183d0: e594009c ldr r0, [r4, #156] ; 0x9c 183d4: ebffbf70 bl 819c <rtems_semaphore_release>
return rc;
}
183d8: e1a00005 mov r0, r5
183dc: e8bd8030 pop {r4, r5, pc}
000185dc <msdos_file_ftruncate>:
int
msdos_file_ftruncate(rtems_libio_t *iop, off_t length)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
185dc: e5903024 ldr r3, [r0, #36] ; 0x24
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately).
*/
int
msdos_file_ftruncate(rtems_libio_t *iop, off_t length)
{
185e0: e92d43f3 push {r0, r1, r4, r5, r6, r7, r8, r9, lr}
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
185e4: e5935008 ldr r5, [r3, #8]
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately).
*/
int
msdos_file_ftruncate(rtems_libio_t *iop, off_t length)
{
185e8: e1a08001 mov r8, r1
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->pathinfo.node_access;
uint32_t old_length;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
185ec: e3a01000 mov r1, #0
msdos_file_ftruncate(rtems_libio_t *iop, off_t length)
{
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->pathinfo.node_access;
185f0: e5904018 ldr r4, [r0, #24]
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately).
*/
int
msdos_file_ftruncate(rtems_libio_t *iop, off_t length)
{
185f4: e1a09002 mov r9, r2
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->pathinfo.node_access;
uint32_t old_length;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
185f8: e595009c ldr r0, [r5, #156] ; 0x9c 185fc: e1a02001 mov r2, r1 18600: ebffbe9e bl 8080 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
18604: e3500000 cmp r0, #0
18608: 0a000004 beq 18620 <msdos_file_ftruncate+0x44>
rtems_set_errno_and_return_minus_one(EIO);
1860c: eb000095 bl 18868 <__errno> <== NOT EXECUTED 18610: e3a03005 mov r3, #5 <== NOT EXECUTED 18614: e5803000 str r3, [r0] <== NOT EXECUTED 18618: e3e07000 mvn r7, #0 <== NOT EXECUTED 1861c: ea000027 b 186c0 <msdos_file_ftruncate+0xe4> <== NOT EXECUTED
old_length = fat_fd->fat_file_size;
18620: e5946018 ldr r6, [r4, #24]
if (length < old_length) {
18624: e3a03000 mov r3, #0 18628: e1a02006 mov r2, r6 1862c: e1580002 cmp r8, r2 18630: e0d91003 sbcs r1, r9, r3
18634: aa000006 bge 18654 <msdos_file_ftruncate+0x78>
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
18638: e1a00005 mov r0, r5 1863c: e1a01004 mov r1, r4 18640: e1a02008 mov r2, r8 18644: ebffdf6d bl 10400 <fat_file_truncate>
errno = ENOSPC;
rc = -1;
}
}
if (rc == RC_OK) {
18648: e2507000 subs r7, r0, #0
1864c: 0a000017 beq 186b0 <msdos_file_ftruncate+0xd4>
18650: ea000018 b 186b8 <msdos_file_ftruncate+0xdc> <== NOT EXECUTED
if (length < old_length) {
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
} else {
uint32_t new_length;
rc = fat_file_extend(&fs_info->fat,
18654: e28d3004 add r3, sp, #4 18658: e58d3000 str r3, [sp] 1865c: e1a00005 mov r0, r5 18660: e1a01004 mov r1, r4 18664: e3a02001 mov r2, #1 18668: e1a03008 mov r3, r8 1866c: ebffdff4 bl 10644 <fat_file_extend>
fat_fd,
true,
length,
&new_length);
if (rc == RC_OK && length != new_length) {
18670: e2507000 subs r7, r0, #0
18674: 1a00000f bne 186b8 <msdos_file_ftruncate+0xdc>
18678: e59d2004 ldr r2, [sp, #4] 1867c: e3a03000 mov r3, #0 18680: e1590003 cmp r9, r3 18684: 01580002 cmpeq r8, r2
18688: 0a000008 beq 186b0 <msdos_file_ftruncate+0xd4>
fat_file_truncate(&fs_info->fat, fat_fd, old_length);
1868c: e1a01004 mov r1, r4 <== NOT EXECUTED 18690: e1a02006 mov r2, r6 <== NOT EXECUTED 18694: e1a00005 mov r0, r5 <== NOT EXECUTED 18698: ebffdf58 bl 10400 <fat_file_truncate> <== NOT EXECUTED
errno = ENOSPC;
1869c: eb000071 bl 18868 <__errno> <== NOT EXECUTED 186a0: e3a0301c mov r3, #28 <== NOT EXECUTED 186a4: e5803000 str r3, [r0] <== NOT EXECUTED
rc = -1;
186a8: e3e07000 mvn r7, #0 <== NOT EXECUTED 186ac: ea000001 b 186b8 <msdos_file_ftruncate+0xdc> <== NOT EXECUTED
}
}
if (rc == RC_OK) {
fat_fd->fat_file_size = length;
186b0: e5848018 str r8, [r4, #24] 186b4: e3a07000 mov r7, #0
}
rtems_semaphore_release(fs_info->vol_sema);
186b8: e595009c ldr r0, [r5, #156] ; 0x9c 186bc: ebffbeb6 bl 819c <rtems_semaphore_release>
return rc;
}
186c0: e1a00007 mov r0, r7
186c4: e8bd83fc pop {r2, r3, r4, r5, r6, r7, r8, r9, pc}
000183e0 <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;
183e0: e5903024 ldr r3, [r0, #36] ; 0x24
* 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)
{
183e4: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr}
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
183e8: e5935008 ldr r5, [r3, #8]
* 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)
{
183ec: e1a08001 mov r8, r1
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->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
183f0: e3a01000 mov r1, #0
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->pathinfo.node_access;
183f4: e5907018 ldr r7, [r0, #24]
* 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)
{
183f8: e1a04000 mov r4, r0 183fc: e1a06002 mov r6, r2
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->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
18400: e595009c ldr r0, [r5, #156] ; 0x9c 18404: e1a02001 mov r2, r1 18408: ebffbf1c bl 8080 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
1840c: e3500000 cmp r0, #0
18410: 0a000004 beq 18428 <msdos_file_read+0x48>
rtems_set_errno_and_return_minus_one(EIO);
18414: eb000113 bl 18868 <__errno> <== NOT EXECUTED 18418: e3a03005 mov r3, #5 <== NOT EXECUTED 1841c: e5803000 str r3, [r0] <== NOT EXECUTED 18420: e3e06000 mvn r6, #0 <== NOT EXECUTED 18424: ea00000d b 18460 <msdos_file_read+0x80> <== NOT EXECUTED
ret = fat_file_read(&fs_info->fat, fat_fd, iop->offset, count,
18428: e1a03006 mov r3, r6 1842c: e1a00005 mov r0, r5 18430: e1a01007 mov r1, r7 18434: e5942004 ldr r2, [r4, #4] 18438: e58d8000 str r8, [sp] 1843c: ebffdf86 bl 1025c <fat_file_read>
buffer);
if (ret > 0)
18440: e2506000 subs r6, r0, #0
18444: da000003 ble 18458 <msdos_file_read+0x78>
iop->offset += ret;
18448: e994000c ldmib r4, {r2, r3}
1844c: e0922006 adds r2, r2, r6
18450: e0a33fc6 adc r3, r3, r6, asr #31
18454: e984000c stmib r4, {r2, r3}
rtems_semaphore_release(fs_info->vol_sema);
18458: e595009c ldr r0, [r5, #156] ; 0x9c 1845c: ebffbf4e bl 819c <rtems_semaphore_release>
return ret;
}
18460: e1a00006 mov r0, r6
18464: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc}
00018528 <msdos_file_stat>:
const 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;
18528: e5903014 ldr r3, [r0, #20]
int
msdos_file_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
1852c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
18530: e5936008 ldr r6, [r3, #8]
int
msdos_file_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
18534: e1a04001 mov r4, r1
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;
uint32_t cl_mask = fs_info->fat.vol.bpc - 1;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
18538: e3a01000 mov r1, #0
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;
1853c: e5905008 ldr r5, [r0, #8]
uint32_t cl_mask = fs_info->fat.vol.bpc - 1;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
18540: e1a02001 mov r2, r1 18544: e596009c ldr r0, [r6, #156] ; 0x9c
)
{
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;
uint32_t cl_mask = fs_info->fat.vol.bpc - 1;
18548: e1d670b6 ldrh r7, [r6, #6]
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
1854c: ebffbecb bl 8080 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
18550: e2508000 subs r8, r0, #0
18554: 0a000004 beq 1856c <msdos_file_stat+0x44>
rtems_set_errno_and_return_minus_one(EIO);
18558: eb0000c2 bl 18868 <__errno> <== NOT EXECUTED
1855c: e3a03005 mov r3, #5 <== NOT EXECUTED
18560: e5803000 str r3, [r0] <== NOT EXECUTED
18564: e3e00000 mvn r0, #0 <== NOT EXECUTED
18568: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
1856c: e5963064 ldr r3, [r6, #100] ; 0x64
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
18570: e893000c ldm r3, {r2, r3}
18574: e884000c stm r4, {r2, r3}
buf->st_ino = fat_fd->ino;
18578: e595300c ldr r3, [r5, #12] 1857c: e5843008 str r3, [r4, #8]
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
18580: e59f3050 ldr r3, [pc, #80] ; 185d8 <msdos_file_stat+0xb0>
buf->st_rdev = 0ll;
18584: e3a02000 mov r2, #0
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
18588: e584300c str r3, [r4, #12]
buf->st_rdev = 0ll;
1858c: e3a03000 mov r3, #0 18590: e5842018 str r2, [r4, #24] 18594: e584301c str r3, [r4, #28]
buf->st_size = fat_fd->fat_file_size;
18598: e5953018 ldr r3, [r5, #24]
)
{
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;
uint32_t cl_mask = fs_info->fat.vol.bpc - 1;
1859c: e2477001 sub r7, r7, #1
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
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;
185a0: e5843020 str r3, [r4, #32]
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
185a4: e0873003 add r3, r7, r3 185a8: e1c37007 bic r7, r3, r7
>> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bpc;
185ac: e1d630b6 ldrh r3, [r6, #6] 185b0: e5843040 str r3, [r4, #64] ; 0x40
buf->st_mtime = fat_fd->mtime;
185b4: e5953040 ldr r3, [r5, #64] ; 0x40
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 + cl_mask) & ~cl_mask)
>> FAT_SECTOR512_BITS;
185b8: e1a074a7 lsr r7, r7, #9
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
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;
185bc: e5848024 str r8, [r4, #36] ; 0x24
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
185c0: e5847044 str r7, [r4, #68] ; 0x44
>> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bpc;
buf->st_mtime = fat_fd->mtime;
185c4: e5843030 str r3, [r4, #48] ; 0x30
rtems_semaphore_release(fs_info->vol_sema);
185c8: e596009c ldr r0, [r6, #156] ; 0x9c 185cc: ebffbef2 bl 819c <rtems_semaphore_release>
return RC_OK;
185d0: e1a00008 mov r0, r8
}
185d4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
000186c8 <msdos_file_sync>:
int
msdos_file_sync(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;
186c8: e5903024 ldr r3, [r0, #36] ; 0x24
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
186cc: e92d4030 push {r4, r5, lr}
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
186d0: e5934008 ldr r4, [r3, #8]
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
186d4: e3a01000 mov r1, #0
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
186d8: e1a05000 mov r5, r0
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
186dc: e1a02001 mov r2, r1 186e0: e594009c ldr r0, [r4, #156] ; 0x9c 186e4: ebffbe65 bl 8080 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
186e8: e3500000 cmp r0, #0
186ec: 0a000004 beq 18704 <msdos_file_sync+0x3c>
rtems_set_errno_and_return_minus_one(EIO);
186f0: eb00005c bl 18868 <__errno> <== NOT EXECUTED 186f4: e3a03005 mov r3, #5 <== NOT EXECUTED 186f8: e5803000 str r3, [r0] <== NOT EXECUTED 186fc: e3e05000 mvn r5, #0 <== NOT EXECUTED 18700: ea000007 b 18724 <msdos_file_sync+0x5c> <== NOT EXECUTED
rc = msdos_file_update(iop);
18704: e1a00005 mov r0, r5 18708: ebffff06 bl 18328 <msdos_file_update>
if (rc != RC_OK)
1870c: e2505000 subs r5, r0, #0
18710: 1a000001 bne 1871c <msdos_file_sync+0x54>
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = fat_sync(&fs_info->fat);
18714: e1a00004 mov r0, r4 18718: ebffe42a bl 117c8 <fat_sync>
rtems_semaphore_release(fs_info->vol_sema);
1871c: e594009c ldr r0, [r4, #156] ; 0x9c 18720: ebffbe9d bl 819c <rtems_semaphore_release>
return RC_OK;
}
18724: e1a00005 mov r0, r5
18728: e8bd8030 pop {r4, r5, pc}
00018328 <msdos_file_update>:
#include "msdos.h"
static int
msdos_file_update(rtems_libio_t *iop)
{
18328: e92d4030 push {r4, r5, lr}
int rc = RC_OK;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
1832c: e5904018 ldr r4, [r0, #24]
/*
* 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))
18330: e5d43030 ldrb r3, [r4, #48] ; 0x30 18334: e3130001 tst r3, #1
#include "msdos.h"
static int
msdos_file_update(rtems_libio_t *iop)
{
18338: e1a05000 mov r5, r0
/*
* 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))
1833c: 1a000009 bne 18368 <msdos_file_update+0x40>
18340: ea00000a b 18370 <msdos_file_update+0x48>
if (rc != RC_OK)
{
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
18344: e5950024 ldr r0, [r5, #36] ; 0x24 18348: e1a01004 mov r1, r4 1834c: ebfff52a bl 157fc <msdos_set_file_size>
if (rc != RC_OK)
18350: e3500000 cmp r0, #0
18354: 18bd8030 popne {r4, r5, pc}
{
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
18358: e5950024 ldr r0, [r5, #36] ; 0x24 1835c: e1a01004 mov r1, r4
return rc;
}
}
return rc;
}
18360: e8bd4030 pop {r4, r5, lr}
if (rc != RC_OK)
{
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
18364: eafff4d1 b 156b0 <msdos_set_dir_wrt_time_and_date>
#include "msdos.h"
static int
msdos_file_update(rtems_libio_t *iop)
{
int rc = RC_OK;
18368: e3a00000 mov r0, #0 <== NOT EXECUTED
return rc;
}
}
return rc;
}
1836c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
* if fat-file descriptor is not marked as "removed", synchronize
* size, first cluster number, write time and date fields of the file
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
18370: e5900024 ldr r0, [r0, #36] ; 0x24 18374: e1a01004 mov r1, r4 18378: ebfff4f9 bl 15764 <msdos_set_first_cluster_num>
if (rc != RC_OK)
1837c: e3500000 cmp r0, #0
18380: 18bd8030 popne {r4, r5, pc}
18384: eaffffee b 18344 <msdos_file_update+0x1c>
00018468 <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;
18468: e5903024 ldr r3, [r0, #36] ; 0x24
* 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)
{
1846c: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr}
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
18470: e5936008 ldr r6, [r3, #8]
* 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)
{
18474: e1a08001 mov r8, r1
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->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
18478: e3a01000 mov r1, #0
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->pathinfo.node_access;
1847c: e5905018 ldr r5, [r0, #24]
* 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)
{
18480: e1a04000 mov r4, r0 18484: e1a07002 mov r7, r2
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->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
18488: e596009c ldr r0, [r6, #156] ; 0x9c 1848c: e1a02001 mov r2, r1 18490: ebffbefa bl 8080 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
18494: e3500000 cmp r0, #0
18498: 0a000003 beq 184ac <msdos_file_write+0x44>
rtems_set_errno_and_return_minus_one(EIO);
1849c: eb0000f1 bl 18868 <__errno> <== NOT EXECUTED 184a0: e3a03005 mov r3, #5 <== NOT EXECUTED 184a4: e5803000 str r3, [r0] <== NOT EXECUTED 184a8: ea00000e b 184e8 <msdos_file_write+0x80> <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_APPEND) != 0)
184ac: e594300c ldr r3, [r4, #12] 184b0: e3130c02 tst r3, #512 ; 0x200
iop->offset = fat_fd->fat_file_size;
184b4: 15953018 ldrne r3, [r5, #24] 184b8: 15843004 strne r3, [r4, #4] 184bc: 15840008 strne r0, [r4, #8]
ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
184c0: e1a03007 mov r3, r7 184c4: e1a00006 mov r0, r6 184c8: e1a01005 mov r1, r5 184cc: e5942004 ldr r2, [r4, #4] 184d0: e58d8000 str r8, [sp] 184d4: ebffe0e4 bl 1086c <fat_file_write>
buffer);
if (ret < 0)
184d8: e2507000 subs r7, r0, #0
184dc: aa000003 bge 184f0 <msdos_file_write+0x88>
{
rtems_semaphore_release(fs_info->vol_sema);
184e0: e596009c ldr r0, [r6, #156] ; 0x9c <== NOT EXECUTED 184e4: ebffbf2c bl 819c <rtems_semaphore_release> <== NOT EXECUTED
return -1;
184e8: e3e07000 mvn r7, #0 <== NOT EXECUTED 184ec: ea00000b b 18520 <msdos_file_write+0xb8> <== NOT EXECUTED
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
184f0: e994000c ldmib r4, {r2, r3}
if (iop->offset > fat_fd->fat_file_size)
184f4: e595c018 ldr ip, [r5, #24]
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
184f8: e0922007 adds r2, r2, r7 184fc: e0a33fc7 adc r3, r3, r7, asr #31
if (iop->offset > fat_fd->fat_file_size)
18500: e1a0000c mov r0, ip 18504: e3a01000 mov r1, #0 18508: e1500002 cmp r0, r2 1850c: e0d1c003 sbcs ip, r1, r3
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
18510: e984000c stmib r4, {r2, r3}
if (iop->offset > fat_fd->fat_file_size)
fat_fd->fat_file_size = iop->offset;
rtems_semaphore_release(fs_info->vol_sema);
18514: e596009c ldr r0, [r6, #156] ; 0x9c
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
if (iop->offset > fat_fd->fat_file_size)
fat_fd->fat_file_size = iop->offset;
18518: b5852018 strlt r2, [r5, #24]
rtems_semaphore_release(fs_info->vol_sema);
1851c: ebffbf1e bl 819c <rtems_semaphore_release>
return ret;
}
18520: e1a00007 mov r0, r7
18524: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc}
00017c08 <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)
{
17c08: e92d4030 push {r4, r5, lr}
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
17c0c: e3a03000 mov r3, #0
dn[i] = ' ';
17c10: e3a0c020 mov ip, #32 17c14: e7c2c003 strb ip, [r2, r3]
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
17c18: e2833001 add r3, r3, #1 17c1c: e353000b cmp r3, #11
17c20: 1afffffb bne 17c14 <msdos_filename_unix2dos+0xc>
/*
* The filenames "." and ".." are handled specially, since they
* don't follow dos filename rules.
*/
if (un[0] == '.' && unlen == 1) {
17c24: e5d03000 ldrb r3, [r0] 17c28: e353002e cmp r3, #46 ; 0x2e 17c2c: 13a0c000 movne ip, #0 17c30: 03a0c001 moveq ip, #1 17c34: e3510001 cmp r1, #1 17c38: 0353002e cmpeq r3, #46 ; 0x2e
dn[0] = '.';
17c3c: 03a0302e moveq r3, #46 ; 0x2e 17c40: 05c23000 strbeq r3, [r2]
/*
* The filenames "." and ".." are handled specially, since they
* don't follow dos filename rules.
*/
if (un[0] == '.' && unlen == 1) {
17c44: 0a000045 beq 17d60 <msdos_filename_unix2dos+0x158>
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
17c48: e35c0000 cmp ip, #0
17c4c: 0a000008 beq 17c74 <msdos_filename_unix2dos+0x6c>
17c50: e5d03001 ldrb r3, [r0, #1] <== NOT EXECUTED 17c54: e3510002 cmp r1, #2 <== NOT EXECUTED 17c58: 0353002e cmpeq r3, #46 ; 0x2e <== NOT EXECUTED
dn[0] = '.';
17c5c: 03a0302e moveq r3, #46 ; 0x2e <== NOT EXECUTED 17c60: 05c23000 strbeq r3, [r2] <== NOT EXECUTED
dn[1] = '.';
17c64: 05c23001 strbeq r3, [r2, #1] <== NOT EXECUTED
*/
if (un[0] == '.' && unlen == 1) {
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
17c68: 1a000001 bne 17c74 <msdos_filename_unix2dos+0x6c> <== NOT EXECUTED 17c6c: ea00003b b 17d60 <msdos_filename_unix2dos+0x158> <== NOT EXECUTED
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
un++;
unlen--;
17c70: e2411001 sub r1, r1, #1 <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
17c74: e3510000 cmp r1, #0
un++; unlen--;
17c78: e1a0c000 mov ip, r0
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
17c7c: 1a000002 bne 17c8c <msdos_filename_unix2dos+0x84>
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
17c80: e3a00000 mov r0, #0
* 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)
17c84: e59f50dc ldr r5, [pc, #220] ; 17d68 <msdos_filename_unix2dos+0x160> 17c88: ea00000a b 17cb8 <msdos_filename_unix2dos+0xb0>
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
17c8c: e5dc3000 ldrb r3, [ip] 17c90: e353002e cmp r3, #46 ; 0x2e 17c94: e2800001 add r0, r0, #1
17c98: 0afffff4 beq 17c70 <msdos_filename_unix2dos+0x68>
17c9c: eafffff7 b 17c80 <msdos_filename_unix2dos+0x78>
* 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)
17ca0: e7d54004 ldrb r4, [r5, r4] 17ca4: e3540000 cmp r4, #0
17ca8: 0a000013 beq 17cfc <msdos_filename_unix2dos+0xf4>
break;
dn[i] = msdos_map[c];
17cac: e7c24000 strb r4, [r2, r0]
un++; unlen--;
17cb0: e2411001 sub r1, r1, #1
* 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++) {
17cb4: e2800001 add r0, r0, #1 17cb8: e2914000 adds r4, r1, #0 17cbc: 13a04001 movne r4, #1 17cc0: e3500007 cmp r0, #7 17cc4: c3a04000 movgt r4, #0 17cc8: e3540000 cmp r4, #0 17ccc: e1a0300c mov r3, ip
17cd0: 0a000009 beq 17cfc <msdos_filename_unix2dos+0xf4>
17cd4: e4dc4001 ldrb r4, [ip], #1 17cd8: e3540000 cmp r4, #0
17cdc: 0a000006 beq 17cfc <msdos_filename_unix2dos+0xf4>
17ce0: e354002e cmp r4, #46 ; 0x2e
17ce4: 1affffed bne 17ca0 <msdos_filename_unix2dos+0x98>
17ce8: ea000003 b 17cfc <msdos_filename_unix2dos+0xf4>
*/
while (unlen && (c = *un)) {
un++;
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
17cec: e350002e cmp r0, #46 ; 0x2e
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
un++;
17cf0: e1a0c003 mov ip, r3
unlen--;
17cf4: e2411001 sub r1, r1, #1
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
17cf8: 0a000005 beq 17d14 <msdos_filename_unix2dos+0x10c>
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
17cfc: e3510000 cmp r1, #0
un++; unlen--; /* Make sure we've skipped over the dot before stopping. */ if (c == '.')
17d00: e1a0c003 mov ip, r3
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
17d04: 0a000002 beq 17d14 <msdos_filename_unix2dos+0x10c>
17d08: e4d30001 ldrb r0, [r3], #1 17d0c: e3500000 cmp r0, #0
17d10: 1afffff5 bne 17cec <msdos_filename_unix2dos+0xe4>
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
17d14: e3a00000 mov r0, #0 17d18: e3a03008 mov r3, #8
* 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)
17d1c: e59f5044 ldr r5, [pc, #68] ; 17d68 <msdos_filename_unix2dos+0x160> 17d20: ea000005 b 17d3c <msdos_filename_unix2dos+0x134> 17d24: e7d54004 ldrb r4, [r5, r4] 17d28: e3540000 cmp r4, #0 17d2c: e2800001 add r0, r0, #1
17d30: 0a00000a beq 17d60 <msdos_filename_unix2dos+0x158>
break;
dn[i] = msdos_map[c];
17d34: e7c24003 strb r4, [r2, r3]
/*
* 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++) {
17d38: e2833001 add r3, r3, #1 17d3c: e0514000 subs r4, r1, r0 17d40: 13a04001 movne r4, #1 17d44: e353000a cmp r3, #10 17d48: c3a04000 movgt r4, #0 17d4c: e3540000 cmp r4, #0
17d50: 0a000002 beq 17d60 <msdos_filename_unix2dos+0x158>
17d54: e7dc4000 ldrb r4, [ip, r0] 17d58: e3540000 cmp r4, #0
17d5c: 1afffff0 bne 17d24 <msdos_filename_unix2dos+0x11c>
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
17d60: e3a00000 mov r0, #0
17d64: e8bd8030 pop {r4, r5, pc}
00016770 <msdos_find_name>:
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
16770: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
16774: e24dd040 sub sp, sp, #64 ; 0x40
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
16778: e5903014 ldr r3, [r0, #20]
fat_file_fd_t *fat_fd = NULL;
1677c: e3a05000 mov r5, #0
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);
16780: e28d400c add r4, sp, #12
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
16784: e1a07001 mov r7, r1 16788: e1a09002 mov r9, r2
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);
1678c: e1a01005 mov r1, r5
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
16790: e1a08000 mov r8, r0
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);
16794: e3a02020 mov r2, #32 16798: e1a00004 mov r0, r4
const char *name,
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
1679c: e5936008 ldr r6, [r3, #8]
fat_file_fd_t *fat_fd = NULL;
167a0: e58d503c str r5, [sp, #60] ; 0x3c
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);
167a4: eb000b0c bl 193dc <memset>
name_type = msdos_long_to_short (name,
167a8: e1a01009 mov r1, r9 167ac: e1a02004 mov r2, r4 167b0: e3a0300b mov r3, #11 167b4: e1a00007 mov r0, r7 167b8: ebfffb3e bl 154b8 <msdos_long_to_short>
/*
* 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,
167bc: e28da02c add sl, sp, #44 ; 0x2c 167c0: e58d0000 str r0, [sp] 167c4: e1a01005 mov r1, r5 167c8: e1a00008 mov r0, r8 167cc: e1a02007 mov r2, r7 167d0: e1a03009 mov r3, r9 167d4: e58da004 str sl, [sp, #4] 167d8: e58d4008 str r4, [sp, #8] 167dc: ebffffae bl 1669c <msdos_get_name_node>
&dir_pos, node_entry);
if (rc != RC_OK)
167e0: e2505000 subs r5, r0, #0
167e4: 1a000045 bne 16900 <msdos_find_name+0x190>
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
167e8: e5dd3017 ldrb r3, [sp, #23] 167ec: e3130008 tst r3, #8
167f0: 1a000041 bne 168fc <msdos_find_name+0x18c>
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
167f4: e203303f and r3, r3, #63 ; 0x3f
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
&dir_pos, node_entry);
if (rc != RC_OK)
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
167f8: e353000f cmp r3, #15
167fc: 0a00003e beq 168fc <msdos_find_name+0x18c>
((*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(&fs_info->fat, &dir_pos, &fat_fd);
16800: e1a00006 mov r0, r6 16804: e1a0100a mov r1, sl 16808: e28d203c add r2, sp, #60 ; 0x3c 1680c: ebffe63d bl 10108 <fat_file_open>
if (rc != RC_OK)
16810: e2505000 subs r5, r0, #0
16814: 1a000039 bne 16900 <msdos_find_name+0x190>
return rc;
fat_fd->dir_pos = dir_pos;
16818: e59d703c ldr r7, [sp, #60] ; 0x3c
1681c: e89a000f ldm sl, {r0, r1, r2, r3}
16820: e287c020 add ip, r7, #32
16824: e88c000f stm ip, {r0, r1, r2, r3}
* 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)
16828: e5973008 ldr r3, [r7, #8] 1682c: e3530001 cmp r3, #1
16830: 1a000026 bne 168d0 <msdos_find_name+0x160>
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
16834: e1d421b4 ldrh r2, [r4, #20] 16838: e1d431ba ldrh r3, [r4, #26] 1683c: e1833802 orr r3, r3, r2, lsl #16 16840: e587301c str r3, [r7, #28]
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));
16844: e1d411b6 ldrh r1, [r4, #22] 16848: e1d401b8 ldrh r0, [r4, #24] 1684c: eb0004a9 bl 17af8 <msdos_date_dos2unix>
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
16850: e5dd3017 ldrb r3, [sp, #23] 16854: e3130010 tst r3, #16
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
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));
16858: e5870040 str r0, [r7, #64] ; 0x40 1685c: e59d103c ldr r1, [sp, #60] ; 0x3c
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
16860: 0a000007 beq 16884 <msdos_find_name+0x114>
{
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
16864: e3a03602 mov r3, #2097152 ; 0x200000
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;
16868: e5815010 str r5, [r1, #16]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
1686c: e5813014 str r3, [r1, #20]
rc = fat_file_size(&fs_info->fat, fat_fd);
16870: e1a00006 mov r0, r6 16874: ebffe897 bl 10ad8 <fat_file_size>
if (rc != RC_OK)
16878: e2505000 subs r5, r0, #0
1687c: 0a000006 beq 1689c <msdos_find_name+0x12c>
16880: ea000019 b 168ec <msdos_find_name+0x17c> <== NOT EXECUTED
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
16884: e594301c ldr r3, [r4, #28] 16888: e5813018 str r3, [r1, #24]
fat_fd->fat_file_type = FAT_FILE;
1688c: e3a03004 mov r3, #4 16890: e5813010 str r3, [r1, #16]
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
16894: e3e03000 mvn r3, #0 16898: e5813014 str r3, [r1, #20]
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
1689c: e59d303c ldr r3, [sp, #60] ; 0x3c 168a0: e3a02000 mov r2, #0
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
168a4: e5931018 ldr r1, [r3, #24]
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;
168a8: e5832034 str r2, [r3, #52] ; 0x34
fat_fd->map.disk_cln = fat_fd->cln;
168ac: e593201c ldr r2, [r3, #28]
if ((fat_fd->fat_file_size != 0) &&
168b0: e3510000 cmp r1, #0
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
168b4: e5832038 str r2, [r3, #56] ; 0x38
if ((fat_fd->fat_file_size != 0) &&
168b8: 0a000002 beq 168c8 <msdos_find_name+0x158>
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
168bc: e1d600b6 ldrh r0, [r6, #6]
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
168c0: e1510000 cmp r1, r0
168c4: 9a000000 bls 168cc <msdos_find_name+0x15c>
{
fat_fd->map.last_cln = fat_fd->cln;
}
else
{
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
168c8: e3e02000 mvn r2, #0 168cc: e583203c str r2, [r3, #60] ; 0x3c
}
}
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(&fs_info->fat, parent_loc->node_access);
168d0: e1a00006 mov r0, r6 168d4: e5981008 ldr r1, [r8, #8] 168d8: ebffe704 bl 104f0 <fat_file_close>
if (rc != RC_OK)
168dc: e2505000 subs r5, r0, #0
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
168e0: 059d303c ldreq r3, [sp, #60] ; 0x3c 168e4: 05883008 streq r3, [r8, #8]
}
}
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(&fs_info->fat, parent_loc->node_access);
if (rc != RC_OK)
168e8: 0a000004 beq 16900 <msdos_find_name+0x190>
{
fat_file_close(&fs_info->fat, fat_fd);
168ec: e1a00006 mov r0, r6 <== NOT EXECUTED 168f0: e59d103c ldr r1, [sp, #60] ; 0x3c <== NOT EXECUTED 168f4: ebffe6fd bl 104f0 <fat_file_close> <== NOT EXECUTED
return rc;
168f8: ea000000 b 16900 <msdos_find_name+0x190> <== NOT EXECUTED
if (rc != RC_OK)
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
168fc: e59f5008 ldr r5, [pc, #8] ; 1690c <msdos_find_name+0x19c> <== NOT EXECUTED
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
return rc;
}
16900: e1a00005 mov r0, r5
16904: e28dd040 add sp, sp, #64 ; 0x40
16908: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
00015a88 <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
)
{
15a88: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
15a8c: e24dd04c sub sp, sp, #76 ; 0x4c
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
15a90: e59dc070 ldr ip, [sp, #112] ; 0x70
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
15a94: e20220ff and r2, r2, #255 ; 0xff
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
15a98: e35c0000 cmp ip, #0
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
15a9c: e1a06001 mov r6, r1 15aa0: e58d3034 str r3, [sp, #52] ; 0x34 15aa4: e59da078 ldr sl, [sp, #120] ; 0x78 15aa8: e58d2018 str r2, [sp, #24]
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
15aac: e5904008 ldr r4, [r0, #8]
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
15ab0: d59f086c ldrle r0, [pc, #2156] ; 16324 <msdos_find_name_in_fat_file+0x89c> 15ab4: d59f186c ldrle r1, [pc, #2156] ; 16328 <msdos_find_name_in_fat_file+0x8a0> 15ab8: d59f286c ldrle r2, [pc, #2156] ; 1632c <msdos_find_name_in_fat_file+0x8a4> 15abc: d59f386c ldrle r3, [pc, #2156] ; 16330 <msdos_find_name_in_fat_file+0x8a8>
15ac0: da000031 ble 15b8c <msdos_find_name_in_fat_file+0x104>
* 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))
15ac4: e59dc018 ldr ip, [sp, #24]
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
15ac8: e3a08000 mov r8, #0
dir_pos->sname.ofs = 0; dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
15acc: e3e03000 mvn r3, #0 15ad0: e15c0008 cmp ip, r8
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
15ad4: e58a8000 str r8, [sl]
dir_pos->sname.ofs = 0;
15ad8: e58a8004 str r8, [sl, #4]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
15adc: e58a3008 str r3, [sl, #8]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
15ae0: e58a300c str r3, [sl, #12]
assert(name_len > 0);
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
15ae4: e58d3044 str r3, [sp, #68] ; 0x44 15ae8: e58d3040 str r3, [sp, #64] ; 0x40
* 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))
15aec: 0a000002 beq 15afc <msdos_find_name_in_fat_file+0x74>
15af0: e59dc074 ldr ip, [sp, #116] ; 0x74 15af4: e35c0001 cmp ip, #1
15af8: 0a000004 beq 15b10 <msdos_find_name_in_fat_file+0x88>
lfn_entries = 0;
else
lfn_entries =
15afc: e59dc070 ldr ip, [sp, #112] ; 0x70 15b00: e3a0100d mov r1, #13 15b04: e28c000c add r0, ip, #12 15b08: eb00415d bl 26084 <__aeabi_idiv> 15b0c: e1a08000 mov r8, r0
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
15b10: e5963020 ldr r3, [r6, #32] 15b14: e3530001 cmp r3, #1
15b18: 1a000006 bne 15b38 <msdos_find_name_in_fat_file+0xb0>
15b1c: e5963024 ldr r3, [r6, #36] ; 0x24 15b20: e3530000 cmp r3, #0
15b24: 1a000003 bne 15b38 <msdos_find_name_in_fat_file+0xb0>
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
15b28: e5d4300e ldrb r3, [r4, #14]
lfn_entries = 0;
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
15b2c: e3130003 tst r3, #3
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
15b30: 15965018 ldrne r5, [r6, #24]
lfn_entries = 0;
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
15b34: 1a000000 bne 15b3c <msdos_find_name_in_fat_file+0xb4>
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
15b38: e1d450b6 ldrh r5, [r4, #6]
/*
* 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(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
15b3c: e3a07000 mov r7, #0
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
bool empty_space_found = false;
15b40: e58d7014 str r7, [sp, #20]
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
15b44: e1a09007 mov r9, r7
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
15b48: e1a0b007 mov fp, r7
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
uint32_t empty_space_offset = 0;
15b4c: e58d701c str r7, [sp, #28]
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
int lfn_entries;
int lfn_entry = 0;
15b50: e58d7010 str r7, [sp, #16]
uint32_t dir_offset = 0;
uint32_t dir_entry = 0;
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
uint8_t lfn_checksum = 0;
15b54: e58d702c str r7, [sp, #44] ; 0x2c
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_offset = 0;
uint32_t dir_entry = 0;
uint32_t bts2rd = 0;
fat_pos_t lfn_start;
bool lfn_matched = false;
15b58: e58d7028 str r7, [sp, #40] ; 0x28
char *name_dir_entry
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_offset = 0;
15b5c: e58d700c str r7, [sp, #12] 15b60: e58d6024 str r6, [sp, #36] ; 0x24 15b64: e58da030 str sl, [sp, #48] ; 0x30
/*
* 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(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
15b68: ea0000d9 b 15ed4 <msdos_find_name_in_fat_file+0x44c>
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)
15b6c: e350001f cmp r0, #31
15b70: da0001d4 ble 162c8 <msdos_find_name_in_fat_file+0x840>
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
15b74: e1500005 cmp r0, r5
15b78: 0a000004 beq 15b90 <msdos_find_name_in_fat_file+0x108>
15b7c: e59f07a0 ldr r0, [pc, #1952] ; 16324 <msdos_find_name_in_fat_file+0x89c><== NOT EXECUTED 15b80: e59f17ac ldr r1, [pc, #1964] ; 16334 <msdos_find_name_in_fat_file+0x8ac><== NOT EXECUTED 15b84: e59f27a0 ldr r2, [pc, #1952] ; 1632c <msdos_find_name_in_fat_file+0x8a4><== NOT EXECUTED 15b88: e59f37a8 ldr r3, [pc, #1960] ; 16338 <msdos_find_name_in_fat_file+0x8b0><== NOT EXECUTED 15b8c: ebfff1e6 bl 1232c <__assert_func> <== NOT EXECUTED
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
15b90: e2883001 add r3, r8, #1 15b94: e58d303c str r3, [sp, #60] ; 0x3c 15b98: e59d3028 ldr r3, [sp, #40] ; 0x28
#endif
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
15b9c: e3a06000 mov r6, #0
memcpy(name_dir_entry, entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
15ba0: e3e0a000 mvn sl, #0
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
15ba4: e1a0c007 mov ip, r7
/* 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;
15ba8: e59420a0 ldr r2, [r4, #160] ; 0xa0
* 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)
15bac: e59d001c ldr r0, [sp, #28]
/* 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;
15bb0: e0827006 add r7, r2, r6
* 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)
15bb4: e59d100c ldr r1, [sp, #12]
/*
* 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) ==
15bb8: e7d22006 ldrb r2, [r2, r6]
* 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)
15bbc: e3590000 cmp r9, #0 15bc0: 01a00001 moveq r0, r1 15bc4: 01a0b006 moveq fp, r6
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
15bc8: e3520000 cmp r2, #0
* 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)
15bcc: e58d001c str r0, [sp, #28]
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
15bd0: 1a00000a bne 15c00 <msdos_find_name_in_fat_file+0x178>
#endif
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
15bd4: e59d2018 ldr r2, [sp, #24] 15bd8: e3520000 cmp r2, #0 15bdc: e1a0c006 mov ip, r6 15be0: e59da030 ldr sl, [sp, #48] ; 0x30 15be4: e59d6024 ldr r6, [sp, #36] ; 0x24
15be8: 0a0001c5 beq 16304 <msdos_find_name_in_fat_file+0x87c>
* 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)
15bec: e59d3014 ldr r3, [sp, #20] 15bf0: e3530000 cmp r3, #0
{
empty_space_count +=
entries_per_block - (dir_entry / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
15bf4: 008992a5 addeq r9, r9, r5, lsr #5
* 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 +=
15bf8: 004992ac subeq r9, r9, ip, lsr #5 15bfc: ea0000c2 b 15f0c <msdos_find_name_in_fat_file+0x484>
printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif
}
break;
}
else if (entry_empty)
15c00: e35200e5 cmp r2, #229 ; 0xe5
{
if (create_node)
15c04: e59d0018 ldr r0, [sp, #24]
printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif
}
break;
}
else if (entry_empty)
15c08: 1a000008 bne 15c30 <msdos_find_name_in_fat_file+0x1a8>
{
if (create_node)
15c0c: e3500000 cmp r0, #0
15c10: 0a0000a7 beq 15eb4 <msdos_find_name_in_fat_file+0x42c>
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
empty_space_found = true;
15c14: e59d203c ldr r2, [sp, #60] ; 0x3c
if (create_node)
{
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
15c18: e2899001 add r9, r9, #1
if (empty_space_count == (lfn_entries + 1))
empty_space_found = true;
15c1c: e59d1014 ldr r1, [sp, #20] 15c20: e1590002 cmp r9, r2 15c24: 03a01001 moveq r1, #1 15c28: e58d1014 str r1, [sp, #20] 15c2c: ea0000a0 b 15eb4 <msdos_find_name_in_fat_file+0x42c>
* 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)
15c30: e3500000 cmp r0, #0
15c34: 0a000003 beq 15c48 <msdos_find_name_in_fat_file+0x1c0>
{
empty_space_entry = 0;
empty_space_count = 0;
15c38: e59d1014 ldr r1, [sp, #20] 15c3c: e3510000 cmp r1, #0 15c40: 01a09001 moveq r9, r1 15c44: 01a0b001 moveq fp, r1
/*
* Check the attribute to see if the entry is for a long
* file name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
15c48: e5d7100b ldrb r1, [r7, #11] 15c4c: e201103f and r1, r1, #63 ; 0x3f 15c50: e351000f cmp r1, #15
15c54: 1a00004f bne 15d98 <msdos_find_name_in_fat_file+0x310>
#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)
15c58: e59d1040 ldr r1, [sp, #64] ; 0x40 15c5c: e3710001 cmn r1, #1
15c60: 1a00000b bne 15c94 <msdos_find_name_in_fat_file+0x20c>
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
15c64: e2123040 ands r3, r2, #64 ; 0x40
15c68: 0a000091 beq 15eb4 <msdos_find_name_in_fat_file+0x42c>
* 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) &
15c6c: e202203f and r2, r2, #63 ; 0x3f 15c70: e1580002 cmp r8, r2
15c74: 1a00008d bne 15eb0 <msdos_find_name_in_fat_file+0x428>
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
15c78: e59d200c ldr r2, [sp, #12]
lfn_start.ofs = dir_entry;
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
15c7c: e5d7300d ldrb r3, [r7, #13]
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
15c80: e58d2040 str r2, [sp, #64] ; 0x40
lfn_start.ofs = dir_entry;
15c84: e58d6044 str r6, [sp, #68] ; 0x44
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
15c88: e58d8010 str r8, [sp, #16] 15c8c: e58d302c str r3, [sp, #44] ; 0x2c
* 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)
{
lfn_matched = false;
15c90: e3a03000 mov r3, #0
* 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) &
15c94: e5d72000 ldrb r2, [r7] 15c98: e59d0010 ldr r0, [sp, #16] 15c9c: e202203f and r2, r2, #63 ; 0x3f 15ca0: e1500002 cmp r0, r2
15ca4: 1a000003 bne 15cb8 <msdos_find_name_in_fat_file+0x230>
MSDOS_LAST_LONG_ENTRY_MASK)) ||
15ca8: e5d7200d ldrb r2, [r7, #13] 15cac: e59d102c ldr r1, [sp, #44] ; 0x2c 15cb0: e1520001 cmp r2, r1
15cb4: 0a000001 beq 15cc0 <msdos_find_name_in_fat_file+0x238>
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
{
#if MSDOS_FIND_PRINT
printf ("MSFS:[4.4] no match\n");
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
15cb8: e58da040 str sl, [sp, #64] ; 0x40 <== NOT EXECUTED
continue;
15cbc: ea00007c b 15eb4 <msdos_find_name_in_fat_file+0x42c> <== NOT EXECUTED
}
lfn_entry--;
15cc0: e59d3010 ldr r3, [sp, #16]
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
15cc4: e3a0000d mov r0, #13
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
15cc8: e2432001 sub r2, r3, #1
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
15ccc: e0010290 mul r1, r0, r2
* RC_OK on success, or error code if error occured (errno set * appropriately) * */ #define MSDOS_FIND_PRINT 0 int msdos_find_name_in_fat_file(
15cd0: e59d0034 ldr r0, [sp, #52] ; 0x34 15cd4: e0800001 add r0, r0, r1 15cd8: e58d0038 str r0, [sp, #56] ; 0x38 15cdc: e58d1004 str r1, [sp, #4]
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
p = entry + 1;
15ce0: e2877001 add r7, r7, #1
#if MSDOS_FIND_PRINT
printf ("MSFS:[5] lfne:%i\n", lfn_entry);
#endif
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
15ce4: e3a03000 mov r3, #0
{
#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')
15ce8: e5d71000 ldrb r1, [r7] 15cec: e3510000 cmp r1, #0 15cf0: e58d1028 str r1, [sp, #40] ; 0x28
15cf4: 1a000008 bne 15d1c <msdos_find_name_in_fat_file+0x294>
/*
* 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) &&
15cf8: e59d0010 ldr r0, [sp, #16] 15cfc: e1500008 cmp r0, r8 15d00: e59d1004 ldr r1, [sp, #4]
15d04: 1a00001a bne 15d74 <msdos_find_name_in_fat_file+0x2ec>
((o + i) != name_len))
15d08: e0813003 add r3, r1, r3
/*
* 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) &&
15d0c: e59d1070 ldr r1, [sp, #112] ; 0x70 15d10: e1530001 cmp r3, r1
15d14: 1a00000b bne 15d48 <msdos_find_name_in_fat_file+0x2c0>
15d18: ea000015 b 15d74 <msdos_find_name_in_fat_file+0x2ec>
* RC_OK on success, or error code if error occured (errno set * appropriately) * */ #define MSDOS_FIND_PRINT 0 int msdos_find_name_in_fat_file(
15d1c: e59d0004 ldr r0, [sp, #4]
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
15d20: e59d1070 ldr r1, [sp, #112] ; 0x70
* RC_OK on success, or error code if error occured (errno set * appropriately) * */ #define MSDOS_FIND_PRINT 0 int msdos_find_name_in_fat_file(
15d24: e0830000 add r0, r3, r0
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
15d28: e1500001 cmp r0, r1
* RC_OK on success, or error code if error occured (errno set * appropriately) * */ #define MSDOS_FIND_PRINT 0 int msdos_find_name_in_fat_file(
15d2c: e58d0020 str r0, [sp, #32]
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
15d30: aa000004 bge 15d48 <msdos_find_name_in_fat_file+0x2c0>
15d34: e59d0038 ldr r0, [sp, #56] ; 0x38 15d38: e59d1028 ldr r1, [sp, #40] ; 0x28 15d3c: e7d00003 ldrb r0, [r0, r3] 15d40: e1500001 cmp r0, r1
15d44: 0a000001 beq 15d50 <msdos_find_name_in_fat_file+0x2c8>
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
15d48: e58da040 str sl, [sp, #64] ; 0x40
break;
15d4c: ea000008 b 15d74 <msdos_find_name_in_fat_file+0x2ec>
}
switch (i)
15d50: e3530004 cmp r3, #4
{
case 4:
p += 5;
15d54: 02877005 addeq r7, r7, #5
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
switch (i)
15d58: 0a000002 beq 15d68 <msdos_find_name_in_fat_file+0x2e0>
15d5c: e353000a cmp r3, #10
break;
case 10:
p += 4;
break;
default:
p += 2;
15d60: 12877002 addne r7, r7, #2
{
case 4:
p += 5;
break;
case 10:
p += 4;
15d64: 02877004 addeq r7, r7, #4
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++)
15d68: e2833001 add r3, r3, #1 15d6c: e353000d cmp r3, #13
15d70: 1affffdc bne 15ce8 <msdos_find_name_in_fat_file+0x260>
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
15d74: e3520000 cmp r2, #0 15d78: 13a03000 movne r3, #0
15d7c: 1a000002 bne 15d8c <msdos_find_name_in_fat_file+0x304> * RC_OK on success, or error code if error occured (errno set * appropriately) * */ #define MSDOS_FIND_PRINT 0 int msdos_find_name_in_fat_file(
15d80: e59d3040 ldr r3, [sp, #64] ; 0x40 15d84: e2933001 adds r3, r3, #1 15d88: 13a03001 movne r3, #1
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
15d8c: e20330ff and r3, r3, #255 ; 0xff
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
15d90: e58d2010 str r2, [sp, #16] 15d94: ea000046 b 15eb4 <msdos_find_name_in_fat_file+0x42c>
* 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)
15d98: e3530000 cmp r3, #0
15d9c: 0a00000f beq 15de0 <msdos_find_name_in_fat_file+0x358>
15da0: e3a02000 mov r2, #0 15da4: e1a03002 mov r3, r2
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;
15da8: e7d71002 ldrb r1, [r7, r2] 15dac: e2130001 ands r0, r3, #1 15db0: 13a00080 movne r0, #128 ; 0x80 15db4: e08130a3 add r3, r1, r3, lsr #1
{
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++)
15db8: e2822001 add r2, r2, #1
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
15dbc: e0833000 add r3, r3, r0
{
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++)
15dc0: e352000b cmp r2, #11
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
15dc4: e20330ff and r3, r3, #255 ; 0xff
{
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++)
15dc8: 1afffff6 bne 15da8 <msdos_find_name_in_fat_file+0x320>
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entry || (lfn_checksum != cs))
15dcc: e59d202c ldr r2, [sp, #44] ; 0x2c 15dd0: e59d0010 ldr r0, [sp, #16] 15dd4: e3500000 cmp r0, #0 15dd8: 01520003 cmpeq r2, r3
15ddc: 0a00000d beq 15e18 <msdos_find_name_in_fat_file+0x390>
* 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 ||
15de0: e59d1074 ldr r1, [sp, #116] ; 0x74 15de4: e3510001 cmp r1, #1
15de8: 1a00002f bne 15eac <msdos_find_name_in_fat_file+0x424>
((name_type == MSDOS_NAME_SHORT) &&
15dec: e59d3040 ldr r3, [sp, #64] ; 0x40 15df0: e3730001 cmn r3, #1
15df4: 1a00002c bne 15eac <msdos_find_name_in_fat_file+0x424>
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
(memcmp(MSDOS_DIR_NAME(entry),
15df8: e1a00007 mov r0, r7 15dfc: e59d107c ldr r1, [sp, #124] ; 0x7c 15e00: e3a0200b mov r2, #11 15e04: e58dc008 str ip, [sp, #8] 15e08: eb000d10 bl 19250 <memcmp>
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
((name_type == MSDOS_NAME_SHORT) &&
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
15e0c: e3500000 cmp r0, #0 15e10: e59dc008 ldr ip, [sp, #8]
15e14: 1a000024 bne 15eac <msdos_find_name_in_fat_file+0x424>
15e18: e1a08007 mov r8, r7 15e1c: e1a0700c mov r7, ip 15e20: e1a0c006 mov ip, r6 15e24: e59d6024 ldr r6, [sp, #36] ; 0x24 15e28: e59da030 ldr sl, [sp, #48] ; 0x30
#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(&fs_info->fat, fat_fd, F_CLU_NUM,
15e2c: e1a03007 mov r3, r7 15e30: e1a00004 mov r0, r4 15e34: e1a01006 mov r1, r6 15e38: e3a02001 mov r2, #1 15e3c: e58dc008 str ip, [sp, #8] 15e40: e58da000 str sl, [sp] 15e44: ebffe9d1 bl 10590 <fat_file_ioctl>
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
15e48: e2507000 subs r7, r0, #0 15e4c: e59dc008 ldr ip, [sp, #8]
15e50: 1a000130 bne 16318 <msdos_find_name_in_fat_file+0x890>
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
15e54: e59d3040 ldr r3, [sp, #64] ; 0x40 15e58: e3730001 cmn r3, #1
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
15e5c: e58ac004 str ip, [sl, #4]
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
15e60: 0a000008 beq 15e88 <msdos_find_name_in_fat_file+0x400>
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
15e64: e28d2040 add r2, sp, #64 ; 0x40 15e68: e58d2000 str r2, [sp] 15e6c: e1a00004 mov r0, r4 15e70: e1a01006 mov r1, r6 15e74: e3a02001 mov r2, #1 15e78: e0030395 mul r3, r5, r3 15e7c: ebffe9c3 bl 10590 <fat_file_ioctl>
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
15e80: e3500000 cmp r0, #0
15e84: 1a000122 bne 16314 <msdos_find_name_in_fat_file+0x88c>
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
15e88: e59d3040 ldr r3, [sp, #64] ; 0x40 15e8c: e58a3008 str r3, [sl, #8]
dir_pos->lname.ofs = lfn_start.ofs;
15e90: e59d3044 ldr r3, [sp, #68] ; 0x44
memcpy(name_dir_entry, entry,
15e94: e59d007c ldr r0, [sp, #124] ; 0x7c
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
15e98: e58a300c str r3, [sl, #12]
memcpy(name_dir_entry, entry,
15e9c: e1a01008 mov r1, r8 15ea0: e3a02020 mov r2, #32 15ea4: eb000d16 bl 19304 <memcpy>
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
15ea8: ea00011a b 16318 <msdos_find_name_in_fat_file+0x890>
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
15eac: e58da040 str sl, [sp, #64] ; 0x40
* 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)
{
lfn_matched = false;
15eb0: e3a03000 mov r3, #0
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)
15eb4: e2866020 add r6, r6, #32
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;
15eb8: e1560005 cmp r6, r5
15ebc: 3affff39 bcc 15ba8 <msdos_find_name_in_fat_file+0x120>
15ec0: e08c7005 add r7, ip, r5
}
if (remainder_empty)
break;
dir_offset++;
15ec4: e59dc00c ldr ip, [sp, #12] 15ec8: e28cc001 add ip, ip, #1 15ecc: e58d3028 str r3, [sp, #40] ; 0x28 15ed0: e58dc00c str ip, [sp, #12]
/*
* 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(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
15ed4: e59430a0 ldr r3, [r4, #160] ; 0xa0 15ed8: e1a00004 mov r0, r4 15edc: e58d3000 str r3, [sp] 15ee0: e59d1024 ldr r1, [sp, #36] ; 0x24 15ee4: e1a02007 mov r2, r7 15ee8: e1a03005 mov r3, r5 15eec: ebffe8da bl 1025c <fat_file_read> 15ef0: e3500000 cmp r0, #0
15ef4: 1affff1c bne 15b6c <msdos_find_name_in_fat_file+0xe4>
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
15ef8: e59dc018 ldr ip, [sp, #24] 15efc: e35c0000 cmp ip, #0 15f00: e59d6024 ldr r6, [sp, #36] ; 0x24 15f04: e59da030 ldr sl, [sp, #48] ; 0x30
15f08: 0a0000fd beq 16304 <msdos_find_name_in_fat_file+0x87c>
* 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)
15f0c: e59dc074 ldr ip, [sp, #116] ; 0x74 15f10: e35c0002 cmp ip, #2
15f14: 1a00001f bne 15f98 <msdos_find_name_in_fat_file+0x510>
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
15f18: e59d101c ldr r1, [sp, #28] 15f1c: e021b195 mla r1, r5, r1, fp
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
15f20: e59dc07c ldr ip, [sp, #124] ; 0x7c
*/
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;
15f24: e2883001 add r3, r8, #1 15f28: e08312a1 add r1, r3, r1, lsr #5
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
15f2c: e5dc3000 ldrb r3, [ip] 15f30: e3530020 cmp r3, #32 15f34: 1353002e cmpne r3, #46 ; 0x2e
*c = '_';
15f38: 03a0305f moveq r3, #95 ; 0x5f 15f3c: 05cc3000 strbeq r3, [ip]
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
15f40: e59dc07c ldr ip, [sp, #124] ; 0x7c 15f44: e5dc3001 ldrb r3, [ip, #1] 15f48: e3530020 cmp r3, #32 15f4c: 1353002e cmpne r3, #46 ; 0x2e
*c = '_';
15f50: 03a0305f moveq r3, #95 ; 0x5f 15f54: 05cc3001 strbeq r3, [ip, #1]
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 < 2; i++, c++)
15f58: e59dc07c ldr ip, [sp, #124] ; 0x7c 15f5c: e28c2002 add r2, ip, #2
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
15f60: e59fc3d4 ldr ip, [pc, #980] ; 1633c <msdos_find_name_in_fat_file+0x8b4>
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 < 2; i++, c++)
15f64: e3a0300c mov r3, #12
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
15f68: e1a00351 asr r0, r1, r3 15f6c: e200000f and r0, r0, #15 15f70: e7dc0000 ldrb r0, [ip, r0]
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
15f74: e2433004 sub r3, r3, #4 15f78: e3730004 cmn r3, #4
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
15f7c: e4c20001 strb r0, [r2], #1
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
15f80: 1afffff8 bne 15f68 <msdos_find_name_in_fat_file+0x4e0>
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
*c++ = '~';
15f84: e59dc07c ldr ip, [sp, #124] ; 0x7c 15f88: e3a0307e mov r3, #126 ; 0x7e 15f8c: e5cc3006 strb r3, [ip, #6]
*c++ = '1';
15f90: e3a03031 mov r3, #49 ; 0x31 15f94: e5cc3007 strb r3, [ip, #7]
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)
15f98: e3580000 cmp r8, #0
* If a long file name calculate the checksum of the short file name
* 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;
15f9c: 058d8010 streq r8, [sp, #16]
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)
15fa0: 0a00000d beq 15fdc <msdos_find_name_in_fat_file+0x554>
15fa4: e3a03000 mov r3, #0 15fa8: e58d3010 str r3, [sp, #16] 15fac: e1a02003 mov r2, r3
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
15fb0: e59dc07c ldr ip, [sp, #124] ; 0x7c 15fb4: e7dc0003 ldrb r0, [ip, r3] 15fb8: e2121001 ands r1, r2, #1 15fbc: 13a01080 movne r1, #128 ; 0x80 15fc0: e08020a2 add r2, r0, r2, lsr #1
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
15fc4: e2833001 add r3, r3, #1
lfn_checksum =
15fc8: e0822001 add r2, r2, r1
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
15fcc: e353000b cmp r3, #11
lfn_checksum =
15fd0: e20220ff and r2, r2, #255 ; 0xff
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
15fd4: 1afffff5 bne 15fb0 <msdos_find_name_in_fat_file+0x528>
15fd8: e58d2010 str r2, [sp, #16]
* 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)
15fdc: e59dc00c ldr ip, [sp, #12] 15fe0: e3590000 cmp r9, #0 15fe4: 058dc01c streq ip, [sp, #28]
{
read_cluster = true;
15fe8: 03a03001 moveq r3, #1
empty_space_offset = dir_offset;
empty_space_entry = 0;
15fec: 01a0b009 moveq fp, r9
* 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)
15ff0: 0a000002 beq 16000 <msdos_find_name_in_fat_file+0x578>
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
15ff4: e59d001c ldr r0, [sp, #28] 15ff8: e05c3000 subs r3, ip, r0 15ffc: 13a03001 movne r3, #1
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
16000: e59d901c ldr r9, [sp, #28] 16004: e3e02000 mvn r2, #0
lfn_entry = 0;
16008: e3a0c000 mov ip, #0
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
1600c: e58d2044 str r2, [sp, #68] ; 0x44 16010: e58d2040 str r2, [sp, #64] ; 0x40 16014: e0090995 mul r9, r5, r9
lfn_entry = 0;
16018: e58dc00c str ip, [sp, #12]
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
1601c: ea0000b3 b 162f0 <msdos_find_name_in_fat_file+0x868>
{
int length = 0;
if (read_cluster)
16020: e3530000 cmp r3, #0
16024: 0a000009 beq 16050 <msdos_find_name_in_fat_file+0x5c8>
{
uint32_t new_length;
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.1] eso:%li\n", empty_space_offset);
#endif
ret = fat_file_read(&fs_info->fat, fat_fd,
16028: e59430a0 ldr r3, [r4, #160] ; 0xa0 1602c: e1a02009 mov r2, r9 16030: e58d3000 str r3, [sp] 16034: e1a00004 mov r0, r4 16038: e1a01006 mov r1, r6 1603c: e1a03005 mov r3, r5 16040: ebffe885 bl 1025c <fat_file_read>
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
16044: e1500005 cmp r0, r5
{
uint32_t new_length;
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.1] eso:%li\n", empty_space_offset);
#endif
ret = fat_file_read(&fs_info->fat, fat_fd,
16048: e1a02000 mov r2, r0
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
1604c: 1a000010 bne 16094 <msdos_find_name_in_fat_file+0x60c>
16050: e59dc00c ldr ip, [sp, #12] 16054: e06c3008 rsb r3, ip, r8 16058: e20330ff and r3, r3, #255 ; 0xff 1605c: e58d3014 str r3, [sp, #20]
* RC_OK on success, or error code if error occured (errno set * appropriately) * */ #define MSDOS_FIND_PRINT 0 int msdos_find_name_in_fat_file(
16060: e59d0034 ldr r0, [sp, #52] ; 0x34 16064: e1e0300c mvn r3, ip 16068: e0883003 add r3, r8, r3 1606c: e3a0200d mov r2, #13 16070: e02c0392 mla ip, r2, r3, r0 16074: e3a01000 mov r1, #0
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
16078: e2883001 add r3, r8, #1 1607c: e58d3024 str r3, [sp, #36] ; 0x24
* RC_OK on success, or error code if error occured (errno set * appropriately) * */ #define MSDOS_FIND_PRINT 0 int msdos_find_name_in_fat_file(
16080: e58dc020 str ip, [sp, #32] 16084: e1a03008 mov r3, r8 16088: e58d1018 str r1, [sp, #24] 1608c: e1a0800b mov r8, fp 16090: ea00007b b 16284 <msdos_find_name_in_fat_file+0x7fc>
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
{
if (ret != FAT_EOF)
16094: e3500000 cmp r0, #0
16098: 1a00008a bne 162c8 <msdos_find_name_in_fat_file+0x840>
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 (&fs_info->fat, fat_fd, false,
1609c: e28d3048 add r3, sp, #72 ; 0x48 160a0: e58d3000 str r3, [sp] 160a4: e1a01006 mov r1, r6 160a8: e1a00004 mov r0, r4 160ac: e1a03009 mov r3, r9 160b0: ebffe963 bl 10644 <fat_file_extend>
empty_space_offset * bts2rd, &new_length);
if (ret != RC_OK)
160b4: e2501000 subs r1, r0, #0
160b8: 1a000093 bne 1630c <msdos_find_name_in_fat_file+0x884>
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))
160bc: e59d3048 ldr r3, [sp, #72] ; 0x48 160c0: e1530009 cmp r3, r9
160c4: 1a00007f bne 162c8 <msdos_find_name_in_fat_file+0x840>
rtems_set_errno_and_return_minus_one(EIO);
memset(fs_info->cl_buf, 0, bts2rd);
160c8: e1a02005 mov r2, r5 160cc: e59400a0 ldr r0, [r4, #160] ; 0xa0 160d0: eb000cc1 bl 193dc <memset>
ret = fat_file_write(&fs_info->fat, fat_fd,
160d4: e59430a0 ldr r3, [r4, #160] ; 0xa0 160d8: e1a00004 mov r0, r4 160dc: e58d3000 str r3, [sp] 160e0: e1a01006 mov r1, r6 160e4: e1a02009 mov r2, r9 160e8: e1a03005 mov r3, r5 160ec: ebffe9de bl 1086c <fat_file_write>
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)
160f0: e3700001 cmn r0, #1
160f4: 0a000086 beq 16314 <msdos_find_name_in_fat_file+0x88c>
return ret;
else if (ret != bts2rd)
160f8: e1500005 cmp r0, r5 <== NOT EXECUTED 160fc: 0affffd3 beq 16050 <msdos_find_name_in_fat_file+0x5c8> <== NOT EXECUTED 16100: ea000070 b 162c8 <msdos_find_name_in_fat_file+0x840> <== NOT EXECUTED
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
16104: e59dc018 ldr ip, [sp, #24] 16108: e28cc020 add ip, ip, #32 1610c: e58dc018 str ip, [sp, #24]
lfn_entry++;
16110: e59dc00c ldr ip, [sp, #12]
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
16114: e59d0024 ldr r0, [sp, #36] ; 0x24
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
16118: e28cc001 add ip, ip, #1
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;
1611c: e59470a0 ldr r7, [r4, #160] ; 0xa0
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
16120: e15c0000 cmp ip, r0
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;
16124: e0877008 add r7, r7, r8
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
16128: e58dc00c str ip, [sp, #12]
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
1612c: 1a000021 bne 161b8 <msdos_find_name_in_fat_file+0x730>
16130: e1a0c008 mov ip, r8
{
/* get current cluster number */
int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
16134: e1a00004 mov r0, r4 16138: e1a08003 mov r8, r3 1613c: e1a01006 mov r1, r6 16140: e3a02001 mov r2, #1 16144: e1a03009 mov r3, r9 16148: e58dc008 str ip, [sp, #8] 1614c: e58da000 str sl, [sp] 16150: ebffe90e bl 10590 <fat_file_ioctl>
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
16154: e3500000 cmp r0, #0 16158: e59dc008 ldr ip, [sp, #8]
1615c: 1a00006c bne 16314 <msdos_find_name_in_fat_file+0x88c>
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
16160: e59d3040 ldr r3, [sp, #64] ; 0x40 16164: e3730001 cmn r3, #1
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
16168: e58ac004 str ip, [sl, #4]
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
1616c: 0a000008 beq 16194 <msdos_find_name_in_fat_file+0x70c>
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
16170: e28d2040 add r2, sp, #64 ; 0x40 16174: e58d2000 str r2, [sp] 16178: e1a00004 mov r0, r4 1617c: e1a01006 mov r1, r6 16180: e3a02001 mov r2, #1 16184: e0030395 mul r3, r5, r3 16188: ebffe900 bl 10590 <fat_file_ioctl>
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
1618c: e3500000 cmp r0, #0
16190: 1a00005f bne 16314 <msdos_find_name_in_fat_file+0x88c>
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
16194: e59d3040 ldr r3, [sp, #64] ; 0x40 16198: e58a3008 str r3, [sl, #8]
dir_pos->lname.ofs = lfn_start.ofs;
1619c: e59d3044 ldr r3, [sp, #68] ; 0x44
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
161a0: e1a00007 mov r0, r7
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
161a4: e58a300c str r3, [sl, #12]
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
161a8: e59d107c ldr r1, [sp, #124] ; 0x7c 161ac: e3a02020 mov r2, #32 161b0: eb000c53 bl 19304 <memcpy>
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
161b4: ea000035 b 16290 <msdos_find_name_in_fat_file+0x808>
* 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)
161b8: e59d2040 ldr r2, [sp, #64] ; 0x40 161bc: e3720001 cmn r2, #1
{
lfn_start.cln = empty_space_offset;
161c0: 059dc01c ldreq ip, [sp, #28]
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
161c4: e3a01000 mov r1, #0 161c8: e3a02020 mov r2, #32 161cc: e1a00007 mov r0, r7
* 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;
161d0: 058dc040 streq ip, [sp, #64] ; 0x40
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
161d4: e58d3008 str r3, [sp, #8]
* 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;
161d8: 058d8044 streq r8, [sp, #68] ; 0x44
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
161dc: eb000c7e bl 193dc <memset>
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
161e0: e59dc010 ldr ip, [sp, #16] 161e4: e5c7c00d strb ip, [r7, #13]
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
char* p;
const char* n;
int i;
char fill = 0;
161e8: e3a00000 mov r0, #0
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
161ec: e59dc020 ldr ip, [sp, #32]
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
161f0: e59d3008 ldr r3, [sp, #8]
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
161f4: e2872001 add r2, r7, #1
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
161f8: e1a01000 mov r1, r0
{
if (*n != 0)
161fc: e5dce000 ldrb lr, [ip] 16200: e35e0000 cmp lr, #0
*p = *n;
n++;
}
else
{
p [0] = fill;
16204: 05c20000 strbeq r0, [r2]
p [1] = fill;
16208: 05c20001 strbeq r0, [r2, #1]
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
if (*n != 0)
{
*p = *n;
1620c: 15c2e000 strbne lr, [r2]
n++;
16210: 128cc001 addne ip, ip, #1
}
else
{
p [0] = fill;
p [1] = fill;
fill = 0xff;
16214: 03a000ff moveq r0, #255 ; 0xff
}
switch (i)
16218: e3510004 cmp r1, #4
{
case 4:
p += 5;
1621c: 02822005 addeq r2, r2, #5
p [0] = fill;
p [1] = fill;
fill = 0xff;
}
switch (i)
16220: 0a000002 beq 16230 <msdos_find_name_in_fat_file+0x7a8>
16224: e351000a cmp r1, #10
break;
case 10:
p += 4;
break;
default:
p += 2;
16228: 12822002 addne r2, r2, #2
{
case 4:
p += 5;
break;
case 10:
p += 4;
1622c: 02822004 addeq r2, r2, #4
*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++)
16230: e2811001 add r1, r1, #1 16234: e351000d cmp r1, #13
16238: 1affffef bne 161fc <msdos_find_name_in_fat_file+0x774>
p += 2;
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
1623c: e59dc014 ldr ip, [sp, #20] 16240: e5c7c000 strb ip, [r7]
if (lfn_entry == 1)
16244: e59dc00c ldr ip, [sp, #12] 16248: e35c0001 cmp ip, #1
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
1624c: 059dc014 ldreq ip, [sp, #20] 16250: 038c2040 orreq r2, ip, #64 ; 0x40 16254: 05c72000 strbeq r2, [r7]
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
16258: e5d7200b ldrb r2, [r7, #11]
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)
1625c: e59dc014 ldr ip, [sp, #20]
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
16260: e382200f orr r2, r2, #15 16264: e5c7200b strb r2, [r7, #11]
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)
16268: e24c2001 sub r2, ip, #1 1626c: e59dc020 ldr ip, [sp, #32] 16270: e20220ff and r2, r2, #255 ; 0xff 16274: e24cc00d sub ip, ip, #13 16278: e58d2014 str r2, [sp, #20] 1627c: e58dc020 str ip, [sp, #32] 16280: e2888020 add r8, r8, #32
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
16284: e1580005 cmp r8, r5
16288: 3affff9d bcc 16104 <msdos_find_name_in_fat_file+0x67c>
1628c: e1a08003 mov r8, 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(&fs_info->fat, fat_fd,
16290: e59430a0 ldr r3, [r4, #160] ; 0xa0 16294: e083300b add r3, r3, fp 16298: e58d3000 str r3, [sp] 1629c: e1a00004 mov r0, r4 162a0: e1a01006 mov r1, r6 162a4: e089200b add r2, r9, fp 162a8: e59d3018 ldr r3, [sp, #24] 162ac: ebffe96e bl 1086c <fat_file_write>
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
162b0: e3700001 cmn r0, #1
162b4: 0a000016 beq 16314 <msdos_find_name_in_fat_file+0x88c>
return ret;
else if (ret != length)
162b8: e59dc018 ldr ip, [sp, #24] 162bc: e150000c cmp r0, ip
}
ret = fat_file_write(&fs_info->fat, fat_fd,
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
162c0: e0899005 add r9, r9, r5
return ret;
else if (ret != length)
162c4: 0a000004 beq 162dc <msdos_find_name_in_fat_file+0x854>
rtems_set_errno_and_return_minus_one(EIO);
162c8: eb000966 bl 18868 <__errno> <== NOT EXECUTED 162cc: e3a03005 mov r3, #5 <== NOT EXECUTED 162d0: e5803000 str r3, [r0] <== NOT EXECUTED 162d4: e3e07000 mvn r7, #0 <== NOT EXECUTED 162d8: ea00000e b 16318 <msdos_find_name_in_fat_file+0x890> <== NOT EXECUTED
empty_space_offset++;
162dc: e59dc01c ldr ip, [sp, #28] 162e0: e28cc001 add ip, ip, #1 162e4: e58dc01c str ip, [sp, #28]
empty_space_entry = 0;
162e8: e3a0b000 mov fp, #0
read_cluster = true;
162ec: e3a03001 mov r3, #1
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
162f0: e59dc00c ldr ip, [sp, #12] 162f4: e158000c cmp r8, ip
162f8: aaffff48 bge 16020 <msdos_find_name_in_fat_file+0x598>
empty_space_offset++;
empty_space_entry = 0;
read_cluster = true;
}
return 0;
162fc: e3a07000 mov r7, #0 16300: ea000004 b 16318 <msdos_find_name_in_fat_file+0x890>
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
return MSDOS_NAME_NOT_FOUND_ERR;
16304: e59f7034 ldr r7, [pc, #52] ; 16340 <msdos_find_name_in_fat_file+0x8b8> 16308: ea000002 b 16318 <msdos_find_name_in_fat_file+0x890>
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 (&fs_info->fat, fat_fd, false,
1630c: e1a07001 mov r7, r1 <== NOT EXECUTED 16310: ea000000 b 16318 <msdos_find_name_in_fat_file+0x890> <== NOT EXECUTED
}
ret = fat_file_write(&fs_info->fat, fat_fd,
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
16314: e1a07000 mov r7, r0
empty_space_entry = 0;
read_cluster = true;
}
return 0;
}
16318: e1a00007 mov r0, r7
1631c: e28dd04c add sp, sp, #76 ; 0x4c
16320: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00016344 <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
)
{
16344: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
16348: e1a09003 mov r9, r3
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) &&
1634c: e5913020 ldr r3, [r1, #32] 16350: e3530001 cmp r3, #1
fat_file_fd_t *fat_fd,
uint32_t cl4find,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
16354: e1a06001 mov r6, r1 16358: e1a0b002 mov fp, r2
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
1635c: e5904008 ldr r4, [r0, #8]
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
16360: 1a000008 bne 16388 <msdos_find_node_by_cluster_num_in_fat_file+0x44>
16364: e5913024 ldr r3, [r1, #36] ; 0x24 <== NOT EXECUTED 16368: e3530000 cmp r3, #0 <== NOT EXECUTED 1636c: 1a000005 bne 16388 <msdos_find_node_by_cluster_num_in_fat_file+0x44><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
16370: e5d4300e ldrb r3, [r4, #14] <== 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) &&
16374: e3130003 tst r3, #3 <== NOT EXECUTED 16378: 0a000002 beq 16388 <msdos_find_node_by_cluster_num_in_fat_file+0x44><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
1637c: e5917018 ldr r7, [r1, #24] <== NOT EXECUTED
assert(ret == bts2rd);
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
16380: e3a0a000 mov sl, #0 16384: ea000031 b 16450 <msdos_find_node_by_cluster_num_in_fat_file+0x10c>
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
16388: e1d470b6 ldrh r7, [r4, #6] 1638c: eafffffb b 16380 <msdos_find_node_by_cluster_num_in_fat_file+0x3c>
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
16390: e350001f cmp r0, #31
16394: ca000004 bgt 163ac <msdos_find_node_by_cluster_num_in_fat_file+0x68>
rtems_set_errno_and_return_minus_one( EIO );
16398: eb000932 bl 18868 <__errno> <== NOT EXECUTED 1639c: e3a03005 mov r3, #5 <== NOT EXECUTED 163a0: e5803000 str r3, [r0] <== NOT EXECUTED 163a4: e3e04000 mvn r4, #0 <== NOT EXECUTED 163a8: ea000032 b 16478 <msdos_find_node_by_cluster_num_in_fat_file+0x134><== NOT EXECUTED
assert(ret == bts2rd);
163ac: e1500007 cmp r0, r7 163b0: 159f00c8 ldrne r0, [pc, #200] ; 16480 <msdos_find_node_by_cluster_num_in_fat_file+0x13c> 163b4: 159f10c8 ldrne r1, [pc, #200] ; 16484 <msdos_find_node_by_cluster_num_in_fat_file+0x140> 163b8: 159f20c8 ldrne r2, [pc, #200] ; 16488 <msdos_find_node_by_cluster_num_in_fat_file+0x144> 163bc: 159f30c8 ldrne r3, [pc, #200] ; 1648c <msdos_find_node_by_cluster_num_in_fat_file+0x148> 163c0: 1bffefd9 blne 1232c <__assert_func>
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
163c4: e59430a0 ldr r3, [r4, #160] ; 0xa0 163c8: e3a05000 mov r5, #0 163cc: e1a08003 mov r8, r3
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
163d0: e7d32005 ldrb r2, [r3, r5] 163d4: e3520000 cmp r2, #0
163d8: 0a000025 beq 16474 <msdos_find_node_by_cluster_num_in_fat_file+0x130>
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)) ==
163dc: e35200e5 cmp r2, #229 ; 0xe5
163e0: 0a000015 beq 1643c <msdos_find_node_by_cluster_num_in_fat_file+0xf8>
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
163e4: e1d811b4 ldrh r1, [r8, #20] 163e8: e1d821ba ldrh r2, [r8, #26] 163ec: e1822801 orr r2, r2, r1, lsl #16 163f0: e152000b cmp r2, fp
163f4: 1a000010 bne 1643c <msdos_find_node_by_cluster_num_in_fat_file+0xf8>
{
/* on success fill aux structure and copy all 32 bytes */
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM, j * bts2rd,
163f8: e1a00004 mov r0, r4 163fc: e1a01006 mov r1, r6 16400: e3a02001 mov r2, #1 16404: e1a0300a mov r3, sl 16408: e58d9000 str r9, [sp] 1640c: ebffe85f bl 10590 <fat_file_ioctl>
&dir_pos->sname.cln);
if (rc != RC_OK)
16410: e2504000 subs r4, r0, #0
16414: 1a000017 bne 16478 <msdos_find_node_by_cluster_num_in_fat_file+0x134>
return rc;
dir_pos->sname.ofs = i;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
16418: e3e03000 mvn r3, #0
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM, j * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = i;
1641c: e5895004 str r5, [r9, #4]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
16420: e5893008 str r3, [r9, #8]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
16424: e589300c str r3, [r9, #12]
memcpy(dir_entry, entry,
16428: e59d0028 ldr r0, [sp, #40] ; 0x28 1642c: e1a01008 mov r1, r8 16430: e3a02020 mov r2, #32 16434: eb000bb2 bl 19304 <memcpy>
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
16438: ea00000e b 16478 <msdos_find_node_by_cluster_num_in_fat_file+0x134>
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)
1643c: e2855020 add r5, r5, #32 16440: e1550007 cmp r5, r7 16444: e2888020 add r8, r8, #32
16448: 3affffe0 bcc 163d0 <msdos_find_node_by_cluster_num_in_fat_file+0x8c>
1644c: e08aa007 add sl, sl, r7 <== 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(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
16450: e59430a0 ldr r3, [r4, #160] ; 0xa0 16454: e1a00004 mov r0, r4 16458: e58d3000 str r3, [sp] 1645c: e1a01006 mov r1, r6 16460: e1a0200a mov r2, sl 16464: e1a03007 mov r3, r7 16468: ebffe77b bl 1025c <fat_file_read> 1646c: e3500000 cmp r0, #0
16470: 1affffc6 bne 16390 <msdos_find_node_by_cluster_num_in_fat_file+0x4c>
char* entry = (char*) fs_info->cl_buf + i;
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
return MSDOS_NAME_NOT_FOUND_ERR;
16474: e59f4014 ldr r4, [pc, #20] ; 16490 <msdos_find_node_by_cluster_num_in_fat_file+0x14c><== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
16478: e1a00004 mov r0, r4
1647c: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000bc54 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
bc54: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
bc58: e59f2d98 ldr r2, [pc, #3480] ; c9f8 <msdos_format+0xda4>
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
bc5c: e24ddfb7 sub sp, sp, #732 ; 0x2dc
bc60: e1a07000 mov r7, r0
bc64: e1a05001 mov r5, r1
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
bc68: e1a00001 mov r0, r1
bc6c: e3a01002 mov r1, #2
bc70: ebffff66 bl ba10 <msdos_format_printf>
fd = open(devname, O_RDWR);
bc74: e3a01002 mov r1, #2
bc78: e1a00007 mov r0, r7
bc7c: ebffe42f bl 4d40 <open>
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
char tmp_sec[FAT_TOTAL_MBR_SIZE];
struct stat stat_buf;
int ret_val = 0;
bc80: e3700001 cmn r0, #1
bc84: 01a04000 moveq r4, r0
bc88: 13a04000 movne r4, #0
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
fd = open(devname, O_RDWR);
bc8c: e1a06000 mov r6, r0
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
bc90: e3a01002 mov r1, #2
bc94: e1a00005 mov r0, r5
bc98: e59f2d5c ldr r2, [pc, #3420] ; c9fc <msdos_format+0xda8>
bc9c: e1a03007 mov r3, r7
bca0: ebffff5a bl ba10 <msdos_format_printf>
"stat check: %s\n", devname);
if (ret_val == 0) {
bca4: e3540000 cmp r4, #0
bca8: 13e04000 mvnne r4, #0
bcac: 1a000003 bne bcc0 <msdos_format+0x6c>
ret_val = fstat(fd, &stat_buf);
bcb0: e1a00006 mov r0, r6
bcb4: e28d1fa2 add r1, sp, #648 ; 0x288
bcb8: ebffe100 bl 40c0 <fstat>
bcbc: e1a04000 mov r4, r0
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
bcc0: e1a00005 mov r0, r5
bcc4: e3a01001 mov r1, #1
bcc8: e59f2d30 ldr r2, [pc, #3376] ; ca00 <msdos_format+0xdac>
bccc: e1a03007 mov r3, r7
bcd0: ebffff4e bl ba10 <msdos_format_printf>
"formating: %s\n", devname);
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {
bcd4: e3540000 cmp r4, #0
bcd8: 1a0001bb bne c3cc <msdos_format+0x778>
bcdc: e59d3294 ldr r3, [sp, #660] ; 0x294
bce0: e2033a0f and r3, r3, #61440 ; 0xf000
bce4: e3530a06 cmp r3, #24576 ; 0x6000
bce8: 0a000321 beq c974 <msdos_format+0xd20>
errno = ENOTTY;
bcec: eb0032dd bl 18868 <__errno> <== NOT EXECUTED
bcf0: e3a03019 mov r3, #25 <== NOT EXECUTED
bcf4: e5803000 str r3, [r0] <== NOT EXECUTED
ret_val = -1;
bcf8: e3e04000 mvn r4, #0 <== NOT EXECUTED
bcfc: ea0001b2 b c3cc <msdos_format+0x778> <== NOT EXECUTED
static inline int rtems_disk_fd_get_block_count(
int fd,
rtems_blkdev_bnum *block_count
)
{
return ioctl(fd, RTEMS_BLKIO_GETSIZE, block_count);
bd00: e1a00006 mov r0, r6
bd04: e59f1cf8 ldr r1, [pc, #3320] ; ca04 <msdos_format+0xdb0>
bd08: e28d2f8e add r2, sp, #568 ; 0x238
bd0c: eb001a3a bl 125fc <ioctl>
ret_val = rtems_disk_fd_get_media_block_size(fd, &fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
ret_val = rtems_disk_fd_get_block_count(fd, &fmt_params->totl_sector_cnt);
}
if (ret_val == 0) {
bd10: e2504000 subs r4, r0, #0
bd14: 1a000132 bne c1e4 <msdos_format+0x590>
total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
bd18: e59d2238 ldr r2, [sp, #568] ; 0x238
bd1c: e59d3234 ldr r3, [sp, #564] ; 0x234
bd20: e0010293 mul r1, r3, r2
bd24: e3a09000 mov r9, #0
bd28: e1a08001 mov r8, r1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
bd2c: e58d2000 str r2, [sp]
bd30: e1a00005 mov r0, r5
bd34: e3a01002 mov r1, #2
bd38: e59f2cc8 ldr r2, [pc, #3272] ; ca08 <msdos_format+0xdb4>
bd3c: e98d0300 stmib sp, {r8, r9}
bd40: ebffff32 bl ba10 <msdos_format_printf>
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
bd44: e1550009 cmp r5, r9
bd48: 0a000002 beq bd58 <msdos_format+0x104>
(rqdata->fat_num == 0)) {
bd4c: e595300c ldr r3, [r5, #12]
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
bd50: e1530009 cmp r3, r9
bd54: 1a000001 bne bd60 <msdos_format+0x10c>
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
bd58: e3a03002 mov r3, #2
bd5c: ea000001 b bd68 <msdos_format+0x114>
}
else if (rqdata->fat_num <= 6) {
bd60: e3530006 cmp r3, #6
bd64: 8a000008 bhi bd8c <msdos_format+0x138>
fmt_params->fat_num = rqdata->fat_num;
bd68: e5cd3264 strb r3, [sp, #612] ; 0x264
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
bd6c: e1a00005 mov r0, r5
bd70: e3a01002 mov r1, #2
bd74: e59f2c90 ldr r2, [pc, #3216] ; ca0c <msdos_format+0xdb8>
bd78: e5dd3264 ldrb r3, [sp, #612] ; 0x264
bd7c: ebffff23 bl ba10 <msdos_format_printf>
* are a compromise concerning capacity and efficency
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
bd80: e3550000 cmp r5, #0
bd84: 1a000005 bne bda0 <msdos_format+0x14c>
bd88: ea000008 b bdb0 <msdos_format+0x15c>
}
else if (rqdata->fat_num <= 6) {
fmt_params->fat_num = rqdata->fat_num;
}
else {
errno = EINVAL;
bd8c: eb0032b5 bl 18868 <__errno>
bd90: e3a03016 mov r3, #22
bd94: e5803000 str r3, [r0]
ret_val = -1;
bd98: e3e04000 mvn r4, #0
bd9c: ea000110 b c1e4 <msdos_format+0x590>
* are a compromise concerning capacity and efficency
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
bda0: e5953008 ldr r3, [r5, #8]
bda4: e3530000 cmp r3, #0
bda8: 11a02003 movne r2, r3
bdac: 1a000001 bne bdb8 <msdos_format+0x164>
* 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
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
bdb0: e3a02020 mov r2, #32
/*
* 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
*/
uint32_t fat12_sect_per_clust = 8;
bdb4: e3a03008 mov r3, #8
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
fat12_sect_per_clust = rqdata->sectors_per_cluster;
fat16_sect_per_clust = rqdata->sectors_per_cluster;
}
if (fmt_params->totl_sector_cnt < FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
bdb8: e59f0c50 ldr r0, [pc, #3152] ; ca10 <msdos_format+0xdbc>
bdbc: e0030390 mul r3, r0, r3
bdc0: e59d1238 ldr r1, [sp, #568] ; 0x238
bdc4: e1510003 cmp r1, r3
fmt_params->fattype = FAT_FAT12;
bdc8: 33a03001 movcc r3, #1
bdcc: 35cd3266 strbcc r3, [sp, #614] ; 0x266
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
bdd0: 33a03002 movcc r3, #2
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
fat12_sect_per_clust = rqdata->sectors_per_cluster;
fat16_sect_per_clust = rqdata->sectors_per_cluster;
}
if (fmt_params->totl_sector_cnt < FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
bdd4: 3a000015 bcc be30 <msdos_format+0x1dc>
fmt_params->fattype = FAT_FAT12;
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt < FAT_FAT16_MAX_CLN * fat16_sect_per_clust) {
bdd8: e59f3c34 ldr r3, [pc, #3124] ; ca14 <msdos_format+0xdc0>
bddc: e0020293 mul r2, r3, r2
bde0: e1510002 cmp r1, r2
fmt_params->fattype = FAT_FAT16;
bde4: 33a03002 movcc r3, #2
bde8: 35cd3266 strbcc r3, [sp, #614] ; 0x266
if (fmt_params->totl_sector_cnt < FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
fmt_params->fattype = FAT_FAT12;
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt < FAT_FAT16_MAX_CLN * fat16_sect_per_clust) {
bdec: 3a00000f bcc be30 <msdos_format+0x1dc>
/* 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;
bdf0: e3a02101 mov r2, #1073741824 ; 0x40000000
bdf4: e0922008 adds r2, r2, r8
bdf8: e3a03000 mov r3, #0
bdfc: e0a33009 adc r3, r3, r9
be00: e1a01f22 lsr r1, r2, #30
be04: e1811103 orr r1, r1, r3, lsl #2
int b;
fmt_params->fattype = FAT_FAT32;
be08: e3a03004 mov r3, #4
be0c: e5cd3266 strb r3, [sp, #614] ; 0x266
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
be10: e3a02001 mov r2, #1
#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--)
be14: e3a0301f mov r3, #31
if ((gigs & (1 << b)) != 0)
be18: e0110312 ands r0, r1, r2, lsl r3
be1c: 1a000001 bne be28 <msdos_format+0x1d4>
#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--)
be20: e2533001 subs r3, r3, #1
be24: 1afffffb bne be18 <msdos_format+0x1c4>
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
be28: e3a02001 mov r2, #1
be2c: e1a03312 lsl r3, r2, r3
}
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata, fmt_params );
be30: e28d1f8d add r1, sp, #564 ; 0x234
be34: e1a00005 mov r0, r5
fmt_params->fattype = FAT_FAT32;
/* 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;
be38: e58d3240 str r3, [sp, #576] ; 0x240
}
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata, fmt_params );
be3c: ebffff68 bl bbe4 <msdos_set_sectors_per_cluster_from_request>
/* 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;
be40: e3a02101 mov r2, #1073741824 ; 0x40000000
be44: e0922008 adds r2, r2, r8
be48: e3a03000 mov r3, #0
be4c: e0a33009 adc r3, r3, r9
be50: e1a02f22 lsr r2, r2, #30
be54: e1822103 orr r2, r2, r3, lsl #2
be58: e3a01000 mov r1, #0
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
}
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata, fmt_params );
be5c: e1a04000 mov r4, r0
/* 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;
be60: e58d2028 str r2, [sp, #40] ; 0x28
be64: e3a080ff mov r8, #255 ; 0xff
be68: e58d100c str r1, [sp, #12]
be6c: e58d6010 str r6, [sp, #16]
be70: ea0000d2 b c1c0 <msdos_format+0x56c>
&& fmt_params->fattype != fat_type
&& fmt_params->totl_sector_cnt > 0 ) {
/*
* Skip aligning structures or d align them
*/
if (ret_val == 0 && rqdata != NULL)
be74: e2956000 adds r6, r5, #0
be78: 13a06001 movne r6, #1
be7c: e3560000 cmp r6, #0
fmt_params->skip_alignment = rqdata->skip_alignment;
be80: 15d53016 ldrbne r3, [r5, #22]
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
be84: e1a00005 mov r0, r5
&& fmt_params->totl_sector_cnt > 0 ) {
/*
* Skip aligning structures or d align them
*/
if (ret_val == 0 && rqdata != NULL)
fmt_params->skip_alignment = rqdata->skip_alignment;
be88: 15cd3284 strbne r3, [sp, #644] ; 0x284
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
be8c: e3a01002 mov r1, #2
be90: e59d3240 ldr r3, [sp, #576] ; 0x240
be94: e59f2b7c ldr r2, [pc, #2940] ; ca18 <msdos_format+0xdc4>
be98: ebfffedc bl ba10 <msdos_format_printf>
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
be9c: e5dd3266 ldrb r3, [sp, #614] ; 0x266
bea0: e3530004 cmp r3, #4
bea4: 1a000008 bne becc <msdos_format+0x278>
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
bea8: e3a03020 mov r3, #32
beac: e58d323c str r3, [sp, #572] ; 0x23c
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
beb0: e3a03000 mov r3, #0
beb4: e58d324c str r3, [sp, #588] ; 0x24c
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
beb8: e3a03006 mov r3, #6
bebc: e58d325c str r3, [sp, #604] ; 0x25c
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
bec0: e3a03001 mov r3, #1
bec4: e58d3260 str r3, [sp, #608] ; 0x260
bec8: ea000015 b bf24 <msdos_format+0x2d0>
}
else {
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
becc: e3a02001 mov r2, #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) &&
bed0: e3560000 cmp r6, #0
fmt_params->fsinfo_sec = 1;
}
else {
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
bed4: e58d223c str r2, [sp, #572] ; 0x23c
/* 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) &&
bed8: 0a000003 beq beec <msdos_format+0x298>
(rqdata->files_per_root_dir > 0)) {
bedc: e5952010 ldr r2, [r5, #16]
/* 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) &&
bee0: e3520000 cmp r2, #0
(rqdata->files_per_root_dir > 0)) {
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
bee4: 158d224c strne r2, [sp, #588] ; 0x24c
/* 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) &&
bee8: 1a000003 bne befc <msdos_format+0x2a8>
(rqdata->files_per_root_dir > 0)) {
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
}
else {
if (fmt_params->fattype == FAT_FAT16) {
beec: e3530002 cmp r3, #2
fmt_params->files_per_root_dir = 512;
bef0: 03a03c02 moveq r3, #512 ; 0x200
}
else {
fmt_params->files_per_root_dir = 64;
bef4: 13a03040 movne r3, #64 ; 0x40
bef8: e58d324c str r3, [sp, #588] ; 0x24c
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
(2*fmt_params->bytes_per_sector/
befc: e59d1234 ldr r1, [sp, #564] ; 0x234
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
bf00: e59d624c ldr r6, [sp, #588] ; 0x24c
(2*fmt_params->bytes_per_sector/
bf04: e1a01081 lsl r1, r1, #1
bf08: e1a012a1 lsr r1, r1, #5
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
bf0c: e2466001 sub r6, r6, #1
bf10: e0866001 add r6, r6, r1
(2*fmt_params->bytes_per_sector/
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
bf14: e1a00006 mov r0, r6
bf18: ebffd796 bl 1d78 <__umodsi3>
bf1c: e0600006 rsb r0, r0, r6
bf20: e58d024c str r0, [sp, #588] ; 0x24c
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
bf24: e59d7234 ldr r7, [sp, #564] ; 0x234
/ fmt_params->bytes_per_sector);
bf28: e59d024c ldr r0, [sp, #588] ; 0x24c
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
bf2c: e2472001 sub r2, r7, #1
/ fmt_params->bytes_per_sector);
bf30: e1a01007 mov r1, r7
bf34: e0820280 add r0, r2, r0, lsl #5
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
bf38: e58d2014 str r2, [sp, #20]
/ fmt_params->bytes_per_sector);
bf3c: ebffd747 bl 1c60 <__aeabi_uidiv>
if (ret_val == 0) {
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
bf40: e59d3238 ldr r3, [sp, #568] ; 0x238
bf44: e59d223c ldr r2, [sp, #572] ; 0x23c
bf48: e58d3024 str r3, [sp, #36] ; 0x24
fmt_params->bytes_per_sector,
fmt_params->totl_sector_cnt,
fmt_params->rsvd_sector_cnt,
fmt_params->root_dir_sectors,
fmt_params->fat_num,
bf4c: e5dd3264 ldrb r3, [sp, #612] ; 0x264
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
bf50: e1a09000 mov r9, r0
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 =
bf54: e58d0250 str r0, [sp, #592] ; 0x250
uint32_t fatdata_sect_cnt;
uint32_t fat_sectors_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
bf58: e1a01007 mov r1, r7
bf5c: e3a00902 mov r0, #32768 ; 0x8000
if (ret_val == 0) {
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
bf60: e5dd8266 ldrb r8, [sp, #614] ; 0x266
bf64: e58d2018 str r2, [sp, #24]
fmt_params->bytes_per_sector,
fmt_params->totl_sector_cnt,
fmt_params->rsvd_sector_cnt,
fmt_params->root_dir_sectors,
fmt_params->fat_num,
bf68: e58d301c str r3, [sp, #28]
if (ret_val == 0) {
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster(fmt_params->fattype,
bf6c: e59d6240 ldr r6, [sp, #576] ; 0x240
fmt_params->totl_sector_cnt,
fmt_params->rsvd_sector_cnt,
fmt_params->root_dir_sectors,
fmt_params->fat_num,
fmt_params->sectors_per_cluster,
fmt_params->skip_alignment,
bf70: e5ddb284 ldrb fp, [sp, #644] ; 0x284
uint32_t fatdata_sect_cnt;
uint32_t fat_sectors_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
bf74: ebffd739 bl 1c60 <__aeabi_uidiv>
bf78: ea000000 b bf80 <msdos_format+0x32c>
sectors_per_cluster /= 2;
bf7c: e1a060a6 lsr r6, r6, #1 <== NOT EXECUTED
uint32_t fatdata_sect_cnt;
uint32_t fat_sectors_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
bf80: e1500006 cmp r0, r6
bf84: 3afffffc bcc bf7c <msdos_format+0x328>
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
bf88: e59d2018 ldr r2, [sp, #24]
bf8c: e2493001 sub r3, r9, #1
bf90: e2422001 sub r2, r2, #1
bf94: e58d202c str r2, [sp, #44] ; 0x2c
bf98: e58d3020 str r3, [sp, #32]
bf9c: e58d4030 str r4, [sp, #48] ; 0x30
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
bfa0: e35b0000 cmp fp, #0
return (sectors + clustersize - 1) & ~(clustersize - 1);
bfa4: 059d202c ldreq r2, [sp, #44] ; 0x2c
bfa8: 02660000 rsbeq r0, r6, #0
bfac: 00823006 addeq r3, r2, r6
bfb0: 00000003 andeq r0, r0, r3
else
return sectors;
bfb4: 159d0018 ldrne r0, [sp, #24]
* 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_sect_cnt = total_sector_cnt
bfb8: e59d3024 ldr r3, [sp, #36] ; 0x24
- loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
if (fattype == FAT_FAT12) {
bfbc: e3580001 cmp r8, #1
* 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_sect_cnt = total_sector_cnt
bfc0: e0600003 rsb r0, r0, r3
- loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
if (fattype == FAT_FAT12) {
bfc4: 1a00000c bne bffc <msdos_format+0x3a8>
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
bfc8: e35b0000 cmp fp, #0
return (sectors + clustersize - 1) & ~(clustersize - 1);
bfcc: 059d2020 ldreq r2, [sp, #32]
bfd0: 00823006 addeq r3, r2, r6
bfd4: 02662000 rsbeq r2, r6, #0
bfd8: 00023003 andeq r3, r2, r3
else
return sectors;
bfdc: 11a03009 movne r3, r9
fatdata_sect_cnt = total_sector_cnt
- loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
if (fattype == FAT_FAT12) {
fatdata_sect_cnt = fatdata_sect_cnt
- loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
bfe0: e0630000 rsb r0, r3, r0
bfe4: e1a01006 mov r1, r6
bfe8: ebffd71c bl 1c60 <__aeabi_uidiv>
bfec: e1a0a000 mov sl, r0
fat_capacity = fatdata_cluster_cnt * 3 / 2;
bff0: e0800080 add r0, r0, r0, lsl #1
bff4: e1a000a0 lsr r0, r0, #1
bff8: ea000011 b c044 <msdos_format+0x3f0>
}
else if (fattype == FAT_FAT16) {
bffc: e3580002 cmp r8, #2
c000: 1a00000b bne c034 <msdos_format+0x3e0>
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
c004: e35b0000 cmp fp, #0
return (sectors + clustersize - 1) & ~(clustersize - 1);
c008: 059d2020 ldreq r2, [sp, #32]
c00c: 00823006 addeq r3, r2, r6
c010: 02662000 rsbeq r2, r6, #0
c014: 00023003 andeq r3, r2, r3
else
return sectors;
c018: 11a03009 movne r3, r9
fat_capacity = fatdata_cluster_cnt * 3 / 2;
}
else if (fattype == FAT_FAT16) {
fatdata_sect_cnt = fatdata_sect_cnt
- loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
c01c: e0630000 rsb r0, r3, r0
c020: e1a01006 mov r1, r6
c024: ebffd70d bl 1c60 <__aeabi_uidiv>
c028: e1a0a000 mov sl, r0
fat_capacity = fatdata_cluster_cnt * 2;
c02c: e1a00080 lsl r0, r0, #1
c030: ea000003 b c044 <msdos_format+0x3f0>
}
else { /* FAT32 */
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
c034: e1a01006 mov r1, r6
c038: ebffd708 bl 1c60 <__aeabi_uidiv>
c03c: e1a0a000 mov sl, r0
fat_capacity = fatdata_cluster_cnt * 4;
c040: e1a00100 lsl r0, r0, #2
}
sectors_per_fat = ((fat_capacity
c044: e59d3014 ldr r3, [sp, #20]
c048: e1a01007 mov r1, r7
c04c: e0800003 add r0, r0, r3
c050: ebffd702 bl 1c60 <__aeabi_uidiv>
+ (bytes_per_sector - 1))
/ bytes_per_sector);
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
c054: e59d201c ldr r2, [sp, #28]
c058: e0040092 mul r4, r2, r0
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
c05c: e35b0000 cmp fp, #0
c060: e2460001 sub r0, r6, #1
return (sectors + clustersize - 1) & ~(clustersize - 1);
c064: 00804004 addeq r4, r0, r4
c068: 02663000 rsbeq r3, r6, #0
c06c: 00044003 andeq r4, r4, r3
skip_alignment);
*data_cluster_cnt = (fatdata_cluster_cnt -
((fat_sectors_cnt
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
c070: e0800004 add r0, r0, r4
c074: e1a01006 mov r1, r6
c078: ebffd6f8 bl 1c60 <__aeabi_uidiv>
/*
* data cluster count too big? Then make clusters bigger
*/
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
c07c: e3580001 cmp r8, #1
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
sectors_per_cluster,
skip_alignment);
*data_cluster_cnt = (fatdata_cluster_cnt -
c080: e060a00a rsb sl, r0, sl
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
/*
* data cluster count too big? Then make clusters bigger
*/
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
c084: 1a000004 bne c09c <msdos_format+0x448>
c088: e59f3980 ldr r3, [pc, #2432] ; ca10 <msdos_format+0xdbc>
c08c: e15a0003 cmp sl, r3
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
}
else {
finished = true;
c090: 91a03008 movls r3, r8
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
/*
* data cluster count too big? Then make clusters bigger
*/
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
c094: 9a000009 bls c0c0 <msdos_format+0x46c>
c098: ea000004 b c0b0 <msdos_format+0x45c>
c09c: e3580002 cmp r8, #2
c0a0: 1a000009 bne c0cc <msdos_format+0x478>
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
c0a4: e59f0968 ldr r0, [pc, #2408] ; ca14 <msdos_format+0xdc0>
c0a8: e15a0000 cmp sl, r0
c0ac: 9a000006 bls c0cc <msdos_format+0x478>
finished = true;
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if (fattype == FAT_FAT12) {
c0b0: e3580001 cmp r8, #1
/*
* data cluster count too big? Then make clusters bigger
*/
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
c0b4: e1a06086 lsl r6, r6, #1
finished = true;
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if (fattype == FAT_FAT12) {
c0b8: e3a03000 mov r3, #0
c0bc: 1a000003 bne c0d0 <msdos_format+0x47c>
if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
c0c0: e0020697 mul r2, r7, r6
c0c4: e3520a01 cmp r2, #4096 ; 0x1000
c0c8: ea000002 b c0d8 <msdos_format+0x484>
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
}
else {
finished = true;
c0cc: e3a03001 mov r3, #1
*/
if (fattype == FAT_FAT12) {
if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
finished = true;
}
} else if ((sectors_per_cluster * bytes_per_sector)
c0d0: e0020697 mul r2, r7, r6
c0d4: e3520902 cmp r2, #32768 ; 0x8000
c0d8: 8a000001 bhi c0e4 <msdos_format+0x490>
> MS_BYTES_PER_CLUSTER_LIMIT) {
finished = true;
}
} while (!finished);
c0dc: e3530000 cmp r3, #0
c0e0: 0affffae beq bfa0 <msdos_format+0x34c>
c0e4: e1a03004 mov r3, r4
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
c0e8: e1a00003 mov r0, r3
c0ec: e59d101c ldr r1, [sp, #28]
c0f0: ebffd6da bl 1c60 <__aeabi_uidiv>
static uint8_t
msdos_get_fat_type( const uint32_t bytes_per_sector,
const uint32_t sectors_per_cluster,
const uint32_t number_of_clusters )
{
uint32_t ms_sectors_per_cluster_limit_FAT12 =
c0f4: e1a01007 mov r1, r7
finished = true;
}
} while (!finished);
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
c0f8: e58d0244 str r0, [sp, #580] ; 0x244
static uint8_t
msdos_get_fat_type( const uint32_t bytes_per_sector,
const uint32_t sectors_per_cluster,
const uint32_t number_of_clusters )
{
uint32_t ms_sectors_per_cluster_limit_FAT12 =
c0fc: e59f0918 ldr r0, [pc, #2328] ; ca1c <msdos_format+0xdc8>
fmt_params->sectors_per_cluster,
fmt_params->skip_alignment,
§ors_per_cluster_adj,
&fmt_params->sectors_per_fat,
&data_clusters_cnt);
fmt_params->sectors_per_cluster = sectors_per_cluster_adj;
c100: e58d6240 str r6, [sp, #576] ; 0x240
static uint8_t
msdos_get_fat_type( const uint32_t bytes_per_sector,
const uint32_t sectors_per_cluster,
const uint32_t number_of_clusters )
{
uint32_t ms_sectors_per_cluster_limit_FAT12 =
c104: ebffd6d5 bl 1c60 <__aeabi_uidiv>
( MS_BYTES_PER_CLUSTER_LIMIT_FAT12 +1 ) / bytes_per_sector;
uint32_t ms_sectors_per_cluster_limit_FAT16 =
( MS_BYTES_PER_CLUSTER_LIMIT +1 ) / bytes_per_sector;
uint8_t fattype = FAT_FAT32;
if ( number_of_clusters < FAT_FAT12_MAX_CLN
c108: e59f3910 ldr r3, [pc, #2320] ; ca20 <msdos_format+0xdcc>
c10c: e1560000 cmp r6, r0
c110: 915a0003 cmpls sl, r3
c114: e59d4030 ldr r4, [sp, #48] ; 0x30
&& sectors_per_cluster <= ms_sectors_per_cluster_limit_FAT12 ) {
fattype = FAT_FAT12;
c118: 93a03001 movls r3, #1
( MS_BYTES_PER_CLUSTER_LIMIT_FAT12 +1 ) / bytes_per_sector;
uint32_t ms_sectors_per_cluster_limit_FAT16 =
( MS_BYTES_PER_CLUSTER_LIMIT +1 ) / bytes_per_sector;
uint8_t fattype = FAT_FAT32;
if ( number_of_clusters < FAT_FAT12_MAX_CLN
c11c: 9a000007 bls c140 <msdos_format+0x4ec>
const uint32_t sectors_per_cluster,
const uint32_t number_of_clusters )
{
uint32_t ms_sectors_per_cluster_limit_FAT12 =
( MS_BYTES_PER_CLUSTER_LIMIT_FAT12 +1 ) / bytes_per_sector;
uint32_t ms_sectors_per_cluster_limit_FAT16 =
c120: e59f08fc ldr r0, [pc, #2300] ; ca24 <msdos_format+0xdd0>
c124: e1a01007 mov r1, r7
c128: ebffd6cc bl 1c60 <__aeabi_uidiv>
( MS_BYTES_PER_CLUSTER_LIMIT +1 ) / bytes_per_sector;
uint8_t fattype = FAT_FAT32;
c12c: e59f38f4 ldr r3, [pc, #2292] ; ca28 <msdos_format+0xdd4>
c130: e1560000 cmp r6, r0
c134: 915a0003 cmpls sl, r3
c138: 93a03002 movls r3, #2
c13c: 83a03004 movhi r3, #4
fmt_params->fattype = msdos_get_fat_type(
fmt_params->bytes_per_sector,
fmt_params->sectors_per_cluster,
data_clusters_cnt );
/* Correct sectors per cluster to the fat type specific default value */
if (fat_type != fmt_params->fattype) {
c140: e1580003 cmp r8, r3
fmt_params->sectors_per_cluster = sectors_per_cluster_adj;
fat_type = fmt_params->fattype;
/* Correct the FAT type according to the new data cluster count */
if ( ret_val == 0 ) {
fmt_params->fattype = msdos_get_fat_type(
c144: e5cd3266 strb r3, [sp, #614] ; 0x266
fmt_params->bytes_per_sector,
fmt_params->sectors_per_cluster,
data_clusters_cnt );
/* Correct sectors per cluster to the fat type specific default value */
if (fat_type != fmt_params->fattype) {
c148: 0a000011 beq c194 <msdos_format+0x540>
static void
msdos_set_default_sectors_per_cluster_for_fattype(
msdos_format_param_t *fmt_params,
const uint64_t total_size )
{
if ( fmt_params->fattype == FAT_FAT12
c14c: e2433001 sub r3, r3, #1
c150: e3530001 cmp r3, #1
|| fmt_params->fattype == FAT_FAT16 ) {
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
c154: 93a03002 movls r3, #2
static void
msdos_set_default_sectors_per_cluster_for_fattype(
msdos_format_param_t *fmt_params,
const uint64_t total_size )
{
if ( fmt_params->fattype == FAT_FAT12
c158: 9a000008 bls c180 <msdos_format+0x52c>
c15c: e3a0301f mov r3, #31
#define ONE_GB ( 1024L * 1024L * 1024L )
uint32_t gigs = ( total_size + ONE_GB ) / ONE_GB;
int b;
/* scale with the size of disk... */
for ( b = 31; b > 0; b-- ) {
if ( (gigs & ( 1 << b) ) != 0 )
c160: e3a02001 mov r2, #1
c164: e59d1028 ldr r1, [sp, #40] ; 0x28
c168: e0111312 ands r1, r1, r2, lsl r3
c16c: 1a000001 bne c178 <msdos_format+0x524>
else {
#define ONE_GB ( 1024L * 1024L * 1024L )
uint32_t gigs = ( total_size + ONE_GB ) / ONE_GB;
int b;
/* scale with the size of disk... */
for ( b = 31; b > 0; b-- ) {
c170: e2533001 subs r3, r3, #1
c174: 1afffffa bne c164 <msdos_format+0x510>
if ( (gigs & ( 1 << b) ) != 0 )
break;
}
fmt_params->sectors_per_cluster = 1 << b;
c178: e3a02001 mov r2, #1
c17c: e1a03312 lsl r3, r2, r3
data_clusters_cnt );
/* Correct sectors per cluster to the fat type specific default value */
if (fat_type != fmt_params->fattype) {
msdos_set_default_sectors_per_cluster_for_fattype( fmt_params,
total_size );
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata,
c180: e1a00005 mov r0, r5
c184: e28d1f8d add r1, sp, #564 ; 0x234
/* 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;
c188: e58d3240 str r3, [sp, #576] ; 0x240
data_clusters_cnt );
/* Correct sectors per cluster to the fat type specific default value */
if (fat_type != fmt_params->fattype) {
msdos_set_default_sectors_per_cluster_for_fattype( fmt_params,
total_size );
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata,
c18c: ebfffe94 bl bbe4 <msdos_set_sectors_per_cluster_from_request>
c190: e1a04000 mov r4, r0
fmt_params );
}
}
if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {
c194: e5dd3266 ldrb r3, [sp, #614] ; 0x266
c198: e59d200c ldr r2, [sp, #12]
c19c: e1530008 cmp r3, r8
c1a0: 13520001 cmpne r2, #1
--fmt_params->totl_sector_cnt;
c1a4: 859d3238 ldrhi r3, [sp, #568] ; 0x238
}
}
++iteration_cnt;
c1a8: e59d000c ldr r0, [sp, #12]
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata,
fmt_params );
}
}
if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {
--fmt_params->totl_sector_cnt;
c1ac: 82433001 subhi r3, r3, #1
c1b0: 858d3238 strhi r3, [sp, #568] ; 0x238
}
}
++iteration_cnt;
c1b4: e2803001 add r3, r0, #1
c1b8: e20330ff and r3, r3, #255 ; 0xff
c1bc: e58d300c str r3, [sp, #12]
if (ret_val == 0) {
data_clusters_cnt =
fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
}
while( ret_val == 0
c1c0: e3540000 cmp r4, #0
c1c4: 1a000005 bne c1e0 <msdos_format+0x58c>
&& fmt_params->fattype != fat_type
c1c8: e5dd3266 ldrb r3, [sp, #614] ; 0x266
c1cc: e1530008 cmp r3, r8
c1d0: 0a000002 beq c1e0 <msdos_format+0x58c>
&& fmt_params->totl_sector_cnt > 0 ) {
c1d4: e59d3238 ldr r3, [sp, #568] ; 0x238
c1d8: e3530000 cmp r3, #0
c1dc: 1affff24 bne be74 <msdos_format+0x220>
c1e0: e59d6010 ldr r6, [sp, #16]
}
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
c1e4: e59d3238 ldr r3, [sp, #568] ; 0x238
c1e8: e3530000 cmp r3, #0
c1ec: 0a000029 beq c298 <msdos_format+0x644>
{
errno = EINVAL;
ret_val = -1;
}
if (0 == ret_val)
c1f0: e3540000 cmp r4, #0
c1f4: 1a00002e bne c2b4 <msdos_format+0x660>
{
if (FAT_FAT32 != fmt_params->fattype)
c1f8: e5dd3266 ldrb r3, [sp, #614] ; 0x266
c1fc: e3530004 cmp r3, #4
c200: 0a00000b beq c234 <msdos_format+0x5e0>
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
c204: e5dd1284 ldrb r1, [sp, #644] ; 0x284
if (0 == ret_val)
{
if (FAT_FAT32 != fmt_params->fattype)
{
fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
c208: e59d3250 ldr r3, [sp, #592] ; 0x250
c20c: e59d2240 ldr r2, [sp, #576] ; 0x240
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
c210: e3510000 cmp r1, #0
return (sectors + clustersize - 1) & ~(clustersize - 1);
c214: 00833002 addeq r3, r3, r2
c218: 02433001 subeq r3, r3, #1
c21c: 02622000 rsbeq r2, r2, #0
c220: 00033002 andeq r3, r3, r2
if (FAT_FAT32 != fmt_params->fattype)
{
fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
fmt_params->sectors_per_cluster,
fmt_params->skip_alignment)
* (fmt_params->bytes_per_sector / FAT_DIRENTRY_SIZE);
c224: e59d2234 ldr r2, [sp, #564] ; 0x234
c228: e1a022a2 lsr r2, r2, #5
c22c: e0030392 mul r3, r2, r3
if (0 == ret_val)
{
if (FAT_FAT32 != fmt_params->fattype)
{
fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
c230: e58d324c str r3, [sp, #588] ; 0x24c
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
c234: e5dd1284 ldrb r1, [sp, #644] ; 0x284
fmt_params->sectors_per_cluster,
fmt_params->skip_alignment)
* (fmt_params->bytes_per_sector / FAT_DIRENTRY_SIZE);
}
fmt_params->rsvd_sector_cnt = loc_align_object (fmt_params->rsvd_sector_cnt,
c238: e59d323c ldr r3, [sp, #572] ; 0x23c
c23c: e59d2240 ldr r2, [sp, #576] ; 0x240
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
c240: e3510000 cmp r1, #0
return (sectors + clustersize - 1) & ~(clustersize - 1);
c244: 00833002 addeq r3, r3, r2
c248: 02433001 subeq r3, r3, #1
c24c: 02622000 rsbeq r2, r2, #0
c250: 00033002 andeq r3, r3, r2
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
c254: e3550000 cmp r5, #0
fmt_params->sectors_per_cluster,
fmt_params->skip_alignment)
* (fmt_params->bytes_per_sector / FAT_DIRENTRY_SIZE);
}
fmt_params->rsvd_sector_cnt = loc_align_object (fmt_params->rsvd_sector_cnt,
c258: e58d323c str r3, [sp, #572] ; 0x23c
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
c25c: 0a000012 beq c2ac <msdos_format+0x658>
(rqdata->media != 0)) {
c260: e5d57014 ldrb r7, [r5, #20]
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
c264: e3570000 cmp r7, #0
c268: 0a00000f beq c2ac <msdos_format+0x658>
(rqdata->media != 0)) {
const char valid_media_codes[] =
c26c: e59f17b8 ldr r1, [pc, #1976] ; ca2c <msdos_format+0xdd8>
c270: e3a02009 mov r2, #9
c274: e28d0e2d add r0, sp, #720 ; 0x2d0
c278: eb003421 bl 19304 <memcpy>
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
c27c: e28d0e2d add r0, sp, #720 ; 0x2d0
c280: e1a01007 mov r1, r7
c284: e3a02009 mov r2, #9
c288: eb0033b0 bl 19150 <memchr>
c28c: e3500000 cmp r0, #0
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
}
else {
fmt_params->media_code = rqdata->media;
c290: 15cd7265 strbne r7, [sp, #613] ; 0x265
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,
c294: 1a000006 bne c2b4 <msdos_format+0x660>
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
c298: eb003172 bl 18868 <__errno>
c29c: e3a03016 mov r3, #22
c2a0: e5803000 str r3, [r0]
const char valid_media_codes[] =
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
c2a4: e3e04000 mvn r4, #0
c2a8: ea000001 b c2b4 <msdos_format+0x660>
else {
fmt_params->media_code = rqdata->media;
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
c2ac: e3e03007 mvn r3, #7
c2b0: e5cd3265 strb r3, [sp, #613] ; 0x265
c2b4: e59d323c ldr r3, [sp, #572] ; 0x23c
c2b8: e5dd2264 ldrb r2, [sp, #612] ; 0x264
c2bc: e59d1244 ldr r1, [sp, #580] ; 0x244
* for formatting
*/
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);
c2c0: e0233291 mla r3, r1, r2, r3
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
c2c4: e59d0250 ldr r0, [sp, #592] ; 0x250
c2c8: e3500000 cmp r0, #0
fmt_params->root_dir_start_sec =
c2cc: e58d3254 str r3, [sp, #596] ; 0x254
* 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;
c2d0: 059d3240 ldreq r3, [sp, #576] ; 0x240
*/
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;
c2d4: 158d0258 strne r0, [sp, #600] ; 0x258
* 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;
c2d8: 058d3258 streq r3, [sp, #600] ; 0x258
}
/*
* determine usable OEMName
*/
if (ret_val == 0) {
c2dc: e3540000 cmp r4, #0
c2e0: 1a000039 bne c3cc <msdos_format+0x778>
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
c2e4: e3550000 cmp r5, #0
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
c2e8: 059f3740 ldreq r3, [pc, #1856] ; ca30 <msdos_format+0xddc>
if ((rqdata != NULL) &&
c2ec: 0a000003 beq c300 <msdos_format+0x6ac>
(rqdata->OEMName != NULL)) {
c2f0: e5953000 ldr r3, [r5]
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
c2f4: e59f2734 ldr r2, [pc, #1844] ; ca30 <msdos_format+0xddc>
c2f8: e3530000 cmp r3, #0
c2fc: 01a03002 moveq r3, r2
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
c300: e59f272c ldr r2, [pc, #1836] ; ca34 <msdos_format+0xde0>
c304: e5928000 ldr r8, [r2]
/*
* determine usable OEMName
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
c308: e28d2f99 add r2, sp, #612 ; 0x264
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
c30c: e3a01009 mov r1, #9
/*
* determine usable OEMName
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
c310: e2822003 add r2, r2, #3
/* * non-printable character in given name, so keep stuck * at that character and replace all following characters * with a ' ' */ *to++=' ';
c314: e3a07020 mov r7, #32
}
*to = '\0';
c318: e3a0e000 mov lr, #0
c31c: ea00000a b c34c <msdos_format+0x6f8>
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
c320: e5d3c000 ldrb ip, [r3]
c324: e088000c add r0, r8, ip
c328: e5d00001 ldrb r0, [r0, #1]
c32c: e3100097 tst r0, #151 ; 0x97
c330: e2820001 add r0, r2, #1
*to++ = *from++;
c334: 15c2c000 strbne ip, [r2]
/* * non-printable character in given name, so keep stuck * at that character and replace all following characters * with a ' ' */ *to++=' ';
c338: 05c27000 strbeq r7, [r2]
}
*to = '\0';
c33c: e5c0e000 strb lr, [r0]
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
*to++ = *from++;
c340: 11a02000 movne r2, r0
c344: 12833001 addne r3, r3, #1
/* * non-printable character in given name, so keep stuck * at that character and replace all following characters * with a ' ' */ *to++=' ';
c348: 01a02000 moveq r2, r0
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
(rqdata->OEMName != NULL)) {
from = rqdata->OEMName;
}
for (cnt = 0;
c34c: e2511001 subs r1, r1, #1
c350: 1afffff2 bne c320 <msdos_format+0x6cc>
c354: ea000191 b c9a0 <msdos_format+0xd4c>
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
c358: e5953004 ldr r3, [r5, #4]
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) &&
c35c: e3530000 cmp r3, #0
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
c360: 13a02001 movne r2, #1
c364: 15cd227c strbne r2, [sp, #636] ; 0x27c
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) &&
c368: 1a000000 bne c370 <msdos_format+0x71c>
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
c36c: e59f36c4 ldr r3, [pc, #1732] ; ca38 <msdos_format+0xde4>
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
c370: e59f26bc ldr r2, [pc, #1724] ; ca34 <msdos_format+0xde0>
c374: e3a0100c mov r1, #12
c378: e5928000 ldr r8, [r2]
/* * non-printable character in given name, so keep stuck * at that character and replace all following characters * with a ' ' */ *to++=' ';
c37c: e3a07020 mov r7, #32
/*
* determine usable Volume Label
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
c380: e28d2e27 add r2, sp, #624 ; 0x270
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
c384: e3a0e000 mov lr, #0
c388: ea00000a b c3b8 <msdos_format+0x764>
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
c38c: e5d3c000 ldrb ip, [r3]
c390: e088000c add r0, r8, ip
c394: e5d00001 ldrb r0, [r0, #1]
c398: e3100097 tst r0, #151 ; 0x97
c39c: e2820001 add r0, r2, #1
*to++ = *from++;
c3a0: 15c2c000 strbne ip, [r2]
/* * non-printable character in given name, so keep stuck * at that character and replace all following characters * with a ' ' */ *to++=' ';
c3a4: 05c27000 strbeq r7, [r2]
}
*to = '\0';
c3a8: e5c0e000 strb lr, [r0]
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
*to++ = *from++;
c3ac: 11a02000 movne r2, r0
c3b0: 12833001 addne r3, r3, #1
/* * non-printable character in given name, so keep stuck * at that character and replace all following characters * with a ' ' */ *to++=' ';
c3b4: 01a02000 moveq r2, r0
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
c3b8: e2511001 subs r1, r1, #1
c3bc: 1afffff2 bne c38c <msdos_format+0x738>
c3c0: ea000179 b c9ac <msdos_format+0xd58>
rc = rtems_clock_get_tod_timeval(&time_value);
if (rc == RTEMS_SUCCESSFUL) {
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
}
else {
*volid_ptr = rand();
c3c4: eb00368b bl 19df8 <rand>
c3c8: e58d0280 str r0, [sp, #640] ; 0x280
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
(rqdata != NULL) &&
c3cc: e2958000 adds r8, r5, #0
c3d0: 13a08001 movne r8, #1
ret_val = msdos_format_determine_fmt_params(fd,rqdata,&fmt_params);
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
c3d4: e3540000 cmp r4, #0
c3d8: 13a03000 movne r3, #0
c3dc: 02083001 andeq r3, r8, #1
c3e0: e3530000 cmp r3, #0
c3e4: 0a00000b beq c418 <msdos_format+0x7c4>
(rqdata != NULL) &&
c3e8: e5d52015 ldrb r2, [r5, #21]
c3ec: e3520000 cmp r2, #0
c3f0: 1a00000a bne c420 <msdos_format+0x7cc>
!(rqdata->quick_format)) {
ret_val = msdos_format_fill_sectors
c3f4: e59d3234 ldr r3, [sp, #564] ; 0x234
c3f8: e58d3000 str r3, [sp]
c3fc: e3a030e5 mov r3, #229 ; 0xe5
c400: e58d3004 str r3, [sp, #4]
c404: e1a00005 mov r0, r5
c408: e1a01006 mov r1, r6
c40c: e59d3238 ldr r3, [sp, #568] ; 0x238
c410: ebfffda9 bl babc <msdos_format_fill_sectors>
c414: e1a04000 mov r4, r0
}
/*
* create master boot record
*/
if (ret_val == 0) {
c418: e3540000 cmp r4, #0
c41c: 1a000173 bne c9f0 <msdos_format+0xd9c>
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
c420: e1a00005 mov r0, r5
c424: e3a01002 mov r1, #2
c428: e59f260c ldr r2, [pc, #1548] ; ca3c <msdos_format+0xde8>
c42c: ebfffd77 bl ba10 <msdos_format_printf>
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
c430: e3a02000 mov r2, #0
c434: e1a00006 mov r0, r6
c438: e3a01000 mov r1, #0
c43c: e3a03000 mov r3, #0
/*
* 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,
c440: e59d4234 ldr r4, [sp, #564] ; 0x234
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
c444: eb00188a bl 12674 <lseek>
c448: e3500000 cmp r0, #0
c44c: e2d12000 sbcs r2, r1, #0
c450: ba000005 blt c46c <msdos_format+0x818>
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
c454: e1a00006 mov r0, r6
c458: e28d1034 add r1, sp, #52 ; 0x34
c45c: e1a02004 mov r2, r4
c460: eb001933 bl 12934 <read>
c464: e3500000 cmp r0, #0
c468: aa000157 bge c9cc <msdos_format+0xd78>
fmt_params.bytes_per_sector,
tmp_sec);
}
}
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
c46c: e3e04000 mvn r4, #0 <== NOT EXECUTED
c470: ea00015e b c9f0 <msdos_format+0xd9c> <== 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) {
c474: e1a07004 mov r7, r4
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
uint32_t total_sectors_num16 = 0;
c478: e3a04000 mov r4, #0
* 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);
c47c: e3a01000 mov r1, #0
c480: e59f25b8 ldr r2, [pc, #1464] ; ca40 <msdos_format+0xdec>
c484: e28d0034 add r0, sp, #52 ; 0x34
c488: eb0033d3 bl 193dc <memset>
memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
c48c: e3a0a000 mov sl, #0
c490: e28d3e23 add r3, sp, #560 ; 0x230
* with 0xEB,.... */ /* * fill OEMName */ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
c494: e28d2f8d add r2, sp, #564 ; 0x234
* 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,
c498: e28d0034 add r0, sp, #52 ; 0x34
* with 0xEB,.... */ /* * fill OEMName */ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
c49c: e2821033 add r1, r2, #51 ; 0x33
* 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,
c4a0: e1c3a0b2 strh sl, [r3, #2]
* with 0xEB,.... */ /* * fill OEMName */ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
c4a4: e3a02008 mov r2, #8
c4a8: e2800003 add r0, r0, #3
c4ac: eb003394 bl 19304 <memcpy>
fmt_params->OEMName, FAT_BR_OEMNAME_SIZE); FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
c4b0: e59d3234 ldr r3, [sp, #564] ; 0x234
c4b4: e5cd303f strb r3, [sp, #63] ; 0x3f
c4b8: e1a03423 lsr r3, r3, #8
c4bc: e5cd3040 strb r3, [sp, #64] ; 0x40
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
c4c0: e59d3240 ldr r3, [sp, #576] ; 0x240
c4c4: e5cd3041 strb r3, [sp, #65] ; 0x41
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
c4c8: e59d323c ldr r3, [sp, #572] ; 0x23c
c4cc: e5cd3042 strb r3, [sp, #66] ; 0x42
c4d0: e1a03423 lsr r3, r3, #8
c4d4: e5cd3043 strb r3, [sp, #67] ; 0x43
/* 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);
c4d8: e59d324c ldr r3, [sp, #588] ; 0x24c
c4dc: e5cd3045 strb r3, [sp, #69] ; 0x45
c4e0: e1a03423 lsr r3, r3, #8
c4e4: e5cd3046 strb r3, [sp, #70] ; 0x46
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16); FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
c4e8: e5dd3265 ldrb r3, [sp, #613] ; 0x265
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);
c4ec: e5cd4047 strb r4, [sp, #71] ; 0x47
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
c4f0: e5cd3049 strb r3, [sp, #73] ; 0x49
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);
c4f4: e1a04424 lsr r4, r4, #8
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
c4f8: e3e03000 mvn r3, #0
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);
c4fc: e5cd4048 strb r4, [sp, #72] ; 0x48
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
c500: e5cd304c strb r3, [sp, #76] ; 0x4c
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) {
c504: e5dd4266 ldrb r4, [sp, #614] ; 0x266
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... */
c508: e3a03006 mov r3, #6
c50c: e5cd304e strb r3, [sp, #78] ; 0x4e
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
c510: e1a03427 lsr r3, r7, #8
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 */
c514: e3a01002 mov r1, #2
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... */
c518: e3a02001 mov r2, #1
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
c51c: e5cd7054 strb r7, [sp, #84] ; 0x54
c520: e5cd3055 strb r3, [sp, #85] ; 0x55
if (fmt_params->fattype != FAT_FAT32) {
c524: e3540004 cmp r4, #4
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);
c528: e1a03827 lsr r3, r7, #16
c52c: e1a07c27 lsr r7, r7, #24
c530: e5cd3056 strb r3, [sp, #86] ; 0x56
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 */
c534: e5cd1044 strb r1, [sp, #68] ; 0x44
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... */
c538: e5cd2050 strb r2, [sp, #80] ; 0x50
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
c53c: e5cd7057 strb r7, [sp, #87] ; 0x57
c540: e59d3244 ldr r3, [sp, #580] ; 0x244
if (fmt_params->fattype != FAT_FAT32) {
c544: 0a000016 beq c5a4 <msdos_format+0x950>
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
c548: e5cd304a strb r3, [sp, #74] ; 0x4a
c54c: e1a03423 lsr r3, r3, #8
c550: e5cd304b strb r3, [sp, #75] ; 0x4b
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);
c554: e3a03029 mov r3, #41 ; 0x29
c558: e5cd305a strb r3, [sp, #90] ; 0x5a
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
c55c: e59d3280 ldr r3, [sp, #640] ; 0x280
c560: e1a02423 lsr r2, r3, #8
c564: e5cd205c strb r2, [sp, #92] ; 0x5c
c568: e1a02823 lsr r2, r3, #16
c56c: e5cd305b strb r3, [sp, #91] ; 0x5b
c570: e5cd205d strb r2, [sp, #93] ; 0x5d
c574: e1a03c23 lsr r3, r3, #24
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
c578: e28d1e27 add r1, sp, #624 ; 0x270
c57c: e28d005f add r0, sp, #95 ; 0x5f
c580: e3a0200b mov r2, #11
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 */
c584: e5cd305e strb r3, [sp, #94] ; 0x5e
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
c588: eb00335d bl 19304 <memcpy>
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
c58c: e59f34b0 ldr r3, [pc, #1200] ; ca44 <msdos_format+0xdf0>
c590: e3540001 cmp r4, #1
c594: e59f14ac ldr r1, [pc, #1196] ; ca48 <msdos_format+0xdf4>
c598: e28d006a add r0, sp, #106 ; 0x6a
c59c: 01a01003 moveq r1, r3
c5a0: ea000018 b c608 <msdos_format+0x9b4>
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
c5a4: e1a00423 lsr r0, r3, #8
c5a8: e5cd3058 strb r3, [sp, #88] ; 0x58
c5ac: e5cd0059 strb r0, [sp, #89] ; 0x59
c5b0: e1a00823 lsr r0, r3, #16
c5b4: e1a03c23 lsr r3, r3, #24
c5b8: e5cd305b strb r3, [sp, #91] ; 0x5b
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 */
c5bc: e59d325c ldr r3, [sp, #604] ; 0x25c
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
c5c0: e5cd005a strb r0, [sp, #90] ; 0x5a
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 */
c5c4: e5cd1060 strb r1, [sp, #96] ; 0x60
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
c5c8: e5cd2064 strb r2, [sp, #100] ; 0x64
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
c5cc: e5cd3066 strb r3, [sp, #102] ; 0x66
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
c5d0: e1a0100a mov r1, sl
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 */
c5d4: e1a03423 lsr r3, r3, #8
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
c5d8: e3a0200c mov r2, #12
c5dc: e28d0068 add r0, sp, #104 ; 0x68
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 */
c5e0: e5cd3067 strb r3, [sp, #103] ; 0x67
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
c5e4: eb00337c bl 193dc <memset>
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);
c5e8: e3a03029 mov r3, #41 ; 0x29
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
c5ec: e1a0100a mov r1, sl
c5f0: e28d007b add r0, sp, #123 ; 0x7b
c5f4: e3a0200b mov r2, #11
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);
c5f8: e5cd3076 strb r3, [sp, #118] ; 0x76
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
c5fc: eb003376 bl 193dc <memset>
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
c600: e59f1444 ldr r1, [pc, #1092] ; ca4c <msdos_format+0xdf8>
c604: e28d0086 add r0, sp, #134 ; 0x86
c608: e3a02008 mov r2, #8
c60c: eb00333c bl 19304 <memcpy>
FAT_BR_FILSYSTYPE_SIZE); } /* * add boot record signature */ FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
c610: e3a03055 mov r3, #85 ; 0x55
c614: e5cd3232 strb r3, [sp, #562] ; 0x232
c618: e3e03055 mvn r3, #85 ; 0x55
c61c: e5cd3233 strb r3, [sp, #563] ; 0x233
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
c620: e3e03014 mvn r3, #20
c624: e5cd3034 strb r3, [sp, #52] ; 0x34
FAT_SET_VAL8(mbr,1,0x3c);
c628: e3a0303c mov r3, #60 ; 0x3c
c62c: e5cd3035 strb r3, [sp, #53] ; 0x35
/*
* 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,
c630: e1a00005 mov r0, r5
/* * 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);
c634: e3e0306f mvn r3, #111 ; 0x6f
/*
* 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,
c638: e3a01002 mov r1, #2
c63c: e59f240c ldr r2, [pc, #1036] ; ca50 <msdos_format+0xdfc>
/* * 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);
c640: e5cd3036 strb r3, [sp, #54] ; 0x36
/*
* 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,
c644: ebfffcf1 bl ba10 <msdos_format_printf>
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
c648: e1a00006 mov r0, r6
c64c: e3a01000 mov r1, #0
c650: e59d2234 ldr r2, [sp, #564] ; 0x234
c654: e28d3034 add r3, sp, #52 ; 0x34
c658: ebfffd01 bl ba64 <msdos_format_write_sec>
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
c65c: e2504000 subs r4, r0, #0
c660: 1a0000e2 bne c9f0 <msdos_format+0xd9c>
c664: e59d325c ldr r3, [sp, #604] ; 0x25c
c668: e3530000 cmp r3, #0
c66c: 0a00000a beq c69c <msdos_format+0xa48>
(fmt_params.mbr_copy_sec != 0)) {
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
c670: e1a00005 mov r0, r5
c674: e3a01002 mov r1, #2
c678: e59f23d4 ldr r2, [pc, #980] ; ca54 <msdos_format+0xe00>
c67c: ebfffce3 bl ba10 <msdos_format_printf>
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
c680: e1a00006 mov r0, r6
c684: e59d125c ldr r1, [sp, #604] ; 0x25c
c688: e59d2234 ldr r2, [sp, #564] ; 0x234
c68c: e28d3034 add r3, sp, #52 ; 0x34
c690: ebfffcf3 bl ba64 <msdos_format_write_sec>
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
c694: e2504000 subs r4, r0, #0
c698: 1a0000d4 bne c9f0 <msdos_format+0xd9c>
(fmt_params.fsinfo_sec != 0)) {
c69c: e59d4260 ldr r4, [sp, #608] ; 0x260
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
c6a0: e3540000 cmp r4, #0
c6a4: 0a000023 beq c738 <msdos_format+0xae4>
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
c6a8: e3a01000 mov r1, #0
c6ac: e3a02c02 mov r2, #512 ; 0x200
c6b0: e28d0034 add r0, sp, #52 ; 0x34
c6b4: eb003348 bl 193dc <memset>
/* * write LEADSIG, STRUCTSIG, TRAILSIG */ FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
c6b8: e3a03052 mov r3, #82 ; 0x52
c6bc: e5cd3034 strb r3, [sp, #52] ; 0x34
c6c0: e5cd3035 strb r3, [sp, #53] ; 0x35
c6c4: e3a03061 mov r3, #97 ; 0x61
c6c8: e5cd3036 strb r3, [sp, #54] ; 0x36
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
c6cc: e5cd321b strb r3, [sp, #539] ; 0x21b
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
c6d0: e3a03055 mov r3, #85 ; 0x55
c6d4: e5cd3232 strb r3, [sp, #562] ; 0x232
c6d8: e3e03055 mvn r3, #85 ; 0x55
*/ memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE); /* * write LEADSIG, STRUCTSIG, TRAILSIG */ FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
c6dc: e3a02041 mov r2, #65 ; 0x41
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
c6e0: e3a01072 mov r1, #114 ; 0x72
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
c6e4: e5cd3233 strb r3, [sp, #563] ; 0x233
/* * write "empty" values for free cluster count and next cluster number */ FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
c6e8: e3e03000 mvn r3, #0
*/ memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE); /* * write LEADSIG, STRUCTSIG, TRAILSIG */ FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
c6ec: e5cd2037 strb r2, [sp, #55] ; 0x37
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
c6f0: e5cd1218 strb r1, [sp, #536] ; 0x218
c6f4: e5cd1219 strb r1, [sp, #537] ; 0x219
c6f8: e5cd221a strb r2, [sp, #538] ; 0x21a
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,
c6fc: e5cd321c strb r3, [sp, #540] ; 0x21c
c700: e5cd321d strb r3, [sp, #541] ; 0x21d
c704: e5cd321e strb r3, [sp, #542] ; 0x21e
c708: e5cd321f strb r3, [sp, #543] ; 0x21f
0xffffffff); FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
c70c: e5cd3220 strb r3, [sp, #544] ; 0x220
c710: e5cd3221 strb r3, [sp, #545] ; 0x221
c714: e5cd3222 strb r3, [sp, #546] ; 0x222
c718: e5cd3223 strb r3, [sp, #547] ; 0x223
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
c71c: e1a01004 mov r1, r4
c720: e1a00006 mov r0, r6
c724: e59d2234 ldr r2, [sp, #564] ; 0x234
c728: e28d3034 add r3, sp, #52 ; 0x34
c72c: ebfffccc bl ba64 <msdos_format_write_sec>
}
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
c730: e2504000 subs r4, r0, #0
c734: 1a0000ad bne c9f0 <msdos_format+0xd9c>
ret_val = msdos_format_fill_sectors
c738: e59d2234 ldr r2, [sp, #564] ; 0x234
(rqdata,
c73c: e5dd3264 ldrb r3, [sp, #612] ; 0x264
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
c740: e59dc244 ldr ip, [sp, #580] ; 0x244
c744: e58d2000 str r2, [sp]
c748: e3a02000 mov r2, #0
c74c: e58d2004 str r2, [sp, #4]
c750: e1a00005 mov r0, r5
c754: e1a01006 mov r1, r6
c758: e59d223c ldr r2, [sp, #572] ; 0x23c
c75c: e003039c mul r3, ip, r3
c760: ebfffcd5 bl babc <msdos_format_fill_sectors>
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
c764: e2504000 subs r4, r0, #0
c768: 1a0000a0 bne c9f0 <msdos_format+0xd9c>
ret_val = msdos_format_fill_sectors
c76c: e59d3234 ldr r3, [sp, #564] ; 0x234
c770: e88d0018 stm sp, {r3, r4}
c774: e28d2f95 add r2, sp, #596 ; 0x254
c778: e1a00005 mov r0, r5
c77c: e1a01006 mov r1, r6
c780: e892000c ldm r2, {r2, r3}
c784: ebfffccc bl babc <msdos_format_fill_sectors>
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
c788: e2504000 subs r4, r0, #0
c78c: 1a000097 bne c9f0 <msdos_format+0xd9c>
c790: e5dd327c ldrb r3, [sp, #636] ; 0x27c
c794: e3530000 cmp r3, #0
c798: 0a000013 beq c7ec <msdos_format+0xb98>
memset(tmp_sec,0,sizeof(tmp_sec));
c79c: e1a01004 mov r1, r4
c7a0: e3a02c02 mov r2, #512 ; 0x200
c7a4: e28d0034 add r0, sp, #52 ; 0x34
c7a8: eb00330b bl 193dc <memset>
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
c7ac: e28d2e27 add r2, sp, #624 ; 0x270
c7b0: e8920007 ldm r2, {r0, r1, r2}
c7b4: e28d3034 add r3, sp, #52 ; 0x34
c7b8: e8a30003 stmia r3!, {r0, r1}
c7bc: e0c320b2 strh r2, [r3], #2
c7c0: e1a02822 lsr r2, r2, #16
c7c4: e5c32000 strb r2, [r3]
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
c7c8: e3a03008 mov r3, #8
c7cc: e5cd303f strb r3, [sp, #63] ; 0x3f
ret_val = msdos_format_write_sec
c7d0: e1a00006 mov r0, r6
c7d4: e59d1254 ldr r1, [sp, #596] ; 0x254
c7d8: e59d2234 ldr r2, [sp, #564] ; 0x234
c7dc: e28d3034 add r3, sp, #52 ; 0x34
c7e0: ebfffc9f bl ba64 <msdos_format_write_sec>
/*
* 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) {
c7e4: e250a000 subs sl, r0, #0
c7e8: 1a00004f bne c92c <msdos_format+0xcd8>
uint32_t start_sector;
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
c7ec: e28d0034 add r0, sp, #52 ; 0x34
c7f0: e3a01000 mov r1, #0
c7f4: e3a02c02 mov r2, #512 ; 0x200
c7f8: eb0032f7 bl 193dc <memset>
switch(fmt_params.fattype) {
c7fc: e5dd3266 ldrb r3, [sp, #614] ; 0x266
c800: e3530002 cmp r3, #2
c804: 0a00000a beq c834 <msdos_format+0xbe0>
c808: e3530004 cmp r3, #4
c80c: 0a000010 beq c854 <msdos_format+0xc00>
c810: e3530001 cmp r3, #1
c814: 1a00001b bne c888 <msdos_format+0xc34>
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
c818: e5dd3265 ldrb r3, [sp, #613] ; 0x265
c81c: e5cd3034 strb r3, [sp, #52] ; 0x34
/* 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)));
c820: e3e03070 mvn r3, #112 ; 0x70
c824: e5cd3035 strb r3, [sp, #53] ; 0x35
/* MSBits of FAT entry 1: MSBits of EOC */
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
c828: e3e03000 mvn r3, #0
c82c: e5cd3036 strb r3, [sp, #54] ; 0x36
break;
c830: ea000018 b c898 <msdos_format+0xc44>
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
c834: e5dd3265 ldrb r3, [sp, #613] ; 0x265
FAT_SET_VAL8(tmp_sec,1,0xff);
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
c838: e3e02007 mvn r2, #7
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
break;
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
c83c: e5cd3034 strb r3, [sp, #52] ; 0x34
FAT_SET_VAL8(tmp_sec,1,0xff);
c840: e3e03000 mvn r3, #0
c844: e5cd3035 strb r3, [sp, #53] ; 0x35
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
c848: e5cd2036 strb r2, [sp, #54] ; 0x36
c84c: e5cd3037 strb r3, [sp, #55] ; 0x37
break;
c850: ea000010 b c898 <msdos_format+0xc44>
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
c854: e5dd3265 ldrb r3, [sp, #613] ; 0x265
c858: e5cd3034 strb r3, [sp, #52] ; 0x34
c85c: e3e03000 mvn r3, #0
c860: e5cd3035 strb r3, [sp, #53] ; 0x35
c864: e5cd3036 strb r3, [sp, #54] ; 0x36
c868: e5cd3037 strb r3, [sp, #55] ; 0x37
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
c86c: e3e02007 mvn r2, #7
c870: e5cd3039 strb r3, [sp, #57] ; 0x39
c874: e5cd303a strb r3, [sp, #58] ; 0x3a
c878: e3a0300f mov r3, #15
c87c: e5cd2038 strb r2, [sp, #56] ; 0x38
c880: e5cd303b strb r3, [sp, #59] ; 0x3b
break;
c884: ea000003 b c898 <msdos_format+0xc44>
default:
ret_val = -1;
errno = EINVAL;
c888: eb002ff6 bl 18868 <__errno> <== NOT EXECUTED
c88c: e3a03016 mov r3, #22 <== NOT EXECUTED
c890: e5803000 str r3, [r0] <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
c894: e3e04000 mvn r4, #0 <== NOT EXECUTED
errno = EINVAL;
}
if (fmt_params.fattype == FAT_FAT32) {
c898: e5dd3266 ldrb r3, [sp, #614] ; 0x266
c89c: e3530004 cmp r3, #4
c8a0: 1a000006 bne c8c0 <msdos_format+0xc6c>
/*
* 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);
c8a4: e3e03007 mvn r3, #7
c8a8: e5cd303c strb r3, [sp, #60] ; 0x3c
c8ac: e3e03000 mvn r3, #0
c8b0: e5cd303d strb r3, [sp, #61] ; 0x3d
c8b4: e5cd303e strb r3, [sp, #62] ; 0x3e
c8b8: e3a0300f mov r3, #15
c8bc: e5cd303f strb r3, [sp, #63] ; 0x3f
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
c8c0: e5dd2284 ldrb r2, [sp, #644] ; 0x284
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
c8c4: e59d723c ldr r7, [sp, #572] ; 0x23c
c8c8: e59d3240 ldr r3, [sp, #576] ; 0x240
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
c8cc: e3520000 cmp r2, #0
return (sectors + clustersize - 1) & ~(clustersize - 1);
c8d0: 00877003 addeq r7, r7, r3
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
c8d4: e1a0a004 mov sl, r4
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
c8d8: 02477001 subeq r7, r7, #1
c8dc: 02633000 rsbeq r3, r3, #0
c8e0: 00077003 andeq r7, r7, r3
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
c8e4: e3a04000 mov r4, #0
c8e8: e1a0000a mov r0, sl
c8ec: ea000006 b c90c <msdos_format+0xcb8>
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
c8f0: e59d1244 ldr r1, [sp, #580] ; 0x244
c8f4: e1a00006 mov r0, r6
c8f8: e0217194 mla r1, r4, r1, r7
c8fc: e59d2234 ldr r2, [sp, #564] ; 0x234
c900: e28d3034 add r3, sp, #52 ; 0x34
c904: ebfffc56 bl ba64 <msdos_format_write_sec>
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
c908: e2844001 add r4, r4, #1
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
c90c: e5dd2264 ldrb r2, [sp, #612] ; 0x264
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
c910: e2703001 rsbs r3, r0, #1
c914: 33a03000 movcc r3, #0
c918: e1540002 cmp r4, r2
c91c: a3a03000 movge r3, #0
c920: e3530000 cmp r3, #0
c924: 1afffff1 bne c8f0 <msdos_format+0xc9c>
c928: e1a0a000 mov sl, r0
fmt_params.bytes_per_sector,
tmp_sec);
}
}
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
c92c: e35a0000 cmp sl, #0
c930: 13a08000 movne r8, #0
c934: 02088001 andeq r8, r8, #1
c938: e3580000 cmp r8, #0
c93c: 0a000006 beq c95c <msdos_format+0xd08>
c940: e5d5a017 ldrb sl, [r5, #23]
c944: e35a0000 cmp sl, #0
c948: 0a000003 beq c95c <msdos_format+0xd08>
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
}
static inline int rtems_disk_fd_sync(int fd)
{
return ioctl(fd, RTEMS_BLKIO_SYNCDEV);
c94c: e1a00006 mov r0, r6
c950: e59f1100 ldr r1, [pc, #256] ; ca58 <msdos_format+0xe04>
c954: eb001728 bl 125fc <ioctl>
c958: e1a0a000 mov sl, r0
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
c95c: e3760001 cmn r6, #1
close(fd);
c960: 11a00006 movne r0, r6
c964: 1bffdd0a blne 3d94 <close>
}
return ret_val;
}
c968: e1a0000a mov r0, sl
c96c: e28ddfb7 add sp, sp, #732 ; 0x2dc
c970: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
uint64_t total_size = 0;
uint32_t data_clusters_cnt;
uint8_t iteration_cnt = 0;
uint8_t fat_type = UINT8_MAX;
memset(fmt_params,0,sizeof(*fmt_params));
c974: e1a01004 mov r1, r4
c978: e3a02054 mov r2, #84 ; 0x54
c97c: e28d0f8d add r0, sp, #564 ; 0x234
c980: eb003295 bl 193dc <memset>
static inline int rtems_disk_fd_get_media_block_size(
int fd,
uint32_t *media_block_size
)
{
return ioctl(fd, RTEMS_BLKIO_GETMEDIABLKSIZE, media_block_size);
c984: e1a00006 mov r0, r6
c988: e59f10cc ldr r1, [pc, #204] ; ca5c <msdos_format+0xe08>
c98c: e28d2f8d add r2, sp, #564 ; 0x234
c990: eb001719 bl 125fc <ioctl>
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
ret_val = rtems_disk_fd_get_media_block_size(fd, &fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
c994: e2504000 subs r4, r0, #0
c998: 1afffe11 bne c1e4 <msdos_format+0x590>
c99c: eafffcd7 b bd00 <msdos_format+0xac>
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) &&
c9a0: e3550000 cmp r5, #0
c9a4: 1afffe6b bne c358 <msdos_format+0x704>
c9a8: eafffe6f b c36c <msdos_format+0x718>
{
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
c9ac: e28d0e2d add r0, sp, #720 ; 0x2d0
c9b0: eb001ac6 bl 134d0 <rtems_clock_get_tod_timeval>
if (rc == RTEMS_SUCCESSFUL) {
c9b4: e3500000 cmp r0, #0
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
c9b8: 059d32d0 ldreq r3, [sp, #720] ; 0x2d0
c9bc: 01a03083 lsleq r3, r3, #1
c9c0: 058d3280 streq r3, [sp, #640] ; 0x280
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
if (rc == RTEMS_SUCCESSFUL) {
c9c4: 0afffe80 beq c3cc <msdos_format+0x778>
c9c8: eafffe7d b c3c4 <msdos_format+0x770>
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,
c9cc: e1a00005 mov r0, r5
c9d0: e3a01002 mov r1, #2
c9d4: e59f2084 ldr r2, [pc, #132] ; ca60 <msdos_format+0xe0c>
c9d8: ebfffc0c bl ba10 <msdos_format_printf>
{
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) {
c9dc: e59d4238 ldr r4, [sp, #568] ; 0x238
c9e0: e3540801 cmp r4, #65536 ; 0x10000
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
uint32_t total_sectors_num16 = 0;
uint32_t total_sectors_num32 = 0;
c9e4: 33a07000 movcc r7, #0
/* store total sector count in either 16 or 32 bit field in mbr */
if (fmt_params->totl_sector_cnt < 0x10000) {
c9e8: 3afffea3 bcc c47c <msdos_format+0x828>
c9ec: eafffea0 b c474 <msdos_format+0x820>
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
c9f0: e1a0a004 mov sl, r4
c9f4: eaffffcc b c92c <msdos_format+0xcd8>
0000babc <msdos_format_fill_sectors>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
babc: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
bac0: e1a06000 mov r6, r0
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
bac4: e59d0028 ldr r0, [sp, #40] ; 0x28
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
bac8: e58d1000 str r1, [sp]
bacc: e1a05002 mov r5, r2
bad0: e1a08003 mov r8, r3
bad4: e5dd402c ldrb r4, [sp, #44] ; 0x2c
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
bad8: ebffe284 bl 44f0 <malloc>
if (fill_buffer == NULL) {
badc: e250b000 subs fp, r0, #0
bae0: 1a000004 bne baf8 <msdos_format_fill_sectors+0x3c>
errno = ENOMEM;
bae4: eb00335f bl 18868 <__errno> <== NOT EXECUTED
bae8: e3a0300c mov r3, #12 <== NOT EXECUTED
baec: e5803000 str r3, [r0] <== NOT EXECUTED
ret_val = -1;
baf0: e3e04000 mvn r4, #0 <== NOT EXECUTED
baf4: ea000003 b bb08 <msdos_format_fill_sectors+0x4c> <== NOT EXECUTED
}
else {
memset(fill_buffer,fill_byte,sector_size);
baf8: e1a01004 mov r1, r4
bafc: e59d2028 ldr r2, [sp, #40] ; 0x28
bb00: eb003635 bl 193dc <memset>
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
bb04: e3a04000 mov r4, #0
else {
memset(fill_buffer,fill_byte,sector_size);
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
bb08: e1a00006 mov r0, r6
bb0c: e3a01002 mov r1, #2
bb10: e59f20bc ldr r2, [pc, #188] ; bbd4 <msdos_format_fill_sectors+0x118>
bb14: e3a07064 mov r7, #100 ; 0x64
bb18: ebffffbc bl ba10 <msdos_format_printf>
bb1c: e0070798 mul r7, r8, r7
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
bb20: e1a0a008 mov sl, r8
\*=========================================================================*/
{
int ret_val = 0;
char *fill_buffer = NULL;
uint32_t total_sectors = sector_cnt;
int last_percent = -1;
bb24: e3e09000 mvn r9, #0
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
bb28: ea000014 b bb80 <msdos_format_fill_sectors+0xc4>
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
bb2c: e1a00007 mov r0, r7
bb30: e1a01008 mov r1, r8
bb34: ebffd849 bl 1c60 <__aeabi_uidiv>
if (percent != last_percent) {
bb38: e1500009 cmp r0, r9
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
bb3c: e1a04000 mov r4, r0
if (percent != last_percent) {
bb40: 0a000005 beq bb5c <msdos_format_fill_sectors+0xa0>
if ((percent & 1) == 0)
bb44: e3100001 tst r0, #1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
bb48: 01a00006 moveq r0, r6
bb4c: 03a01002 moveq r1, #2
bb50: 059f2080 ldreq r2, [pc, #128] ; bbd8 <msdos_format_fill_sectors+0x11c>
bb54: 0bffffad bleq ba10 <msdos_format_printf>
*/
while ((ret_val == 0) &&
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
if (percent != last_percent) {
if ((percent & 1) == 0)
bb58: e1a09004 mov r9, r4
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);
bb5c: e1a01005 mov r1, r5
bb60: e59d0000 ldr r0, [sp]
bb64: e59d2028 ldr r2, [sp, #40] ; 0x28
bb68: e1a0300b mov r3, fp
bb6c: ebffffbc bl ba64 <msdos_format_write_sec>
start_sector++;
bb70: e2855001 add r5, r5, #1
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);
bb74: e1a04000 mov r4, r0
start_sector++;
sector_cnt--;
bb78: e24aa001 sub sl, sl, #1
bb7c: e2477064 sub r7, r7, #100 ; 0x64
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
bb80: e29a3000 adds r3, sl, #0
bb84: 13a03001 movne r3, #1
bb88: e3540000 cmp r4, #0
bb8c: 13a03000 movne r3, #0
bb90: e3530000 cmp r3, #0
bb94: 1affffe4 bne bb2c <msdos_format_fill_sectors+0x70>
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");
bb98: e1a00006 mov r0, r6
bb9c: e3a01002 mov r1, #2
bba0: e59f2034 ldr r2, [pc, #52] ; bbdc <msdos_format_fill_sectors+0x120>
bba4: ebffff99 bl ba10 <msdos_format_printf>
if (ret_val)
bba8: e3540000 cmp r4, #0
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
bbac: 11a00006 movne r0, r6
bbb0: 13a01001 movne r1, #1
bbb4: 159f2024 ldrne r2, [pc, #36] ; bbe0 <msdos_format_fill_sectors+0x124>
bbb8: 11a03005 movne r3, r5
bbbc: 1bffff93 blne ba10 <msdos_format_printf>
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
bbc0: e35b0000 cmp fp, #0
free(fill_buffer);
bbc4: 11a0000b movne r0, fp
bbc8: 1bffe113 blne 401c <free>
fill_buffer = NULL;
}
return ret_val;
}
bbcc: e1a00004 mov r0, r4
bbd0: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000ba10 <msdos_format_printf>:
*/
static void
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
ba10: e92d000c push {r2, r3}
ba14: e92d4011 push {r0, r4, lr}
va_list args; va_start (args, format); if (rqdata != NULL && rqdata->info_level >= info_level)
ba18: e3500000 cmp r0, #0
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
va_list args;
va_start (args, format);
ba1c: e28d2010 add r2, sp, #16
ba20: e58d2000 str r2, [sp]
if (rqdata != NULL && rqdata->info_level >= info_level)
ba24: 0a00000a beq ba54 <msdos_format_printf+0x44>
ba28: e5903018 ldr r3, [r0, #24]
ba2c: e1530001 cmp r3, r1
ba30: ba000007 blt ba54 <msdos_format_printf+0x44>
{
vfprintf (stdout, format, args);
ba34: e59f4024 ldr r4, [pc, #36] ; ba60 <msdos_format_printf+0x50><== NOT EXECUTED
ba38: e5943000 ldr r3, [r4] <== NOT EXECUTED
ba3c: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED
ba40: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
ba44: eb0056e3 bl 215d8 <vfprintf> <== NOT EXECUTED
fflush (stdout);
ba48: e5943000 ldr r3, [r4] <== NOT EXECUTED
ba4c: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
ba50: eb003481 bl 18c5c <fflush> <== NOT EXECUTED
} va_end (args); }
ba54: e8bd4018 pop {r3, r4, lr}
ba58: e28dd008 add sp, sp, #8
ba5c: e12fff1e bx lr
0000ba64 <msdos_format_write_sec>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ba64: e92d41f0 push {r4, r5, r6, r7, r8, lr}
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ba68: e0887291 umull r7, r8, r1, r2
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ba6c: e1a04002 mov r4, r2
ba70: e1a05003 mov r5, r3
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ba74: e1a02008 mov r2, r8
ba78: e1a01007 mov r1, r7
ba7c: e3a03000 mov r3, #0
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ba80: e1a06000 mov r6, r0
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ba84: eb001afa bl 12674 <lseek>
ba88: e3500000 cmp r0, #0
ba8c: e2d18000 sbcs r8, r1, #0
ba90: ba000007 blt bab4 <msdos_format_write_sec+0x50>
ret_val = -1;
}
if (ret_val == 0) {
if (0 > write(fd,buffer,sector_size)) {
ba94: e1a00006 mov r0, r6
ba98: e1a01005 mov r1, r5
ba9c: e1a02004 mov r2, r4
baa0: ebffefc3 bl 79b4 <write>
baa4: e3500000 cmp r0, #0
baa8: b3e00000 mvnlt r0, #0
baac: a3a00000 movge r0, #0
bab0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
bab4: e3e00000 mvn r0, #0 <== NOT EXECUTED
ret_val = -1;
}
}
return ret_val;
}
bab8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00016494 <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
)
{
16494: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
16498: e5905008 ldr r5, [r0, #8]
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
1649c: e24dd058 sub sp, sp, #88 ; 0x58 164a0: e1a06002 mov r6, r2 164a4: e58d3010 str r3, [sp, #16]
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
164a8: e28d2058 add r2, sp, #88 ; 0x58 164ac: e3a03000 mov r3, #0
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
164b0: e1a09000 mov r9, r0 164b4: e1a07001 mov r7, r1
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
164b8: e5223004 str r3, [r2, #-4]!
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
164bc: e1a00005 mov r0, r5 164c0: e1a01006 mov r1, r6 164c4: ebffe70f bl 10108 <fat_file_open>
if (rc != RC_OK)
164c8: e2504000 subs r4, r0, #0
164cc: 1a00006d bne 16688 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1f4>
return rc;
fat_fd->cln = cln;
164d0: e59d1054 ldr r1, [sp, #84] ; 0x54
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
164d4: e3a03602 mov r3, #2097152 ; 0x200000
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
fat_fd->fat_file_type = FAT_DIRECTORY;
164d8: e5814010 str r4, [r1, #16]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
164dc: e5814034 str r4, [r1, #52] ; 0x34
*/
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
164e0: e581701c str r7, [r1, #28]
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
164e4: e5813014 str r3, [r1, #20]
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
164e8: e5817038 str r7, [r1, #56] ; 0x38
rc = fat_file_size(&fs_info->fat, fat_fd);
164ec: e1a00005 mov r0, r5 164f0: ebffe978 bl 10ad8 <fat_file_size>
if (rc != RC_OK)
164f4: e2504000 subs r4, r0, #0
164f8: 1a000050 bne 16640 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1ac>
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
164fc: e28d7014 add r7, sp, #20 16500: e1a01004 mov r1, r4 16504: e3a02020 mov r2, #32 16508: e1a00007 mov r0, r7 1650c: eb000bb2 bl 193dc <memset>
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
16510: e3a01001 mov r1, #1 16514: e1a02007 mov r2, r7 16518: e3a0300b mov r3, #11 1651c: e59f0170 ldr r0, [pc, #368] ; 16694 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x200> 16520: ebfffbe4 bl 154b8 <msdos_long_to_short>
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
16524: e3a0a001 mov sl, #1 16528: e1a02004 mov r2, r4 1652c: e1a00009 mov r0, r9 16530: e59d1054 ldr r1, [sp, #84] ; 0x54 16534: e59f3158 ldr r3, [pc, #344] ; 16694 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x200> 16538: e58da000 str sl, [sp] 1653c: e58da004 str sl, [sp, #4] 16540: e58d6008 str r6, [sp, #8] 16544: e58d700c str r7, [sp, #12] 16548: ebfffd4e bl 15a88 <msdos_find_name_in_fat_file>
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
1654c: e2504000 subs r4, r0, #0
16550: 1a00003a bne 16640 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1ac>
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
16554: e28d8034 add r8, sp, #52 ; 0x34 16558: e1a01004 mov r1, r4 1655c: e3a02020 mov r2, #32 16560: e1a00008 mov r0, r8 16564: eb000b9c bl 193dc <memset>
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
16568: e3a01002 mov r1, #2 1656c: e1a02008 mov r2, r8 16570: e3a0300b mov r3, #11 16574: e59f011c ldr r0, [pc, #284] ; 16698 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x204> 16578: ebfffbce bl 154b8 <msdos_long_to_short>
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
1657c: e3a03002 mov r3, #2
16580: e88d0408 stm sp, {r3, sl}
16584: e1a02004 mov r2, r4
16588: e1a00009 mov r0, r9
1658c: e59d1054 ldr r1, [sp, #84] ; 0x54
16590: e59f3100 ldr r3, [pc, #256] ; 16698 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x204>
16594: e58d6008 str r6, [sp, #8]
16598: e58d800c str r8, [sp, #12]
1659c: ebfffd39 bl 15a88 <msdos_find_name_in_fat_file>
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
165a0: e2504000 subs r4, r0, #0
165a4: 1a000025 bne 16640 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1ac>
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(&fs_info->fat, fat_fd);
165a8: e1a00005 mov r0, r5 165ac: e59d1054 ldr r1, [sp, #84] ; 0x54
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
165b0: e1d7b1ba ldrh fp, [r7, #26] 165b4: e1d771b4 ldrh r7, [r7, #20]
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(&fs_info->fat, fat_fd);
165b8: ebffe7cc bl 104f0 <fat_file_close>
if ( rc != RC_OK )
165bc: e2504000 subs r4, r0, #0
165c0: 1a000030 bne 16688 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1f4>
return rc;
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
165c4: e1d821b4 ldrh r2, [r8, #20] 165c8: e1d831ba ldrh r3, [r8, #26] 165cc: e1933802 orrs r3, r3, r2, lsl #16
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
165d0: 05863004 streq r3, [r6, #4]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
165d4: 03e03000 mvneq r3, #0 165d8: 05863008 streq r3, [r6, #8]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
165dc: 0586300c streq r3, [r6, #12]
/*
* 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;
165e0: 0586a000 streq sl, [r6]
}
/* open fat-file corresponded to second ".." */
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
165e4: e1a00005 mov r0, r5 165e8: e1a01006 mov r1, r6 165ec: e28d2054 add r2, sp, #84 ; 0x54 165f0: ebffe6c4 bl 10108 <fat_file_open>
if (rc != RC_OK)
165f4: e2504000 subs r4, r0, #0
165f8: 1a000022 bne 16688 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1f4>
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
165fc: e1dd24b8 ldrh r2, [sp, #72] ; 0x48 16600: e1dd34be ldrh r3, [sp, #78] ; 0x4e 16604: e1933802 orrs r3, r3, r2, lsl #16
fat_fd->cln = fs_info->fat.vol.rdir_cl;
16608: 0595303c ldreq r3, [r5, #60] ; 0x3c 1660c: e59d1054 ldr r1, [sp, #84] ; 0x54
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
16610: e581301c str r3, [r1, #28]
fat_fd->fat_file_type = FAT_DIRECTORY;
16614: e3a03000 mov r3, #0 16618: e5813010 str r3, [r1, #16]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
1661c: e5813034 str r3, [r1, #52] ; 0x34
fat_fd->map.disk_cln = fat_fd->cln;
16620: e591301c ldr r3, [r1, #28]
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;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
16624: e3a02602 mov r2, #2097152 ; 0x200000 16628: e5812014 str r2, [r1, #20]
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
1662c: e5813038 str r3, [r1, #56] ; 0x38
rc = fat_file_size(&fs_info->fat, fat_fd);
16630: e1a00005 mov r0, r5 16634: ebffe927 bl 10ad8 <fat_file_size>
if (rc != RC_OK)
16638: e2504000 subs r4, r0, #0
1663c: 0a000002 beq 1664c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1b8>
{
fat_file_close(&fs_info->fat, fat_fd);
16640: e1a00005 mov r0, r5 <== NOT EXECUTED 16644: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED 16648: ea00000a b 16678 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1e4><== NOT EXECUTED
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,
1664c: e59d3010 ldr r3, [sp, #16] 16650: e59d1054 ldr r1, [sp, #84] ; 0x54 16654: e58d3000 str r3, [sp] 16658: e1a00009 mov r0, r9 1665c: e18b2807 orr r2, fp, r7, lsl #16 16660: e1a03006 mov r3, r6 16664: ebffff36 bl 16344 <msdos_find_node_by_cluster_num_in_fat_file>
dir_pos, dir_entry);
if (rc != RC_OK)
16668: e2504000 subs r4, r0, #0
{
fat_file_close(&fs_info->fat, fat_fd);
1666c: e59d1054 ldr r1, [sp, #84] ; 0x54 16670: e1a00005 mov r0, r5
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
dir_pos, dir_entry);
if (rc != RC_OK)
16674: 0a000001 beq 16680 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1ec>
{
fat_file_close(&fs_info->fat, fat_fd);
16678: ebffe79c bl 104f0 <fat_file_close> <== NOT EXECUTED
return rc;
1667c: ea000001 b 16688 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1f4><== NOT EXECUTED
}
rc = fat_file_close(&fs_info->fat, fat_fd);
16680: ebffe79a bl 104f0 <fat_file_close> 16684: e1a04000 mov r4, r0
return rc;
}
16688: e1a00004 mov r0, r4
1668c: e28dd058 add sp, sp, #88 ; 0x58
16690: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000cad8 <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
)
{
cad8: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
cadc: e1a06000 mov r6, r0
cae0: e24dd018 sub sp, sp, #24
cae4: e1a08001 mov r8, r1
cae8: e1a07003 mov r7, r3
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));
caec: e3a00001 mov r0, #1
)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
caf0: e3a03000 mov r3, #0
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
caf4: e3a010a4 mov r1, #164 ; 0xa4
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
)
{
caf8: e1a0a002 mov sl, r2
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
cafc: e58d3014 str r3, [sp, #20]
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
cb00: ebffdc91 bl 3d4c <calloc>
if (!fs_info)
cb04: e2504000 subs r4, r0, #0
cb08: 0a000041 beq cc14 <msdos_initialize_support+0x13c>
rtems_set_errno_and_return_minus_one(ENOMEM);
temp_mt_entry->fs_info = fs_info;
cb0c: e5864008 str r4, [r6, #8]
rc = fat_init_volume_info(&fs_info->fat, temp_mt_entry->dev);
cb10: e5961038 ldr r1, [r6, #56] ; 0x38
cb14: eb001183 bl 11128 <fat_init_volume_info>
if (rc != RC_OK)
cb18: e2505000 subs r5, r0, #0
cb1c: 1a00000f bne cb60 <msdos_initialize_support+0x88>
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
cb20: e3e03000 mvn r3, #0
cb24: e58d300c str r3, [sp, #12]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
cb28: e58d3010 str r3, [sp, #16]
/*
* 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;
cb2c: e28d1018 add r1, sp, #24
cb30: e3a03001 mov r3, #1
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
cb34: e584a098 str sl, [r4, #152] ; 0x98
fs_info->directory_handlers = directory_handlers;
cb38: e5847094 str r7, [r4, #148] ; 0x94
/*
* 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;
cb3c: e5213014 str r3, [r1, #-20]!
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
cb40: e1a00004 mov r0, r4
cb44: e28d2014 add r2, sp, #20
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
cb48: e58d5008 str r5, [sp, #8]
cb4c: eb000d6d bl 10108 <fat_file_open>
if (rc != RC_OK)
cb50: e2505000 subs r5, r0, #0
cb54: 0a000004 beq cb6c <msdos_initialize_support+0x94>
{
fat_shutdown_drive(&fs_info->fat);
cb58: e1a00004 mov r0, r4 <== NOT EXECUTED
cb5c: eb001345 bl 11878 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
cb60: e1a00004 mov r0, r4 <== NOT EXECUTED
cb64: ebffdd2c bl 401c <free> <== NOT EXECUTED
return rc;
cb68: ea000048 b cc90 <msdos_initialize_support+0x1b8> <== NOT EXECUTED
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
cb6c: e59d1014 ldr r1, [sp, #20]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
cb70: e3a03602 mov r3, #2097152 ; 0x200000
cb74: e5813014 str r3, [r1, #20]
fat_fd->cln = fs_info->fat.vol.rdir_cl;
cb78: e594303c ldr r3, [r4, #60] ; 0x3c
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
cb7c: e3530000 cmp r3, #0
free(fs_info);
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
cb80: e5815010 str r5, [r1, #16]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->cln = fs_info->fat.vol.rdir_cl;
cb84: e581301c str r3, [r1, #28]
fat_fd->map.file_cln = 0;
cb88: e5815034 str r5, [r1, #52] ; 0x34
fat_fd->map.disk_cln = fat_fd->cln;
cb8c: e5813038 str r3, [r1, #56] ; 0x38
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
cb90: 1a000005 bne cbac <msdos_initialize_support+0xd4>
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
cb94: e594302c ldr r3, [r4, #44] ; 0x2c
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
fs_info->fat.vol.bpc :
cb98: e1d400b6 ldrh r0, [r4, #6]
fat_fd->map.disk_cln = fat_fd->cln;
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
cb9c: e5813018 str r3, [r1, #24]
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
cba0: e1500003 cmp r0, r3
cba4: 31a00003 movcc r0, r3
cba8: ea00000d b cbe4 <msdos_initialize_support+0x10c>
fs_info->fat.vol.bpc :
fs_info->fat.vol.rdir_size;
}
else
{
rc = fat_file_size(&fs_info->fat, fat_fd);
cbac: e1a00004 mov r0, r4
cbb0: eb000fc8 bl 10ad8 <fat_file_size>
if ( rc != RC_OK )
cbb4: e250a000 subs sl, r0, #0
fat_file_close(&fs_info->fat, fat_fd);
fat_shutdown_drive(&fs_info->fat);
free(fs_info);
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
cbb8: 01d400b6 ldrheq r0, [r4, #6]
fs_info->fat.vol.rdir_size;
}
else
{
rc = fat_file_size(&fs_info->fat, fat_fd);
if ( rc != RC_OK )
cbbc: 0a000008 beq cbe4 <msdos_initialize_support+0x10c>
{
fat_file_close(&fs_info->fat, fat_fd);
cbc0: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED
cbc4: e1a00004 mov r0, r4 <== NOT EXECUTED
cbc8: eb000e48 bl 104f0 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
cbcc: e1a00004 mov r0, r4 <== NOT EXECUTED
cbd0: eb001328 bl 11878 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
cbd4: e1a00004 mov r0, r4 <== NOT EXECUTED
cbd8: ebffdd0f bl 401c <free> <== NOT EXECUTED
return rc;
cbdc: e1a0500a mov r5, sl <== NOT EXECUTED
cbe0: ea00002a b cc90 <msdos_initialize_support+0x1b8> <== NOT EXECUTED
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
cbe4: e3a01001 mov r1, #1
cbe8: ebffdc57 bl 3d4c <calloc>
if (fs_info->cl_buf == NULL)
cbec: e3500000 cmp r0, #0
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
cbf0: e58400a0 str r0, [r4, #160] ; 0xa0
if (fs_info->cl_buf == NULL)
cbf4: 1a00000b bne cc28 <msdos_initialize_support+0x150>
{
fat_file_close(&fs_info->fat, fat_fd);
cbf8: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED
cbfc: e1a00004 mov r0, r4 <== NOT EXECUTED
cc00: eb000e3a bl 104f0 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
cc04: e1a00004 mov r0, r4 <== NOT EXECUTED
cc08: eb00131a bl 11878 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
cc0c: e1a00004 mov r0, r4 <== NOT EXECUTED
cc10: ebffdd01 bl 401c <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
cc14: eb002f13 bl 18868 <__errno> <== NOT EXECUTED
cc18: e3a0300c mov r3, #12 <== NOT EXECUTED
cc1c: e5803000 str r3, [r0] <== NOT EXECUTED
cc20: e3e05000 mvn r5, #0 <== NOT EXECUTED
cc24: ea000019 b cc90 <msdos_initialize_support+0x1b8> <== NOT EXECUTED
}
sc = rtems_semaphore_create(3,
cc28: e284309c add r3, r4, #156 ; 0x9c
cc2c: e58d3000 str r3, [sp]
cc30: e3a00003 mov r0, #3
cc34: e3a01001 mov r1, #1
cc38: e3a02010 mov r2, #16
cc3c: e3a03000 mov r3, #0
cc40: ebffec7f bl 7e44 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
cc44: e3500000 cmp r0, #0
cc48: 0a00000b beq cc7c <msdos_initialize_support+0x1a4>
{
fat_file_close(&fs_info->fat, fat_fd);
cc4c: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED
cc50: e1a00004 mov r0, r4 <== NOT EXECUTED
cc54: eb000e25 bl 104f0 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
cc58: e1a00004 mov r0, r4 <== NOT EXECUTED
cc5c: eb001305 bl 11878 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info->cl_buf);
cc60: e59400a0 ldr r0, [r4, #160] ; 0xa0 <== NOT EXECUTED
cc64: ebffdcec bl 401c <free> <== NOT EXECUTED
free(fs_info);
cc68: e1a00004 mov r0, r4 <== NOT EXECUTED
cc6c: ebffdcea bl 401c <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
cc70: eb002efc bl 18868 <__errno> <== NOT EXECUTED
cc74: e3a03005 mov r3, #5 <== NOT EXECUTED
cc78: eaffffe7 b cc1c <msdos_initialize_support+0x144> <== NOT EXECUTED
}
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
cc7c: e5963024 ldr r3, [r6, #36] ; 0x24
cc80: e59d2014 ldr r2, [sp, #20]
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
cc84: e5837010 str r7, [r3, #16]
free(fs_info->cl_buf);
free(fs_info);
rtems_set_errno_and_return_minus_one( EIO );
}
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
cc88: e5832008 str r2, [r3, #8]
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
temp_mt_entry->ops = op_table;
cc8c: e586800c str r8, [r6, #12]
return rc;
}
cc90: e1a00005 mov r0, r5
cc94: e28dd018 add sp, sp, #24
cc98: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
0000caac <msdos_lock>:
void msdos_lock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
msdos_fs_info_t *fs_info = mt_entry->fs_info;
rtems_status_code sc = rtems_semaphore_obtain(
fs_info->vol_sema,
caac: e5903008 ldr r3, [r0, #8]
};
void msdos_lock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
msdos_fs_info_t *fs_info = mt_entry->fs_info;
rtems_status_code sc = rtems_semaphore_obtain(
cab0: e3a01000 mov r1, #0
.rename_h = msdos_rename,
.statvfs_h = rtems_filesystem_default_statvfs
};
void msdos_lock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
cab4: e52de004 push {lr} ; (str lr, [sp, #-4]!)
msdos_fs_info_t *fs_info = mt_entry->fs_info; rtems_status_code sc = rtems_semaphore_obtain(
cab8: e593009c ldr r0, [r3, #156] ; 0x9c
cabc: e1a02001 mov r2, r1
cac0: ebffed6e bl 8080 <rtems_semaphore_obtain>
fs_info->vol_sema,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if (sc != RTEMS_SUCCESSFUL) {
cac4: e3500000 cmp r0, #0
cac8: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_fatal_error_occurred(0xdeadbeef);
cacc: e59f0000 ldr r0, [pc] ; cad4 <msdos_lock+0x28> <== NOT EXECUTED
cad0: ebffef42 bl 87e0 <rtems_fatal_error_occurred> <== NOT EXECUTED
000154b8 <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)
{
154b8: e92d4ff3 push {r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr}
154bc: e1a05000 mov r5, r0
154c0: e1a04001 mov r4, r1
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
154c4: e1a00002 mov r0, r2 154c8: e3a01020 mov r1, #32
*
*/
#define MSDOS_L2S_PRINT 0
msdos_name_type_t
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
{
154cc: e1a06002 mov r6, r2
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
154d0: e1a02003 mov r2, r3 154d4: eb000fc0 bl 193dc <memset>
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
154d8: e5d52000 ldrb r2, [r5] 154dc: e242102e sub r1, r2, #46 ; 0x2e 154e0: e2713000 rsbs r3, r1, #0 154e4: e0a33001 adc r3, r3, r1 154e8: e3540001 cmp r4, #1 154ec: 0352002e cmpeq r2, #46 ; 0x2e
{
sfn[0] = '.';
154f0: 03a0302e moveq r3, #46 ; 0x2e
memset (sfn, ' ', sfn_len);
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
154f4: 0a000065 beq 15690 <msdos_long_to_short+0x1d8>
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))
154f8: e3530000 cmp r3, #0
154fc: 0a00000b beq 15530 <msdos_long_to_short+0x78>
15500: e5d53001 ldrb r3, [r5, #1] 15504: e3540002 cmp r4, #2 15508: 0353002e cmpeq r3, #46 ; 0x2e 1550c: 13a03000 movne r3, #0 15510: 03a03001 moveq r3, #1
15514: 1a000005 bne 15530 <msdos_long_to_short+0x78>
15518: ea00005a b 15688 <msdos_long_to_short+0x1d0>
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
1551c: e7d52003 ldrb r2, [r5, r3] 15520: e352002e cmp r2, #46 ; 0x2e 15524: 13520020 cmpne r2, #32
15528: 1a000002 bne 15538 <msdos_long_to_short+0x80>
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
1552c: e2833001 add r3, r3, #1 15530: e1530004 cmp r3, r4
15534: bafffff8 blt 1551c <msdos_long_to_short+0x64>
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
15538: e1530004 cmp r3, r4
{
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: INVALID[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
1553c: 03a00000 moveq r0, #0
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
15540: 0a000054 beq 15698 <msdos_long_to_short+0x1e0>
15544: e3a08000 mov r8, #0 15548: e3e09000 mvn r9, #0 1554c: e58d8004 str r8, [sp, #4] 15550: e1a03008 mov r3, r8 15554: ea000037 b 15638 <msdos_long_to_short+0x180>
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
15558: e24a202e sub r2, sl, #46 ; 0x2e 1555c: e272b000 rsbs fp, r2, #0
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
15560: e59f013c ldr r0, [pc, #316] ; 156a4 <msdos_long_to_short+0x1ec> 15564: e1a0100a mov r1, sl
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
15568: e0abb002 adc fp, fp, r2
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
1556c: e58d3000 str r3, [sp] 15570: eb001325 bl 1a20c <strchr> 15574: e3500000 cmp r0, #0 15578: e59d3000 ldr r3, [sp]
return MSDOS_NAME_LONG;
1557c: 13a07002 movne r7, #2
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
15580: 1a00000f bne 155c4 <msdos_long_to_short+0x10c>
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
15584: e35b0000 cmp fp, #0
15588: 1a00000c bne 155c0 <msdos_long_to_short+0x108>
1558c: e59f1114 ldr r1, [pc, #276] ; 156a8 <msdos_long_to_short+0x1f0> 15590: e5912000 ldr r2, [r1] 15594: e082200a add r2, r2, sl 15598: e5d22001 ldrb r2, [r2, #1] 1559c: e3120007 tst r2, #7
155a0: 1a000006 bne 155c0 <msdos_long_to_short+0x108>
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
155a4: e59f0100 ldr r0, [pc, #256] ; 156ac <msdos_long_to_short+0x1f4> 155a8: e1a0100a mov r1, sl 155ac: eb001316 bl 1a20c <strchr>
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
155b0: e2907000 adds r7, r0, #0 155b4: 13a07001 movne r7, #1 155b8: e59d3000 ldr r3, [sp] 155bc: ea000000 b 155c4 <msdos_long_to_short+0x10c>
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
return MSDOS_NAME_SHORT;
155c0: e3a07001 mov r7, #1
#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))
155c4: e3570000 cmp r7, #0 155c8: 13570002 cmpne r7, #2
155cc: 0a000025 beq 15668 <msdos_long_to_short+0x1b0>
return type;
if (dot_at >= 0)
155d0: e3790001 cmn r9, #1
155d4: 0a000005 beq 155f0 <msdos_long_to_short+0x138>
{
if (is_dot || ((count - dot_at) > 3))
155d8: e35b0000 cmp fp, #0
155dc: 1a00002e bne 1569c <msdos_long_to_short+0x1e4>
155e0: e0692008 rsb r2, r9, r8 155e4: e3520003 cmp r2, #3
155e8: da000007 ble 1560c <msdos_long_to_short+0x154>
155ec: ea00002a b 1569c <msdos_long_to_short+0x1e4> <== NOT EXECUTED
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
155f0: e3580008 cmp r8, #8
155f4: 1a000002 bne 15604 <msdos_long_to_short+0x14c>
155f8: e35b0000 cmp fp, #0
155fc: 1a00000b bne 15630 <msdos_long_to_short+0x178>
15600: ea000025 b 1569c <msdos_long_to_short+0x1e4>
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
15604: e35b0000 cmp fp, #0
15608: 1a000008 bne 15630 <msdos_long_to_short+0x178>
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
1560c: e24a2041 sub r2, sl, #65 ; 0x41 15610: e3520019 cmp r2, #25
uppercase = true;
15614: 93a02001 movls r2, #1 15618: 958d2004 strls r2, [sp, #4]
}
}
if (is_dot)
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
1561c: 9a000004 bls 15634 <msdos_long_to_short+0x17c>
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
15620: e24aa061 sub sl, sl, #97 ; 0x61
lowercase = true;
15624: e35a0019 cmp sl, #25 15628: 93a03001 movls r3, #1 1562c: ea000000 b 15634 <msdos_long_to_short+0x17c>
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
15630: e1a09008 mov r9, r8
else if ((*name >= 'A') && (*name <= 'Z'))
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
lowercase = true;
count++;
15634: e2888001 add r8, r8, #1
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
15638: e7d5a008 ldrb sl, [r5, r8] 1563c: e35a0000 cmp sl, #0 15640: 11580004 cmpne r8, r4
15644: baffffc3 blt 15558 <msdos_long_to_short+0xa0>
count++;
name++;
}
if (lowercase && uppercase)
15648: e3530000 cmp r3, #0
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
1564c: 03a07001 moveq r7, #1
count++;
name++;
}
if (lowercase && uppercase)
15650: 0a000006 beq 15670 <msdos_long_to_short+0x1b8>
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
15654: e59d3004 ldr r3, [sp, #4] 15658: e3530000 cmp r3, #0 1565c: 13a07002 movne r7, #2 15660: 03a07001 moveq r7, #1 15664: ea000001 b 15670 <msdos_long_to_short+0x1b8>
* Is this a short name ?
*/
type = msdos_name_type (lfn, lfn_len);
if (type == MSDOS_NAME_INVALID)
15668: e2570000 subs r0, r7, #0
1566c: 0a000009 beq 15698 <msdos_long_to_short+0x1e0>
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
}
msdos_filename_unix2dos (lfn, lfn_len, sfn);
15670: e1a00005 mov r0, r5 15674: e1a01004 mov r1, r4 15678: e1a02006 mov r2, r6 1567c: eb000961 bl 17c08 <msdos_filename_unix2dos> 15680: e1a00007 mov r0, r7 15684: ea000003 b 15698 <msdos_long_to_short+0x1e0>
return MSDOS_NAME_SHORT;
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
{
sfn[0] = sfn[1] = '.';
15688: e3a0302e mov r3, #46 ; 0x2e 1568c: e5c63001 strb r3, [r6, #1] 15690: e5c63000 strb r3, [r6]
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
15694: e3a00001 mov r0, #1
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
}
15698: e8bd8ffc pop {r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: LONG[2]: is_dot:%d, at:%d cnt\n",
is_dot, dot_at, count);
#endif
return MSDOS_NAME_LONG;
1569c: e3a07002 mov r7, #2 156a0: eafffff2 b 15670 <msdos_long_to_short+0x1b8>
0000cc9c <msdos_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
cc9c: e1a0c002 mov ip, r2
msdos_node_type_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
cca0: e2032a0f and r2, r3, #61440 ; 0xf000
cca4: e3520901 cmp r2, #16384 ; 0x4000
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
cca8: e92d4010 push {r4, lr}
ccac: e1a04001 mov r4, r1
msdos_node_type_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
ccb0: 0a000007 beq ccd4 <msdos_mknod+0x38>
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
ccb4: e3520902 cmp r2, #32768 ; 0x8000
{
type = MSDOS_REGULAR_FILE;
ccb8: 03a01004 moveq r1, #4
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
ccbc: 0a000005 beq ccd8 <msdos_mknod+0x3c>
{
type = MSDOS_REGULAR_FILE;
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
ccc0: eb002ee8 bl 18868 <__errno> <== NOT EXECUTED
ccc4: e3a03016 mov r3, #22 <== NOT EXECUTED
ccc8: e5803000 str r3, [r0] <== NOT EXECUTED
/* Create an MSDOS node */
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
return rc;
}
cccc: e3e00000 mvn r0, #0 <== NOT EXECUTED
ccd0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
ccd4: e3a01000 mov r1, #0
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
/* Create an MSDOS node */
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
ccd8: e58d3008 str r3, [sp, #8]
ccdc: e3a03000 mov r3, #0
cce0: e58d300c str r3, [sp, #12]
cce4: e1a02004 mov r2, r4
cce8: e1a0300c mov r3, ip
return rc;
}
ccec: e8bd4010 pop {r4, lr}
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
/* Create an MSDOS node */
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
ccf0: ea0020c3 b 15004 <msdos_creat_node>
0000cd00 <msdos_rename>:
const rtems_filesystem_location_info_t *old_loc,
const rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name,
size_t new_namelen
)
{
cd00: e92d4033 push {r0, r1, r4, r5, lr} <== NOT EXECUTED
int rc = RC_OK;
fat_file_fd_t *old_fat_fd = old_loc->node_access;
cd04: e5914008 ldr r4, [r1, #8] <== NOT EXECUTED
const rtems_filesystem_location_info_t *old_loc,
const rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name,
size_t new_namelen
)
{
cd08: e1a05001 mov r5, r1 <== NOT EXECUTED
/*
* create new directory entry as "hard link", copying relevant info from
* existing file
*/
rc = msdos_creat_node(new_parent_loc,
cd0c: e3a01902 mov r1, #32768 ; 0x8000 <== NOT EXECUTED
cd10: e88d0012 stm sp, {r1, r4} <== NOT EXECUTED
cd14: e1a00002 mov r0, r2 <== NOT EXECUTED
cd18: e3a01002 mov r1, #2 <== NOT EXECUTED
cd1c: e1a02003 mov r2, r3 <== NOT EXECUTED
cd20: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED
cd24: eb0020b6 bl 15004 <msdos_creat_node> <== NOT EXECUTED
MSDOS_HARD_LINK,new_name,new_namelen,S_IFREG,
old_fat_fd);
if (rc != RC_OK)
cd28: e3500000 cmp r0, #0 <== NOT EXECUTED
cd2c: 1a000005 bne cd48 <msdos_rename+0x48> <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
cd30: e5950014 ldr r0, [r5, #20] <== NOT EXECUTED
cd34: e2841020 add r1, r4, #32 <== NOT EXECUTED
cd38: e3a020e5 mov r2, #229 ; 0xe5 <== NOT EXECUTED
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
return rc;
}
cd3c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
cd40: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
cd44: ea0022c6 b 15864 <msdos_set_first_char4file_name> <== NOT EXECUTED
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
return rc;
}
cd48: e28dd008 add sp, sp, #8 <== NOT EXECUTED
cd4c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
0000cd50 <msdos_rmnod>:
#include "msdos.h"
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
cd50: e92d40f1 push {r0, r4, r5, r6, r7, lr}
int rc = RC_OK;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
cd54: e5914008 ldr r4, [r1, #8]
if (fat_fd->fat_file_type == MSDOS_DIRECTORY)
cd58: e5943010 ldr r3, [r4, #16]
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
cd5c: e5910014 ldr r0, [r1, #20]
fat_file_fd_t *fat_fd = pathloc->node_access;
if (fat_fd->fat_file_type == MSDOS_DIRECTORY)
cd60: e3530000 cmp r3, #0
#include "msdos.h"
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
cd64: e1a05001 mov r5, r1
int rc = RC_OK;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
cd68: e5906008 ldr r6, [r0, #8]
fat_file_fd_t *fat_fd = pathloc->node_access;
if (fat_fd->fat_file_type == MSDOS_DIRECTORY)
cd6c: 1a000013 bne cdc0 <msdos_rmnod+0x70>
{
bool is_empty = false;
cd70: e28d2004 add r2, sp, #4
cd74: e5623001 strb r3, [r2, #-1]!
/*
* You cannot remove a node that still has children
*/
rc = msdos_dir_is_empty(pathloc->mt_entry, fat_fd, &is_empty);
cd78: e1a01004 mov r1, r4
cd7c: eb0022f9 bl 15968 <msdos_dir_is_empty>
if (rc != RC_OK)
cd80: e2507000 subs r7, r0, #0
cd84: 1a000015 bne cde0 <msdos_rmnod+0x90>
{
return rc;
}
if (!is_empty)
cd88: e5dd3003 ldrb r3, [sp, #3]
cd8c: e3530000 cmp r3, #0
cd90: 1a000002 bne cda0 <msdos_rmnod+0x50>
{
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
cd94: eb002eb3 bl 18868 <__errno>
cd98: e3a0305a mov r3, #90 ; 0x5a
cd9c: ea000004 b cdb4 <msdos_rmnod+0x64>
/*
* We deny attempts to delete open directory (if directory is current
* directory we assume it is open one)
*/
if (fat_fd->links_num > 1)
cda0: e5943008 ldr r3, [r4, #8]
cda4: e3530001 cmp r3, #1
cda8: 9a000004 bls cdc0 <msdos_rmnod+0x70>
{
rtems_set_errno_and_return_minus_one(EBUSY);
cdac: eb002ead bl 18868 <__errno> <== NOT EXECUTED
cdb0: e3a03010 mov r3, #16 <== NOT EXECUTED
cdb4: e5803000 str r3, [r0]
cdb8: e3e07000 mvn r7, #0
cdbc: ea000007 b cde0 <msdos_rmnod+0x90>
* not used - mount() not implemenetd yet.
*/
}
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
cdc0: e5950014 ldr r0, [r5, #20]
cdc4: e2841020 add r1, r4, #32
cdc8: e3a020e5 mov r2, #229 ; 0xe5
cdcc: eb0022a4 bl 15864 <msdos_set_first_char4file_name>
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
cdd0: e2507000 subs r7, r0, #0
{
return rc;
}
fat_file_mark_removed(&fs_info->fat, fat_fd);
cdd4: 01a00006 moveq r0, r6
cdd8: 01a01004 moveq r1, r4
cddc: 0b000f2b bleq 10a90 <fat_file_mark_removed>
return rc;
}
cde0: e1a00007 mov r0, r7
cde4: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
00015864 <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
)
{
15864: e92d41ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, lr}
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
15868: e5904008 ldr r4, [r0, #8]
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
1586c: e5cd2004 strb r2, [sp, #4]
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;
15870: e2813008 add r3, r1, #8
15874: e893000c ldm r3, {r2, r3}
fat_pos_t end = dir_pos->sname;
15878: e8910120 ldm r1, {r5, r8}
)
{
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;
1587c: e58d2008 str r2, [sp, #8] 15880: e58d300c str r3, [sp, #12]
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
15884: e594303c ldr r3, [r4, #60] ; 0x3c 15888: e1550003 cmp r5, r3
1588c: 1a000003 bne 158a0 <msdos_set_first_char4file_name+0x3c>
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
15890: e5d4300e ldrb r3, [r4, #14]
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;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
15894: e3130003 tst r3, #3
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
15898: 1594602c ldrne r6, [r4, #44] ; 0x2c
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;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
1589c: 1a000000 bne 158a4 <msdos_set_first_char4file_name+0x40>
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
else
dir_block_size = fs_info->fat.vol.bpc;
158a0: e1d460b6 ldrh r6, [r4, #6] <== NOT EXECUTED
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
158a4: e5913008 ldr r3, [r1, #8] 158a8: e3730001 cmn r3, #1
start = dir_pos->sname;
158ac: 0891000c ldmeq r1, {r2, r3}
158b0: 058d2008 streq r2, [sp, #8]
158b4: 058d300c streq r3, [sp, #12]
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
1, &fchar);
158b8: e28d7004 add r7, sp, #4
* name code was written rather than use the fat_file_write
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
158bc: e59d1008 ldr r1, [sp, #8] 158c0: e1a00004 mov r0, r4 158c4: ebfffef0 bl 1548c <fat_cluster_num_to_sector_num>
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
158c8: e1d420b0 ldrh r2, [r4]
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
158cc: e59d300c ldr r3, [sp, #12] 158d0: e5d41002 ldrb r1, [r4, #2]
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
158d4: e2422001 sub r2, r2, #1
* name code was written rather than use the fat_file_write
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
158d8: e0801133 add r1, r0, r3, lsr r1
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
158dc: e0022003 and r2, r2, r3 158e0: e1a00004 mov r0, r4 158e4: e3a03001 mov r3, #1 158e8: e58d7000 str r7, [sp] 158ec: ebffed65 bl 10e88 <fat_sector_write>
1, &fchar);
if (ret < 0)
158f0: e3500000 cmp r0, #0
158f4: ba000016 blt 15954 <msdos_set_first_char4file_name+0xf0>
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
158f8: e59d1008 ldr r1, [sp, #8] 158fc: e1510005 cmp r1, r5 15900: e59d300c ldr r3, [sp, #12]
15904: 1a000001 bne 15910 <msdos_set_first_char4file_name+0xac>
15908: e1530008 cmp r3, r8
1590c: 0a000012 beq 1595c <msdos_set_first_char4file_name+0xf8>
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
15910: e2833020 add r3, r3, #32
if (start.ofs >= dir_block_size)
15914: e1530006 cmp r3, r6
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
15918: e58d300c str r3, [sp, #12]
if (start.ofs >= dir_block_size)
1591c: 3affffe6 bcc 158bc <msdos_set_first_char4file_name+0x58>
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
15920: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED 15924: e1550003 cmp r5, r3 <== NOT EXECUTED 15928: 1a000002 bne 15938 <msdos_set_first_char4file_name+0xd4> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
1592c: e5d4300e ldrb r3, [r4, #14] <== NOT EXECUTED
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
if (start.ofs >= dir_block_size)
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
15930: e3130003 tst r3, #3 <== NOT EXECUTED 15934: 1a000008 bne 1595c <msdos_set_first_char4file_name+0xf8> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
break;
rc = fat_get_fat_cluster(&fs_info->fat, start.cln, &start.cln);
15938: e1a00004 mov r0, r4 <== NOT EXECUTED 1593c: e28d2008 add r2, sp, #8 <== NOT EXECUTED 15940: eb00044c bl 16a78 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
15944: e3500000 cmp r0, #0 <== NOT EXECUTED 15948: 1a000004 bne 15960 <msdos_set_first_char4file_name+0xfc> <== NOT EXECUTED
return rc;
start.ofs = 0;
1594c: e58d000c str r0, [sp, #12] <== NOT EXECUTED 15950: eaffffd9 b 158bc <msdos_set_first_char4file_name+0x58> <== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
1, &fchar);
if (ret < 0)
return -1;
15954: e3e00000 mvn r0, #0 <== NOT EXECUTED 15958: ea000000 b 15960 <msdos_set_first_char4file_name+0xfc> <== NOT EXECUTED
return rc;
start.ofs = 0;
}
}
return RC_OK;
1595c: e3a00000 mov r0, #0
}
15960: e28dd010 add sp, sp, #16
15964: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
0000bbe4 <msdos_set_sectors_per_cluster_from_request>:
msdos_format_param_t *fmt_params )
{
int ret_val = -1;
uint32_t onebit;
if ( rqdata != NULL && rqdata->sectors_per_cluster > 0 ) {
bbe4: e3500000 cmp r0, #0
static int
msdos_set_sectors_per_cluster_from_request(
const msdos_format_request_param_t *rqdata,
msdos_format_param_t *fmt_params )
{
bbe8: e92d4070 push {r4, r5, r6, lr}
bbec: e1a05001 mov r5, r1
int ret_val = -1;
uint32_t onebit;
if ( rqdata != NULL && rqdata->sectors_per_cluster > 0 ) {
bbf0: 0a000002 beq bc00 <msdos_set_sectors_per_cluster_from_request+0x1c>
bbf4: e5903008 ldr r3, [r0, #8]
bbf8: e3530000 cmp r3, #0
fmt_params->sectors_per_cluster = rqdata->sectors_per_cluster;
bbfc: 1581300c strne r3, [r1, #12]
static int
msdos_set_sectors_per_cluster_from_request(
const msdos_format_request_param_t *rqdata,
msdos_format_param_t *fmt_params )
{
bc00: e3a04080 mov r4, #128 ; 0x80
bc04: e3e06000 mvn r6, #0
* 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 ) {
bc08: e595300c ldr r3, [r5, #12]
bc0c: e1530004 cmp r3, r4
bc10: 3a000006 bcc bc30 <msdos_set_sectors_per_cluster_from_request+0x4c>
fmt_params->sectors_per_cluster = onebit;
bc14: e585400c str r4, [r5, #12]
if ( fmt_params->sectors_per_cluster
<= 32768L / fmt_params->bytes_per_sector ) {
bc18: e3a00902 mov r0, #32768 ; 0x8000
bc1c: e5951000 ldr r1, [r5]
bc20: ebffd80e bl 1c60 <__aeabi_uidiv>
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for ( onebit = 128; onebit >= 1; onebit = onebit >> 1 ) {
if ( fmt_params->sectors_per_cluster >= onebit ) {
fmt_params->sectors_per_cluster = onebit;
if ( fmt_params->sectors_per_cluster
bc24: e1540000 cmp r4, r0
<= 32768L / fmt_params->bytes_per_sector ) {
/* value is small enough so this value is ok */
onebit = 1;
bc28: 93a04001 movls r4, #1
ret_val = 0;
bc2c: 93a06000 movls r6, #0
* 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 ) {
bc30: e1b040a4 lsrs r4, r4, #1
bc34: 1afffff3 bne bc08 <msdos_set_sectors_per_cluster_from_request+0x24>
ret_val = 0;
}
}
}
if (ret_val != 0) {
bc38: e3560000 cmp r6, #0
bc3c: 0a000002 beq bc4c <msdos_set_sectors_per_cluster_from_request+0x68>
errno = EINVAL;
bc40: eb003308 bl 18868 <__errno> <== NOT EXECUTED
bc44: e3a03016 mov r3, #22 <== NOT EXECUTED
bc48: e5803000 str r3, [r0] <== NOT EXECUTED
}
return ret_val;
}
bc4c: e1a00006 mov r0, r6
bc50: e8bd8070 pop {r4, r5, r6, pc}
00016910 <msdos_sync>:
int
msdos_sync(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;
16910: e5903024 ldr r3, [r0, #36] ; 0x24
return MSDOS_NAME_NOT_FOUND_ERR;
}
int
msdos_sync(rtems_libio_t *iop)
{
16914: e92d4030 push {r4, r5, lr}
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
16918: e5934008 ldr r4, [r3, #8]
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
1691c: e3a01000 mov r1, #0 16920: e594009c ldr r0, [r4, #156] ; 0x9c 16924: e1a02001 mov r2, r1 16928: ebffc5d4 bl 8080 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
1692c: e3500000 cmp r0, #0
16930: 0a000004 beq 16948 <msdos_sync+0x38>
rtems_set_errno_and_return_minus_one(EIO);
16934: eb0007cb bl 18868 <__errno> <== NOT EXECUTED 16938: e3a03005 mov r3, #5 <== NOT EXECUTED 1693c: e5803000 str r3, [r0] <== NOT EXECUTED 16940: e3e05000 mvn r5, #0 <== NOT EXECUTED 16944: ea000004 b 1695c <msdos_sync+0x4c> <== NOT EXECUTED
rc = fat_sync(&fs_info->fat);
16948: e1a00004 mov r0, r4 1694c: ebffeb9d bl 117c8 <fat_sync> 16950: e1a05000 mov r5, r0
rtems_semaphore_release(fs_info->vol_sema);
16954: e594009c ldr r0, [r4, #156] ; 0x9c 16958: ebffc60f bl 819c <rtems_semaphore_release>
return rc;
}
1695c: e1a00005 mov r0, r5
16960: e8bd8030 pop {r4, r5, pc}
0000ca88 <msdos_unlock>:
}
void msdos_unlock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
msdos_fs_info_t *fs_info = mt_entry->fs_info;
rtems_status_code sc = rtems_semaphore_release(fs_info->vol_sema);
ca88: e5903008 ldr r3, [r0, #8]
rtems_fatal_error_occurred(0xdeadbeef);
}
}
void msdos_unlock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
ca8c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
msdos_fs_info_t *fs_info = mt_entry->fs_info; rtems_status_code sc = rtems_semaphore_release(fs_info->vol_sema);
ca90: e593009c ldr r0, [r3, #156] ; 0x9c
ca94: ebffedc0 bl 819c <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL) {
ca98: e3500000 cmp r0, #0
ca9c: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_fatal_error_occurred(0xdeadbeef);
caa0: e59f0000 ldr r0, [pc] ; caa8 <msdos_unlock+0x20> <== NOT EXECUTED
caa4: ebffef4d bl 87e0 <rtems_fatal_error_occurred> <== NOT EXECUTED
00002ba8 <newlib_free_buffers>:
* task.
*/
int newlib_free_buffers(
FILE *fp
)
{
2ba8: e92d4010 push {r4, lr}
2bac: e1a04000 mov r4, r0
switch ( fileno(fp) ) {
2bb0: eb002be8 bl db58 <fileno>
2bb4: e3500002 cmp r0, #2
2bb8: 8a00000b bhi 2bec <newlib_free_buffers+0x44>
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
2bbc: e1d430bc ldrh r3, [r4, #12]
2bc0: e3130080 tst r3, #128 ; 0x80
2bc4: 0a00000a beq 2bf4 <newlib_free_buffers+0x4c>
free( fp->_bf._base );
2bc8: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
2bcc: ebfffdd5 bl 2328 <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
2bd0: e1d430bc ldrh r3, [r4, #12] <== NOT EXECUTED
2bd4: e3c33080 bic r3, r3, #128 ; 0x80 <== NOT EXECUTED
2bd8: e1c430bc strh r3, [r4, #12] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
2bdc: e3a03000 mov r3, #0 <== NOT EXECUTED
2be0: e5843000 str r3, [r4] <== NOT EXECUTED
2be4: e5843010 str r3, [r4, #16] <== NOT EXECUTED
2be8: ea000001 b 2bf4 <newlib_free_buffers+0x4c> <== NOT EXECUTED
}
break;
default:
fclose(fp);
2bec: e1a00004 mov r0, r4 <== NOT EXECUTED
2bf0: eb002b1b bl d864 <fclose> <== NOT EXECUTED
} return 0; }
2bf4: e3a00000 mov r0, #0
2bf8: e8bd8010 pop {r4, pc}
00001568 <notify>:
}
void
notify (s)
char *s;
{
1568: e1a01000 mov r1, r0 <== NOT EXECUTED
156c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
printf ("%s test appears to be inconsistent...\n", s);
1570: e59f000c ldr r0, [pc, #12] ; 1584 <notify+0x1c> <== NOT EXECUTED
1574: eb006403 bl 1a588 <printf> <== NOT EXECUTED
printf (" PLEASE NOTIFY KARPINKSI!\n");
1578: e59f0008 ldr r0, [pc, #8] ; 1588 <notify+0x20> <== NOT EXECUTED
}
157c: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
void
notify (s)
char *s;
{
printf ("%s test appears to be inconsistent...\n", s);
printf (" PLEASE NOTIFY KARPINKSI!\n");
1580: ea006440 b 1a688 <puts> <== NOT EXECUTED
0000565c <null_op_fsmount_me>:
rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data
)
{
return -1;
}
565c: e3e00000 mvn r0, #0 <== NOT EXECUTED
5660: e12fff1e bx lr <== NOT EXECUTED
0000566c <null_op_fsunmount_me>:
static void null_op_fsunmount_me(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
/* Do nothing */
}
566c: e12fff1e bx lr <== NOT EXECUTED
00005634 <null_op_link>:
const char *name,
size_t namelen
)
{
return -1;
}
5634: e3e00000 mvn r0, #0 <== NOT EXECUTED
5638: e12fff1e bx lr <== NOT EXECUTED
00005654 <null_op_mount>:
static int null_op_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
return -1;
}
5654: e3e00000 mvn r0, #0 <== NOT EXECUTED
5658: e12fff1e bx lr <== NOT EXECUTED
00005680 <null_op_readlink>:
char *buf,
size_t bufsize
)
{
return -1;
}
5680: e3e00000 mvn r0, #0 <== NOT EXECUTED
5684: e12fff1e bx lr <== NOT EXECUTED
00005688 <null_op_rename>:
const char *name,
size_t namelen
)
{
return -1;
}
5688: e3e00000 mvn r0, #0 <== NOT EXECUTED
568c: e12fff1e bx lr <== NOT EXECUTED
0000562c <null_op_rmnod>:
const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *loc
)
{
return -1;
}
562c: e3e00000 mvn r0, #0 <== NOT EXECUTED
5630: e12fff1e bx lr <== NOT EXECUTED
00004914 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
4914: e92d4011 push {r0, r4, lr}
int i;
if (tty->termios.c_oflag & OPOST) {
4918: e5913034 ldr r3, [r1, #52] ; 0x34
491c: e3130001 tst r3, #1
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
4920: e1a04001 mov r4, r1
4924: e5cd0000 strb r0, [sp]
int i;
if (tty->termios.c_oflag & OPOST) {
4928: 0a000045 beq 4a44 <oproc+0x130>
switch (c) {
492c: e20020ff and r2, r0, #255 ; 0xff
4930: e2421008 sub r1, r2, #8
4934: e3510005 cmp r1, #5
4938: 979ff101 ldrls pc, [pc, r1, lsl #2]
493c: ea00002c b 49f4 <oproc+0xe0>
4940: 000049e0 .word 0x000049e0
4944: 000049b8 .word 0x000049b8 <== NOT EXECUTED
4948: 00004958 .word 0x00004958 <== NOT EXECUTED
494c: 000049f4 .word 0x000049f4 <== NOT EXECUTED
4950: 000049f4 .word 0x000049f4 <== NOT EXECUTED
4954: 00004980 .word 0x00004980 <== NOT EXECUTED
case '\n':
if (tty->termios.c_oflag & ONLRET)
4958: e3130020 tst r3, #32
tty->column = 0;
495c: 13a02000 movne r2, #0
4960: 15842028 strne r2, [r4, #40] ; 0x28
if (tty->termios.c_oflag & ONLCR) {
4964: e3130004 tst r3, #4
4968: 0a000035 beq 4a44 <oproc+0x130>
rtems_termios_puts ("\r", 1, tty);
496c: e59f00e4 ldr r0, [pc, #228] ; 4a58 <oproc+0x144>
4970: e3a01001 mov r1, #1
4974: e1a02004 mov r2, r4
4978: ebffffa8 bl 4820 <rtems_termios_puts>
497c: ea00000b b 49b0 <oproc+0x9c>
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
4980: e3130010 tst r3, #16 <== NOT EXECUTED
4984: 0a000002 beq 4994 <oproc+0x80> <== NOT EXECUTED
4988: e5942028 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED
498c: e3520000 cmp r2, #0 <== NOT EXECUTED
4990: 0a00002f beq 4a54 <oproc+0x140> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
4994: e2132008 ands r2, r3, #8 <== NOT EXECUTED
c = '\n';
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
break;
}
tty->column = 0;
4998: 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) {
499c: 0a000028 beq 4a44 <oproc+0x130> <== NOT EXECUTED
c = '\n';
49a0: e3a0200a mov r2, #10 <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
49a4: 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';
49a8: e5cd2000 strb r2, [sp] <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
49ac: 0a000024 beq 4a44 <oproc+0x130> <== NOT EXECUTED
tty->column = 0;
49b0: e3a03000 mov r3, #0
49b4: ea000021 b 4a40 <oproc+0x12c>
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
49b8: e5942028 ldr r2, [r4, #40] ; 0x28
49bc: e2021007 and r1, r2, #7
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
49c0: e2033b06 and r3, r3, #6144 ; 0x1800
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
49c4: e2611008 rsb r1, r1, #8
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
49c8: e3530b06 cmp r3, #6144 ; 0x1800
49cc: e0823001 add r3, r2, r1
tty->column += i;
49d0: e5843028 str r3, [r4, #40] ; 0x28
rtems_termios_puts ( " ", i, tty);
49d4: 059f0080 ldreq r0, [pc, #128] ; 4a5c <oproc+0x148>
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
49d8: 1a000019 bne 4a44 <oproc+0x130>
49dc: ea00001a b 4a4c <oproc+0x138>
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
49e0: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
49e4: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
49e8: c2433001 subgt r3, r3, #1 <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
49ec: ca000013 bgt 4a40 <oproc+0x12c> <== NOT EXECUTED
49f0: ea000013 b 4a44 <oproc+0x130> <== NOT EXECUTED
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
49f4: e3130002 tst r3, #2
49f8: 0a000007 beq 4a1c <oproc+0x108>
c = toupper(c);
49fc: e59f305c ldr r3, [pc, #92] ; 4a60 <oproc+0x14c> <== NOT EXECUTED
4a00: e5933000 ldr r3, [r3] <== NOT EXECUTED
4a04: e0833002 add r3, r3, r2 <== NOT EXECUTED
4a08: e5d33001 ldrb r3, [r3, #1] <== NOT EXECUTED
4a0c: e2033003 and r3, r3, #3 <== NOT EXECUTED
4a10: e3530002 cmp r3, #2 <== NOT EXECUTED
4a14: 02422020 subeq r2, r2, #32 <== NOT EXECUTED
4a18: e5cd2000 strb r2, [sp] <== NOT EXECUTED
if (!iscntrl(c))
4a1c: e59f203c ldr r2, [pc, #60] ; 4a60 <oproc+0x14c>
4a20: e5dd3000 ldrb r3, [sp]
4a24: e5922000 ldr r2, [r2]
4a28: e0823003 add r3, r2, r3
4a2c: e5d33001 ldrb r3, [r3, #1]
4a30: e3130020 tst r3, #32
4a34: 1a000002 bne 4a44 <oproc+0x130>
tty->column++;
4a38: e5943028 ldr r3, [r4, #40] ; 0x28
4a3c: e2833001 add r3, r3, #1
4a40: e5843028 str r3, [r4, #40] ; 0x28
break;
}
}
rtems_termios_puts (&c, 1, tty);
4a44: e1a0000d mov r0, sp
4a48: e3a01001 mov r1, #1
4a4c: e1a02004 mov r2, r4
4a50: ebffff72 bl 4820 <rtems_termios_puts>
}
4a54: e8bd8018 pop {r3, r4, pc}
00003538 <partition_free>:
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
{
3538: e92d4070 push {r4, r5, r6, lr}
int part_num;
if (part_desc == NULL)
353c: e2504000 subs r4, r0, #0
3540: 08bd8070 popeq {r4, r5, r6, pc}
return;
if (is_extended(part_desc->sys_type))
3544: e5d43001 ldrb r3, [r4, #1]
3548: e3530005 cmp r3, #5
354c: 13530085 cmpne r3, #133 ; 0x85
3550: 1a000006 bne 3570 <partition_free+0x38>
3554: e1a06004 mov r6, r4 <== NOT EXECUTED
3558: e3a05004 mov r5, #4 <== NOT EXECUTED
{
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
partition_free(part_desc->sub_part[part_num]);
355c: e5960018 ldr r0, [r6, #24] <== NOT EXECUTED
3560: ebfffff4 bl 3538 <partition_free> <== NOT EXECUTED
if (part_desc == NULL)
return;
if (is_extended(part_desc->sys_type))
{
for (part_num = 0;
3564: e2555001 subs r5, r5, #1 <== NOT EXECUTED
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
partition_free(part_desc->sub_part[part_num]);
3568: e2866004 add r6, r6, #4 <== NOT EXECUTED
if (part_desc == NULL)
return;
if (is_extended(part_desc->sys_type))
{
for (part_num = 0;
356c: 1afffffa bne 355c <partition_free+0x24> <== NOT EXECUTED
{
partition_free(part_desc->sub_part[part_num]);
}
}
free(part_desc);
3570: e1a00004 mov r0, r4
}
3574: e8bd4070 pop {r4, r5, r6, lr}
{
partition_free(part_desc->sub_part[part_num]);
}
}
free(part_desc);
3578: ea0003ad b 4434 <free>
00003808 <partition_table_get>:
* RTEMS_SUCCESSFUL if success,
* RTEMS_INTERNAL_ERROR otherwise
*/
static rtems_status_code
partition_table_get(const char *dev_name, rtems_disk_desc_t *disk_desc)
{
3808: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
380c: e1a05001 mov r5, r1
3810: e24dd050 sub sp, sp, #80 ; 0x50
struct stat dev_stat;
rtems_status_code rc;
int fd;
fd = open(dev_name, O_RDONLY);
3814: e3a01000 mov r1, #0
* RTEMS_SUCCESSFUL if success,
* RTEMS_INTERNAL_ERROR otherwise
*/
static rtems_status_code
partition_table_get(const char *dev_name, rtems_disk_desc_t *disk_desc)
{
3818: e1a07000 mov r7, r0
struct stat dev_stat;
rtems_status_code rc;
int fd;
fd = open(dev_name, O_RDONLY);
381c: eb000688 bl 5244 <open>
if (fd < 0)
3820: e2506000 subs r6, r0, #0
3824: ba00005f blt 39a8 <partition_table_get+0x1a0>
{
return RTEMS_INTERNAL_ERROR;
}
rc = fstat(fd, &dev_stat);
3828: e1a0100d mov r1, sp
382c: eb000329 bl 44d8 <fstat>
if (rc != RTEMS_SUCCESSFUL)
3830: e2504000 subs r4, r0, #0
3834: 0a000002 beq 3844 <partition_table_get+0x3c>
{
close(fd);
3838: e1a00006 mov r0, r6 <== NOT EXECUTED
383c: eb00025a bl 41ac <close> <== NOT EXECUTED
3840: ea000058 b 39a8 <partition_table_get+0x1a0> <== NOT EXECUTED
return RTEMS_INTERNAL_ERROR;
}
strncpy (disk_desc->dev_name, dev_name, 15);
3844: e1a01007 mov r1, r7
3848: e3a0200f mov r2, #15
384c: e2850008 add r0, r5, #8
3850: eb004310 bl 14498 <strncpy>
disk_desc->dev = dev_stat.st_rdev;
3854: e28d3018 add r3, sp, #24
3858: e893000c ldm r3, {r2, r3}
385c: e885000c stm r5, {r2, r3}
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
3860: e59d3040 ldr r3, [sp, #64] ; 0x40
3864: e3530000 cmp r3, #0
3868: 03a03c02 moveq r3, #512 ; 0x200
*/
static rtems_status_code
read_mbr(int fd, rtems_disk_desc_t *disk_desc)
{
int part_num;
rtems_sector_data_t *sector = NULL;
386c: e28d2050 add r2, sp, #80 ; 0x50
3870: e5224008 str r4, [r2, #-8]!
rtems_part_desc_t *part_desc;
uint8_t *data;
rtems_status_code rc;
/* get MBR sector */
rc = get_sector(fd, 0, §or);
3874: e1a01004 mov r1, r4
return RTEMS_INTERNAL_ERROR;
}
strncpy (disk_desc->dev_name, dev_name, 15);
disk_desc->dev = dev_stat.st_rdev;
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
3878: e5853018 str r3, [r5, #24]
rtems_part_desc_t *part_desc;
uint8_t *data;
rtems_status_code rc;
/* get MBR sector */
rc = get_sector(fd, 0, §or);
387c: e1a00006 mov r0, r6
3880: ebffff3d bl 357c <get_sector>
if (rc != RTEMS_SUCCESSFUL)
3884: e2504000 subs r4, r0, #0
3888: e59d0048 ldr r0, [sp, #72] ; 0x48
388c: 0a000002 beq 389c <partition_table_get+0x94>
{
if (sector)
3890: e3500000 cmp r0, #0 <== NOT EXECUTED
3894: 1a000017 bne 38f8 <partition_table_get+0xf0> <== NOT EXECUTED
3898: ea00003f b 399c <partition_table_get+0x194> <== NOT EXECUTED
static bool
msdos_signature_check (rtems_sector_data_t *sector)
{
uint8_t *p = sector->data + RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_OFFSET;
return ((p[0] == RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_DATA1) &&
389c: e5d03202 ldrb r3, [r0, #514] ; 0x202
38a0: e3530055 cmp r3, #85 ; 0x55
38a4: 1a000003 bne 38b8 <partition_table_get+0xb0>
* RETURNS:
* RTEMS_SUCCESSFUL if success,
* RTEMS_INTERNAL_ERROR otherwise
*/
static rtems_status_code
partition_table_get(const char *dev_name, rtems_disk_desc_t *disk_desc)
38a8: e5d04203 ldrb r4, [r0, #515] ; 0x203
38ac: e24420aa sub r2, r4, #170 ; 0xaa
38b0: e2724000 rsbs r4, r2, #0
38b4: e0a44002 adc r4, r4, r2
free(sector);
return rc;
}
/* check if the partition table structure is MS-DOS style */
if (!msdos_signature_check(sector))
38b8: e31400ff tst r4, #255 ; 0xff
38bc: 1a000002 bne 38cc <partition_table_get+0xc4>
{
free(sector);
38c0: eb0002db bl 4434 <free> <== NOT EXECUTED
return RTEMS_INTERNAL_ERROR;
38c4: e3a04019 mov r4, #25 <== NOT EXECUTED
38c8: ea000033 b 399c <partition_table_get+0x194> <== NOT EXECUTED
}
/* read and process 4 primary partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
38cc: e2809d07 add r9, r0, #448 ; 0x1c0
38d0: e2899002 add r9, r9, #2
38d4: e1a07005 mov r7, r5
38d8: e1a0a005 mov sl, r5
38dc: e3a08001 mov r8, #1
38e0: e1a00009 mov r0, r9
38e4: e28d104c add r1, sp, #76 ; 0x4c
38e8: ebffff47 bl 360c <data_to_part_desc.part.1>
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
rc = data_to_part_desc(data, &part_desc);
if (rc != RTEMS_SUCCESSFUL)
38ec: e2504000 subs r4, r0, #0
38f0: 0a000002 beq 3900 <partition_table_get+0xf8>
{
free(sector);
38f4: e59d0048 ldr r0, [sp, #72] ; 0x48 <== NOT EXECUTED
38f8: eb0002cd bl 4434 <free> <== NOT EXECUTED
38fc: ea000026 b 399c <partition_table_get+0x194> <== NOT EXECUTED
return rc;
}
if (part_desc != NULL)
3900: e59d304c ldr r3, [sp, #76] ; 0x4c
3904: e3530000 cmp r3, #0
{
part_desc->log_id = part_num + 1;
part_desc->disk_desc = disk_desc;
part_desc->end = part_desc->start + part_desc->size - 1;
3908: 19930006 ldmibne r3, {r1, r2}
390c: 10812002 addne r2, r1, r2
return rc;
}
if (part_desc != NULL)
{
part_desc->log_id = part_num + 1;
3910: 15c38002 strbne r8, [r3, #2]
else
{
disk_desc->partitions[part_num] = NULL;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
3914: e2888001 add r8, r8, #1
if (part_desc != NULL)
{
part_desc->log_id = part_num + 1;
part_desc->disk_desc = disk_desc;
part_desc->end = part_desc->start + part_desc->size - 1;
3918: 12422001 subne r2, r2, #1
else
{
disk_desc->partitions[part_num] = NULL;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
391c: e20880ff and r8, r8, #255 ; 0xff
}
if (part_desc != NULL)
{
part_desc->log_id = part_num + 1;
part_desc->disk_desc = disk_desc;
3920: 15835010 strne r5, [r3, #16]
part_desc->end = part_desc->start + part_desc->size - 1;
3924: 1583200c strne r2, [r3, #12]
disk_desc->partitions[part_num] = part_desc;
}
else
{
disk_desc->partitions[part_num] = NULL;
3928: 058a4028 streq r4, [sl, #40] ; 0x28
if (part_desc != NULL)
{
part_desc->log_id = part_num + 1;
part_desc->disk_desc = disk_desc;
part_desc->end = part_desc->start + part_desc->size - 1;
disk_desc->partitions[part_num] = part_desc;
392c: 158a3028 strne r3, [sl, #40] ; 0x28
/* read and process 4 primary partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (part_num = 0;
3930: e3580005 cmp r8, #5
else
{
disk_desc->partitions[part_num] = NULL;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
3934: e2899010 add r9, r9, #16
3938: e28aa004 add sl, sl, #4
/* read and process 4 primary partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (part_num = 0;
393c: 1affffe7 bne 38e0 <partition_table_get+0xd8>
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
3940: e59d0048 ldr r0, [sp, #72] ; 0x48
3944: eb0002ba bl 4434 <free>
disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
3948: e3a03004 mov r3, #4
394c: e5853024 str r3, [r5, #36] ; 0x24
part_desc = disk_desc->partitions[part_num];
if (part_desc != NULL && is_extended(part_desc->sys_type))
{
read_extended_partition(fd, part_desc->start, part_desc);
free(part_desc);
disk_desc->partitions[part_num] = NULL;
3950: e3a08000 mov r8, #0
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
3954: e1a05003 mov r5, r3
but we are to process each primary partition */
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
part_desc = disk_desc->partitions[part_num];
3958: e5972028 ldr r2, [r7, #40] ; 0x28
if (part_desc != NULL && is_extended(part_desc->sys_type))
395c: e3520000 cmp r2, #0
but we are to process each primary partition */
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
part_desc = disk_desc->partitions[part_num];
3960: e58d204c str r2, [sp, #76] ; 0x4c
if (part_desc != NULL && is_extended(part_desc->sys_type))
3964: 0a000009 beq 3990 <partition_table_get+0x188>
3968: e5d23001 ldrb r3, [r2, #1]
396c: e3530005 cmp r3, #5
3970: 13530085 cmpne r3, #133 ; 0x85
3974: 1a000005 bne 3990 <partition_table_get+0x188>
{
read_extended_partition(fd, part_desc->start, part_desc);
3978: e5921004 ldr r1, [r2, #4]
397c: e1a00006 mov r0, r6
3980: ebffff4e bl 36c0 <read_extended_partition>
free(part_desc);
3984: e59d004c ldr r0, [sp, #76] ; 0x4c
3988: eb0002a9 bl 4434 <free>
disk_desc->partitions[part_num] = NULL;
398c: e5878028 str r8, [r7, #40] ; 0x28
disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
/* There cannot be more than one extended partition,
but we are to process each primary partition */
for (part_num = 0;
3990: e2555001 subs r5, r5, #1
part_desc = disk_desc->partitions[part_num];
if (part_desc != NULL && is_extended(part_desc->sys_type))
{
read_extended_partition(fd, part_desc->start, part_desc);
free(part_desc);
disk_desc->partitions[part_num] = NULL;
3994: e2877004 add r7, r7, #4
disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
/* There cannot be more than one extended partition,
but we are to process each primary partition */
for (part_num = 0;
3998: 1affffee bne 3958 <partition_table_get+0x150>
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
RTEMS_IDE_SECTOR_SIZE;
rc = read_mbr(fd, disk_desc);
close(fd);
399c: e1a00006 mov r0, r6
39a0: eb000201 bl 41ac <close>
return rc;
39a4: ea000000 b 39ac <partition_table_get+0x1a4>
int fd;
fd = open(dev_name, O_RDONLY);
if (fd < 0)
{
return RTEMS_INTERNAL_ERROR;
39a8: e3a04019 mov r4, #25 <== NOT EXECUTED
rc = read_mbr(fd, disk_desc);
close(fd);
return rc;
}
39ac: e1a00004 mov r0, r4
39b0: e28dd050 add sp, sp, #80 ; 0x50
39b4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
000034e4 <pathconf>:
*/
long pathconf(
const char *path,
int name
)
{
34e4: e92d4030 push {r4, r5, lr}
34e8: e1a05001 mov r5, r1
int status;
int fd;
fd = open( path, O_RDONLY );
34ec: e3a01000 mov r1, #0
34f0: ebffff80 bl 32f8 <open>
if ( fd == -1 )
34f4: e3700001 cmn r0, #1
)
{
int status;
int fd;
fd = open( path, O_RDONLY );
34f8: e1a04000 mov r4, r0
if ( fd == -1 )
return -1;
34fc: 01a05000 moveq r5, r0
{
int status;
int fd;
fd = open( path, O_RDONLY );
if ( fd == -1 )
3500: 0a000004 beq 3518 <pathconf+0x34>
return -1;
status = fpathconf( fd, name );
3504: e1a01005 mov r1, r5 <== NOT EXECUTED
3508: eb0012e3 bl 809c <fpathconf> <== NOT EXECUTED
350c: e1a05000 mov r5, r0 <== NOT EXECUTED
(void) close( fd );
3510: e1a00004 mov r0, r4 <== NOT EXECUTED
3514: eb0012c2 bl 8024 <close> <== NOT EXECUTED
return status;
}
3518: e1a00005 mov r0, r5
351c: e8bd8030 pop {r4, r5, pc}
0000b2b0 <pipe_create>:
static uint16_t rtems_pipe_no = 0;
int pipe_create(
int filsdes[2]
)
{
b2b0: e92d403f push {r0, r1, r2, r3, r4, r5, lr}
b2b4: e1a04000 mov r4, r0
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
b2b8: e59f10f4 ldr r1, [pc, #244] ; b3b4 <pipe_create+0x104>
b2bc: e59f00f4 ldr r0, [pc, #244] ; b3b8 <pipe_create+0x108>
b2c0: eb0004e4 bl c658 <rtems_mkdir>
b2c4: e3500000 cmp r0, #0
b2c8: 1a000036 bne b3a8 <pipe_create+0xf8>
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
b2cc: e59f10e8 ldr r1, [pc, #232] ; b3bc <pipe_create+0x10c>
b2d0: e3a0200a mov r2, #10
b2d4: e1a0000d mov r0, sp
b2d8: eb001125 bl f774 <memcpy>
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
b2dc: e59f30dc ldr r3, [pc, #220] ; b3c0 <pipe_create+0x110>
b2e0: e1d320b0 ldrh r2, [r3]
b2e4: e2821001 add r1, r2, #1
b2e8: e1c310b0 strh r1, [r3]
b2ec: e28d000a add r0, sp, #10
b2f0: e59f10cc ldr r1, [pc, #204] ; b3c4 <pipe_create+0x114>
b2f4: eb00121e bl fb74 <sprintf>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
b2f8: e1a0000d mov r0, sp
b2fc: e3a01d06 mov r1, #384 ; 0x180
b300: eb00043d bl c3fc <mkfifo>
b304: e2505000 subs r5, r0, #0
b308: 0a000001 beq b314 <pipe_create+0x64>
if (errno != EEXIST){
b30c: eb000ede bl ee8c <__errno> <== NOT EXECUTED
b310: ea000024 b b3a8 <pipe_create+0xf8> <== 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);
b314: e1a0000d mov r0, sp
b318: e3a01901 mov r1, #16384 ; 0x4000
b31c: ebffe17c bl 3914 <open>
if (filsdes[0] < 0) {
b320: 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);
b324: e5840000 str r0, [r4]
if (filsdes[0] < 0) {
b328: aa000002 bge b338 <pipe_create+0x88>
err = errno;
b32c: eb000ed6 bl ee8c <__errno>
b330: e5905000 ldr r5, [r0]
b334: ea000014 b b38c <pipe_create+0xdc>
the file node will be deleted after it is closed by all. */
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
b338: e59f3088 ldr r3, [pc, #136] ; b3c8 <pipe_create+0x118>
b33c: e5933000 ldr r3, [r3]
b340: e1500003 cmp r0, r3
b344: 359f3080 ldrcc r3, [pc, #128] ; b3cc <pipe_create+0x11c>
b348: 35933000 ldrcc r3, [r3]
b34c: 33a05030 movcc r5, #48 ; 0x30
b350: 30253590 mlacc r5, r0, r5, r3
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
b354: e595300c ldr r3, [r5, #12]
b358: e3c33001 bic r3, r3, #1
b35c: e585300c str r3, [r5, #12]
filsdes[1] = open(fifopath, O_WRONLY);
b360: e1a0000d mov r0, sp
b364: e3a01001 mov r1, #1
b368: ebffe169 bl 3914 <open>
if (filsdes[1] < 0) {
b36c: e3500000 cmp r0, #0
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);
b370: e5840004 str r0, [r4, #4]
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
b374: a3a05000 movge r5, #0
iop = rtems_libio_iop(filsdes[0]);
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
if (filsdes[1] < 0) {
b378: aa000003 bge b38c <pipe_create+0xdc>
err = errno;
b37c: eb000ec2 bl ee8c <__errno>
b380: e5905000 ldr r5, [r0]
close(filsdes[0]);
b384: e5940000 ldr r0, [r4]
b388: ebffdd96 bl 29e8 <close>
}
unlink(fifopath);
b38c: e1a0000d mov r0, sp
b390: ebffec29 bl 643c <unlink>
} if(err != 0)
b394: e3550000 cmp r5, #0
rtems_set_errno_and_return_minus_one(err);
return 0;
b398: 01a00005 moveq r0, r5
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
b39c: 0a000002 beq b3ac <pipe_create+0xfc>
rtems_set_errno_and_return_minus_one(err);
b3a0: eb000eb9 bl ee8c <__errno>
b3a4: e5805000 str r5, [r0]
b3a8: e3e00000 mvn r0, #0
return 0; }
b3ac: e28dd010 add sp, sp, #16
b3b0: e8bd8030 pop {r4, r5, pc}
0000c6f0 <pipe_ioctl>:
ioctl_command_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
c6f0: e59f3058 ldr r3, [pc, #88] ; c750 <pipe_ioctl+0x60>
c6f4: e1510003 cmp r1, r3
pipe_control_t *pipe,
ioctl_command_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
c6f8: e92d4070 push {r4, r5, r6, lr}
c6fc: e1a04000 mov r4, r0
c700: e1a05002 mov r5, r2
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
c704: 13e00015 mvnne r0, #21
ioctl_command_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
c708: 18bd8070 popne {r4, r5, r6, pc}
if (buffer == NULL)
c70c: e3520000 cmp r2, #0
return -EFAULT;
c710: 03e0000d mvneq r0, #13
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
c714: 08bd8070 popeq {r4, r5, r6, pc}
return -EFAULT;
if (! PIPE_LOCK(pipe))
c718: e3a01000 mov r1, #0
c71c: e5940028 ldr r0, [r4, #40] ; 0x28
c720: e1a02001 mov r2, r1
c724: ebffec1c bl 779c <rtems_semaphore_obtain>
c728: e2506000 subs r6, r0, #0
c72c: 1a000005 bne c748 <pipe_ioctl+0x58>
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
c730: e594300c ldr r3, [r4, #12]
PIPE_UNLOCK(pipe);
c734: e5940028 ldr r0, [r4, #40] ; 0x28
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
c738: e5853000 str r3, [r5]
PIPE_UNLOCK(pipe);
c73c: ebffec5d bl 78b8 <rtems_semaphore_release>
return 0;
c740: e1a00006 mov r0, r6
c744: e8bd8070 pop {r4, r5, r6, pc}
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
if (! PIPE_LOCK(pipe))
return -EINTR;
c748: e3e00003 mvn r0, #3 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
}
c74c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
0000c3d4 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
c3d4: e92d47f1 push {r0, r4, r5, r6, r7, r8, r9, sl, lr}
c3d8: e1a09001 mov r9, r1
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
c3dc: e3a01000 mov r1, #0
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
c3e0: e1a04000 mov r4, r0
c3e4: e1a05002 mov r5, r2
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
c3e8: e5900028 ldr r0, [r0, #40] ; 0x28
c3ec: e1a02001 mov r2, r1
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
c3f0: e1a0a003 mov sl, r3
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
c3f4: ebffece8 bl 779c <rtems_semaphore_obtain>
c3f8: e2506000 subs r6, r0, #0
return -EINTR;
c3fc: 13e06003 mvnne r6, #3
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
c400: 0a000042 beq c510 <pipe_read+0x13c>
c404: ea00004c b c53c <pipe_read+0x168> <== NOT EXECUTED
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
c408: e5947014 ldr r7, [r4, #20]
c40c: e3570000 cmp r7, #0
c410: 0a000043 beq c524 <pipe_read+0x150>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
c414: e59a800c ldr r8, [sl, #12]
c418: e2188001 ands r8, r8, #1
c41c: 1a00003f bne c520 <pipe_read+0x14c>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
c420: e5943018 ldr r3, [r4, #24]
c424: e2833001 add r3, r3, #1
c428: e5843018 str r3, [r4, #24]
PIPE_UNLOCK(pipe);
c42c: e5940028 ldr r0, [r4, #40] ; 0x28
c430: ebffed20 bl 78b8 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
c434: e1a01008 mov r1, r8
c438: e594002c ldr r0, [r4, #44] ; 0x2c
c43c: eb000532 bl d90c <rtems_barrier_wait>
c440: e3500000 cmp r0, #0
c444: 01a07000 moveq r7, r0
c448: 13e07003 mvnne r7, #3
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
c44c: e1a01008 mov r1, r8
c450: e5940028 ldr r0, [r4, #40] ; 0x28
c454: e1a02008 mov r2, r8
c458: ebffeccf bl 779c <rtems_semaphore_obtain>
c45c: e3500000 cmp r0, #0
c460: 1a000032 bne c530 <pipe_read+0x15c>
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
c464: e5943018 ldr r3, [r4, #24]
if (ret != 0)
c468: e3570000 cmp r7, #0
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
c46c: e2433001 sub r3, r3, #1
c470: e5843018 str r3, [r4, #24]
if (ret != 0)
c474: 1a00002a bne c524 <pipe_read+0x150>
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
c478: e594300c ldr r3, [r4, #12]
c47c: e3530000 cmp r3, #0
c480: 0affffe0 beq c408 <pipe_read+0x34>
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
c484: e0667005 rsb r7, r6, r5
c488: e1530007 cmp r3, r7
c48c: 31a07003 movcc r7, r3
chunk1 = pipe->Size - pipe->Start;
c490: e5948004 ldr r8, [r4, #4]
c494: e5943008 ldr r3, [r4, #8]
c498: e5941000 ldr r1, [r4]
c49c: e0638008 rsb r8, r3, r8
if (chunk > chunk1) {
c4a0: e1570008 cmp r7, r8
c4a4: e0890006 add r0, r9, r6
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
c4a8: e0811003 add r1, r1, r3
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
c4ac: d1a02007 movle r2, r7
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
c4b0: da000005 ble c4cc <pipe_read+0xf8>
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
c4b4: e1a02008 mov r2, r8
c4b8: eb00102c bl 10570 <memcpy>
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
c4bc: e0860008 add r0, r6, r8
c4c0: e5941000 ldr r1, [r4]
c4c4: e0890000 add r0, r9, r0
c4c8: e0682007 rsb r2, r8, r7
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
c4cc: eb001027 bl 10570 <memcpy>
pipe->Start += chunk;
c4d0: e5940008 ldr r0, [r4, #8]
pipe->Start %= pipe->Size;
c4d4: e5941004 ldr r1, [r4, #4]
c4d8: e0870000 add r0, r7, r0
c4dc: eb00404d bl 1c618 <__umodsi3>
pipe->Length -= chunk;
c4e0: e594300c ldr r3, [r4, #12]
c4e4: e0673003 rsb r3, r7, r3
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
c4e8: e3530000 cmp r3, #0
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
c4ec: e5840008 str r0, [r4, #8]
pipe->Length -= chunk;
c4f0: e584300c str r3, [r4, #12]
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
c4f4: 05843008 streq r3, [r4, #8]
if (pipe->waitingWriters > 0)
c4f8: e594301c ldr r3, [r4, #28]
c4fc: e3530000 cmp r3, #0
PIPE_WAKEUPWRITERS(pipe);
c500: 15940030 ldrne r0, [r4, #48] ; 0x30
c504: 11a0100d movne r1, sp
c508: 1b0004e9 blne d8b4 <rtems_barrier_release>
read += chunk;
c50c: e0866007 add r6, r6, r7
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
c510: e1560005 cmp r6, r5
c514: 3affffd7 bcc c478 <pipe_read+0xa4>
c518: e3a07000 mov r7, #0
c51c: ea000000 b c524 <pipe_read+0x150>
/* Not an error */
if (pipe->Writers == 0)
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
c520: e3e0700a mvn r7, #10
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
c524: e5940028 ldr r0, [r4, #40] ; 0x28
c528: ebffece2 bl 78b8 <rtems_semaphore_release>
c52c: ea000000 b c534 <pipe_read+0x160>
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
c530: e3e07003 mvn r7, #3 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
return read;
return ret;
c534: e3560000 cmp r6, #0
c538: d1a06007 movle r6, r7
}
c53c: e1a00006 mov r0, r6
c540: e8bd87f8 pop {r3, r4, r5, r6, r7, r8, r9, sl, pc}
0000c544 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
c544: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
c548: e2527000 subs r7, r2, #0
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
c54c: e1a04000 mov r4, r0
c550: e1a0b001 mov fp, r1
c554: e1a08003 mov r8, r3
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
c558: 01a05007 moveq r5, r7
)
{
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
c55c: 0a000061 beq c6e8 <pipe_write+0x1a4>
return 0;
if (! PIPE_LOCK(pipe))
c560: e3a01000 mov r1, #0
c564: e5900028 ldr r0, [r0, #40] ; 0x28
c568: e1a02001 mov r2, r1
c56c: ebffec8a bl 779c <rtems_semaphore_obtain>
c570: e3500000 cmp r0, #0
return -EINTR;
c574: 13e05003 mvnne r5, #3
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
c578: 1a00005a bne c6e8 <pipe_write+0x1a4>
return -EINTR;
if (pipe->Readers == 0) {
c57c: e5945010 ldr r5, [r4, #16]
c580: e3550000 cmp r5, #0
c584: 0a00004b beq c6b8 <pipe_write+0x174>
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
c588: e5949004 ldr r9, [r4, #4]
c58c: e1570009 cmp r7, r9
c590: 91a09007 movls r9, r7
c594: 83a09001 movhi r9, #1
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
c598: e1a05000 mov r5, r0
c59c: ea00003f b c6a0 <pipe_write+0x15c>
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
c5a0: e598a00c ldr sl, [r8, #12]
c5a4: e21aa001 ands sl, sl, #1
c5a8: 1a000040 bne c6b0 <pipe_write+0x16c>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
c5ac: e594301c ldr r3, [r4, #28]
c5b0: e2833001 add r3, r3, #1
c5b4: e584301c str r3, [r4, #28]
PIPE_UNLOCK(pipe);
c5b8: e5940028 ldr r0, [r4, #40] ; 0x28
c5bc: ebffecbd bl 78b8 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
c5c0: e1a0100a mov r1, sl
c5c4: e5940030 ldr r0, [r4, #48] ; 0x30
c5c8: eb0004cf bl d90c <rtems_barrier_wait>
c5cc: e3500000 cmp r0, #0
c5d0: 01a06000 moveq r6, r0
c5d4: 13e06003 mvnne r6, #3
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
c5d8: e1a0100a mov r1, sl
c5dc: e5940028 ldr r0, [r4, #40] ; 0x28
c5e0: e1a0200a mov r2, sl
c5e4: ebffec6c bl 779c <rtems_semaphore_obtain>
c5e8: e3500000 cmp r0, #0
c5ec: 1a00003a bne c6dc <pipe_write+0x198>
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
c5f0: e594301c ldr r3, [r4, #28]
if (ret != 0)
c5f4: e3560000 cmp r6, #0
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
c5f8: e2433001 sub r3, r3, #1
c5fc: e584301c str r3, [r4, #28]
if (ret != 0)
c600: 1a00002d bne c6bc <pipe_write+0x178>
goto out_locked;
if (pipe->Readers == 0) {
c604: e5943010 ldr r3, [r4, #16]
c608: e3530000 cmp r3, #0
c60c: 0a000029 beq c6b8 <pipe_write+0x174>
/* 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) {
c610: e594a004 ldr sl, [r4, #4]
c614: e594300c ldr r3, [r4, #12]
c618: e063200a rsb r2, r3, sl
c61c: e1520009 cmp r2, r9
c620: 3affffde bcc c5a0 <pipe_write+0x5c>
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
c624: e5940008 ldr r0, [r4, #8]
c628: e1a0100a mov r1, sl
c62c: e0830000 add r0, r3, r0
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
c630: e0656007 rsb r6, r5, r7
c634: e1520006 cmp r2, r6
c638: 31a06002 movcc r6, r2
chunk1 = pipe->Size - PIPE_WSTART(pipe);
c63c: eb003ff5 bl 1c618 <__umodsi3>
c640: e5943000 ldr r3, [r4]
c644: e060a00a rsb sl, r0, sl
if (chunk > chunk1) {
c648: e156000a cmp r6, sl
c64c: e08b1005 add r1, fp, r5
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
c650: e0830000 add r0, r3, r0
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
c654: d1a02006 movle r2, r6
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
if (chunk > chunk1) {
c658: da000005 ble c674 <pipe_write+0x130>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
c65c: e1a0200a mov r2, sl
c660: eb000fc2 bl 10570 <memcpy>
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
c664: e08a1005 add r1, sl, r5
c668: e5940000 ldr r0, [r4]
c66c: e08b1001 add r1, fp, r1
c670: e06a2006 rsb r2, sl, r6
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
c674: eb000fbd bl 10570 <memcpy>
pipe->Length += chunk;
c678: e594300c ldr r3, [r4, #12]
c67c: e0833006 add r3, r3, r6
c680: e584300c str r3, [r4, #12]
if (pipe->waitingReaders > 0)
c684: e5943018 ldr r3, [r4, #24]
c688: e3530000 cmp r3, #0
PIPE_WAKEUPREADERS(pipe);
c68c: 1594002c ldrne r0, [r4, #44] ; 0x2c
c690: 11a0100d movne r1, sp
c694: 1b000486 blne d8b4 <rtems_barrier_release>
written += chunk;
c698: e0855006 add r5, r5, r6
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
c69c: e3a09001 mov r9, #1
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
c6a0: e1550007 cmp r5, r7
c6a4: 3affffd9 bcc c610 <pipe_write+0xcc>
c6a8: e3a06000 mov r6, #0
c6ac: ea000002 b c6bc <pipe_write+0x178>
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
c6b0: e3e0600a mvn r6, #10
c6b4: ea000000 b c6bc <pipe_write+0x178>
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
c6b8: e3e0601f mvn r6, #31
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
c6bc: e5940028 ldr r0, [r4, #40] ; 0x28
c6c0: ebffec7c bl 78b8 <rtems_semaphore_release>
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
c6c4: e3760020 cmn r6, #32
c6c8: 1a000004 bne c6e0 <pipe_write+0x19c>
kill(getpid(), SIGPIPE);
c6cc: eb00011e bl cb4c <getpid>
c6d0: e3a0100d mov r1, #13
c6d4: eb000277 bl d0b8 <kill>
c6d8: ea000000 b c6e0 <pipe_write+0x19c>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
c6dc: e3e06003 mvn r6, #3 <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
c6e0: e3550000 cmp r5, #0
c6e4: d1a05006 movle r5, r6
return written;
return ret;
}
c6e8: e1a00005 mov r0, r5
c6ec: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000a594 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
a594: e3500000 cmp r0, #0
a598: 0a00000b beq a5cc <pthread_attr_setschedpolicy+0x38>
a59c: e5903000 ldr r3, [r0]
a5a0: e3530000 cmp r3, #0
a5a4: 0a000008 beq a5cc <pthread_attr_setschedpolicy+0x38>
return EINVAL;
switch ( policy ) {
a5a8: e3510004 cmp r1, #4
a5ac: 8a000008 bhi a5d4 <pthread_attr_setschedpolicy+0x40>
a5b0: e3a03001 mov r3, #1
a5b4: e1a03113 lsl r3, r3, r1
a5b8: e3130017 tst r3, #23
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
a5bc: 15801014 strne r1, [r0, #20]
return 0;
a5c0: 13a00000 movne r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( policy ) {
a5c4: 112fff1e bxne lr
a5c8: ea000001 b a5d4 <pthread_attr_setschedpolicy+0x40> <== NOT EXECUTED
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
a5cc: e3a00016 mov r0, #22
a5d0: e12fff1e bx lr
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
a5d4: e3a00086 mov r0, #134 ; 0x86
} }
a5d8: e12fff1e bx lr
00018f20 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
18f20: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr}
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
18f24: e2517000 subs r7, r1, #0
18f28: 0a000002 beq 18f38 <pthread_kill+0x18>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
18f2c: e2478001 sub r8, r7, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
18f30: e358001f cmp r8, #31
18f34: 9a000002 bls 18f44 <pthread_kill+0x24>
rtems_set_errno_and_return_minus_one( EINVAL );
18f38: ebffd1fd bl d734 <__errno> 18f3c: e3a03016 mov r3, #22 18f40: ea000025 b 18fdc <pthread_kill+0xbc>
the_thread = _Thread_Get( thread, &location );
18f44: e1a0100d mov r1, sp 18f48: ebffbdc2 bl 8658 <_Thread_Get>
switch ( location ) {
18f4c: e59d6000 ldr r6, [sp] 18f50: e3560000 cmp r6, #0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _Thread_Get( thread, &location );
18f54: e1a04000 mov r4, r0
switch ( location ) {
18f58: 1a00001d bne 18fd4 <pthread_kill+0xb4>
18f5c: e59f0084 ldr r0, [pc, #132] ; 18fe8 <pthread_kill+0xc8> 18f60: ebffb645 bl 687c <_API_extensions_Add_post_switch>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
18f64: e59f2080 ldr r2, [pc, #128] ; 18fec <pthread_kill+0xcc> 18f68: e3a0100c mov r1, #12 18f6c: e0222791 mla r2, r1, r7, r2 18f70: e5922008 ldr r2, [r2, #8] 18f74: e3520001 cmp r2, #1
* If sig == 0 then just validate arguments
*/
_POSIX_signals_Add_post_switch_extension();
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
18f78: e59430f4 ldr r3, [r4, #244] ; 0xf4
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
18f7c: 1a000002 bne 18f8c <pthread_kill+0x6c>
_Thread_Enable_dispatch();
18f80: ebffbdac bl 8638 <_Thread_Enable_dispatch>
return 0;
18f84: e1a00006 mov r0, r6 18f88: ea000015 b 18fe4 <pthread_kill+0xc4>
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
18f8c: e59320d4 ldr r2, [r3, #212] ; 0xd4
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
18f90: e3a05001 mov r5, #1 18f94: e1828815 orr r8, r2, r5, lsl r8
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
18f98: e1a00004 mov r0, r4
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
18f9c: e58380d4 str r8, [r3, #212] ; 0xd4
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
18fa0: e1a02006 mov r2, r6 18fa4: e1a01007 mov r1, r7 18fa8: ebffff97 bl 18e0c <_POSIX_signals_Unblock_thread>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
18fac: e59f303c ldr r3, [pc, #60] ; 18ff0 <pthread_kill+0xd0> 18fb0: e5932000 ldr r2, [r3] 18fb4: e3520000 cmp r2, #0
18fb8: 0a000002 beq 18fc8 <pthread_kill+0xa8>
18fbc: e5932008 ldr r2, [r3, #8] 18fc0: e1540002 cmp r4, r2
_Thread_Dispatch_necessary = true;
18fc4: 05c35004 strbeq r5, [r3, #4]
}
_Thread_Enable_dispatch();
18fc8: ebffbd9a bl 8638 <_Thread_Enable_dispatch>
return 0;
18fcc: e3a00000 mov r0, #0 18fd0: ea000003 b 18fe4 <pthread_kill+0xc4>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
18fd4: ebffd1d6 bl d734 <__errno> <== NOT EXECUTED 18fd8: e3a03003 mov r3, #3 <== NOT EXECUTED
18fdc: e5803000 str r3, [r0] 18fe0: e3e00000 mvn r0, #0
}
18fe4: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc}
0000584c <pthread_mutexattr_gettype>:
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
if ( !attr )
584c: e3500000 cmp r0, #0
5850: 0a000008 beq 5878 <pthread_mutexattr_gettype+0x2c>
return EINVAL;
if ( !attr->is_initialized )
5854: e5903000 ldr r3, [r0]
5858: e3530000 cmp r3, #0
585c: 0a000005 beq 5878 <pthread_mutexattr_gettype+0x2c>
return EINVAL;
if ( !type )
5860: e3510000 cmp r1, #0
return EINVAL;
*type = attr->type;
5864: 15903010 ldrne r3, [r0, #16]
return 0;
5868: 13a00000 movne r0, #0
return EINVAL;
if ( !type )
return EINVAL;
*type = attr->type;
586c: 15813000 strne r3, [r1]
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
if ( !type )
5870: 112fff1e bxne lr
5874: ea000001 b 5880 <pthread_mutexattr_gettype+0x34> <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
5878: e3a00016 mov r0, #22
587c: e12fff1e bx lr
if ( !type )
return EINVAL;
5880: e3a00016 mov r0, #22 <== NOT EXECUTED
*type = attr->type;
return 0;
}
5884: e12fff1e bx lr <== NOT EXECUTED
00007d80 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
7d80: e3500000 cmp r0, #0
7d84: 0a000007 beq 7da8 <pthread_mutexattr_setpshared+0x28>
7d88: e5903000 ldr r3, [r0]
7d8c: e3530000 cmp r3, #0
7d90: 0a000004 beq 7da8 <pthread_mutexattr_setpshared+0x28>
return EINVAL;
switch ( pshared ) {
7d94: e3510001 cmp r1, #1
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
7d98: 95801004 strls r1, [r0, #4]
return 0;
7d9c: 93a00000 movls r0, #0
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
7da0: 912fff1e bxls lr
7da4: ea000001 b 7db0 <pthread_mutexattr_setpshared+0x30> <== NOT EXECUTED
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
7da8: e3a00016 mov r0, #22
7dac: e12fff1e bx lr
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
7db0: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
7db4: e12fff1e bx lr <== NOT EXECUTED
00007a8c <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
7a8c: e3500000 cmp r0, #0
7a90: 0a000007 beq 7ab4 <pthread_rwlockattr_setpshared+0x28>
return EINVAL;
if ( !attr->is_initialized )
7a94: e5903000 ldr r3, [r0]
7a98: e3530000 cmp r3, #0
7a9c: 0a000004 beq 7ab4 <pthread_rwlockattr_setpshared+0x28>
return EINVAL;
switch ( pshared ) {
7aa0: e3510001 cmp r1, #1
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
7aa4: 95801004 strls r1, [r0, #4]
return 0;
7aa8: 93a00000 movls r0, #0
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
switch ( pshared ) {
7aac: 912fff1e bxls lr
7ab0: ea000001 b 7abc <pthread_rwlockattr_setpshared+0x30> <== NOT EXECUTED
{
if ( !attr )
return EINVAL;
if ( !attr->is_initialized )
return EINVAL;
7ab4: e3a00016 mov r0, #22
7ab8: e12fff1e bx lr
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
7abc: e3a00016 mov r0, #22 <== NOT EXECUTED
} }
7ac0: e12fff1e bx lr <== NOT EXECUTED
0000abfc <ramdisk_allocate>:
void *area_begin,
uint32_t media_block_size,
rtems_blkdev_bnum media_block_count,
bool trace
)
{
abfc: e92d41f0 push {r4, r5, r6, r7, r8, lr}
ac00: e1a04000 mov r4, r0
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
ac04: e3a00010 mov r0, #16
void *area_begin,
uint32_t media_block_size,
rtems_blkdev_bnum media_block_count,
bool trace
)
{
ac08: e1a05001 mov r5, r1
ac0c: e1a06002 mov r6, r2
ac10: e20380ff and r8, r3, #255 ; 0xff
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
ac14: ebffe333 bl 38e8 <malloc>
if (rd == NULL) {
ac18: e2507000 subs r7, r0, #0
ac1c: 0a000012 beq ac6c <ramdisk_allocate+0x70>
return NULL;
}
if (area_begin == NULL) {
ac20: e3540000 cmp r4, #0
return NULL;
}
rd->malloced = true;
} else {
rd->malloced = false;
ac24: 13a03000 movne r3, #0
if (rd == NULL) {
return NULL;
}
if (area_begin == NULL) {
ac28: 1a000009 bne ac54 <ramdisk_allocate+0x58>
area_begin = calloc(media_block_count, media_block_size);
ac2c: e1a00006 mov r0, r6
ac30: e1a01005 mov r1, r5
ac34: ebffe149 bl 3160 <calloc>
if (area_begin == NULL) {
ac38: e2504000 subs r4, r0, #0
free(rd);
return NULL;
}
rd->malloced = true;
ac3c: 13a03001 movne r3, #1
return NULL;
}
if (area_begin == NULL) {
area_begin = calloc(media_block_count, media_block_size);
if (area_begin == NULL) {
ac40: 1a000003 bne ac54 <ramdisk_allocate+0x58>
free(rd);
ac44: e1a00007 mov r0, r7 <== NOT EXECUTED
ac48: ebffe1f8 bl 3430 <free> <== NOT EXECUTED
return NULL;
ac4c: e1a07004 mov r7, r4 <== NOT EXECUTED
ac50: ea000005 b ac6c <ramdisk_allocate+0x70> <== NOT EXECUTED
}
rd->malloced = true;
} else {
rd->malloced = false;
ac54: e5c7300d strb r3, [r7, #13]
} rd->block_size = media_block_size; rd->block_num = media_block_count;
ac58: e8870060 stm r7, {r5, r6}
rd->area = area_begin; rd->trace = trace; rd->initialized = true;
ac5c: e3a03001 mov r3, #1
} else {
rd->malloced = false;
}
rd->block_size = media_block_size;
rd->block_num = media_block_count;
rd->area = area_begin;
ac60: e5874008 str r4, [r7, #8]
rd->trace = trace;
ac64: e5c7800e strb r8, [r7, #14]
rd->initialized = true;
ac68: e5c7300c strb r3, [r7, #12]
return rd;
}
ac6c: e1a00007 mov r0, r7
ac70: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
0000bd88 <ramdisk_initialize>:
rtems_device_driver
ramdisk_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *arg __attribute__((unused)))
{
bd88: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
bd8c: e24dd01c sub sp, sp, #28
bd90: e1a09000 mov r9, r0
rtems_device_minor_number i;
rtems_ramdisk_config *c = rtems_ramdisk_configuration;
struct ramdisk *r;
rtems_status_code rc;
rc = rtems_disk_io_initialize();
bd94: ebffdd9d bl 3410 <rtems_disk_io_initialize>
if (rc != RTEMS_SUCCESSFUL)
bd98: e2505000 subs r5, r0, #0
bd9c: 11a00005 movne r0, r5
bda0: 1a00003c bne be98 <ramdisk_initialize+0x110>
* 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));
bda4: e59f80f4 ldr r8, [pc, #244] ; bea0 <ramdisk_initialize+0x118>
bda8: e3a01010 mov r1, #16
bdac: e5980000 ldr r0, [r8]
bdb0: ebffe0eb bl 4164 <calloc>
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *arg __attribute__((unused)))
{
rtems_device_minor_number i;
rtems_ramdisk_config *c = rtems_ramdisk_configuration;
bdb4: e59f60e8 ldr r6, [pc, #232] ; bea4 <ramdisk_initialize+0x11c>
* 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));
bdb8: e1a04000 mov r4, r0
r->trace = false;
bdbc: e5c0500e strb r5, [r0, #14]
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";
bdc0: e28d7010 add r7, sp, #16
* 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++)
bdc4: ea00002f b be88 <ramdisk_initialize+0x100>
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
bdc8: e3a02009 mov r2, #9
bdcc: e1a00007 mov r0, r7
bdd0: e59f10d0 ldr r1, [pc, #208] ; bea8 <ramdisk_initialize+0x120>
bdd4: eb001cf9 bl 131c0 <memcpy>
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
bdd8: e5dd3018 ldrb r3, [sp, #24]
r->block_size = c->block_size;
r->block_num = c->block_num;
if (c->location == NULL)
bddc: e5962008 ldr r2, [r6, #8]
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;
bde0: e596b000 ldr fp, [r6]
r->block_num = c->block_num;
bde4: e596a004 ldr sl, [r6, #4]
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;
bde8: e0853003 add r3, r5, r3
r->block_size = c->block_size;
r->block_num = c->block_num;
if (c->location == NULL)
bdec: e3520000 cmp r2, #0
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;
bdf0: e5cd3018 strb r3, [sp, #24]
r->block_size = c->block_size;
bdf4: e584b000 str fp, [r4]
r->block_num = c->block_num;
bdf8: e584a004 str sl, [r4, #4]
bdfc: e3a03001 mov r3, #1
if (c->location == NULL)
be00: 1a00000a bne be30 <ramdisk_initialize+0xa8>
{
r->malloced = true;
r->area = malloc(r->block_size * r->block_num);
be04: e0000a9b mul r0, fp, sl
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;
be08: e5c4300d strb r3, [r4, #13]
r->area = malloc(r->block_size * r->block_num);
be0c: e58d300c str r3, [sp, #12]
be10: ebffe2f7 bl 49f4 <malloc>
if (r->area == NULL) /* No enough memory for this disk */
be14: e59d300c ldr r3, [sp, #12]
be18: e3500000 cmp r0, #0
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);
be1c: e5840008 str r0, [r4, #8]
if (r->area == NULL) /* No enough memory for this disk */
{
r->initialized = false;
be20: 05c4000c strbeq r0, [r4, #12]
continue;
}
else
{
r->initialized = true;
be24: 15c4300c strbne r3, [r4, #12]
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 */
be28: 1a000004 bne be40 <ramdisk_initialize+0xb8>
be2c: ea000012 b be7c <ramdisk_initialize+0xf4> <== NOT EXECUTED
r->initialized = true;
}
}
else
{
r->malloced = false;
be30: e3a01000 mov r1, #0 <== NOT EXECUTED
be34: e5c4100d strb r1, [r4, #13] <== NOT EXECUTED
r->initialized = true;
be38: e5c4300c strb r3, [r4, #12] <== NOT EXECUTED
r->area = c->location;
be3c: e5842008 str r2, [r4, #8] <== NOT EXECUTED
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
be40: e59f3064 ldr r3, [pc, #100] ; beac <ramdisk_initialize+0x124>
be44: e1a00009 mov r0, r9
be48: e88d0098 stm sp, {r3, r4, r7}
be4c: e1a01005 mov r1, r5
be50: e1a0200b mov r2, fp
be54: e1a0300a mov r3, sl
be58: ebffdcd8 bl 31c0 <rtems_disk_create_phys>
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
be5c: e3500000 cmp r0, #0
be60: 0a000005 beq be7c <ramdisk_initialize+0xf4>
{
if (r->malloced)
be64: e5d4300d ldrb r3, [r4, #13] <== NOT EXECUTED
be68: e3530000 cmp r3, #0 <== NOT EXECUTED
{
free(r->area);
be6c: 15940008 ldrne r0, [r4, #8] <== NOT EXECUTED
be70: 1bffe16f blne 4434 <free> <== NOT EXECUTED
}
r->initialized = false;
be74: e3a03000 mov r3, #0 <== NOT EXECUTED
be78: e5c4300c strb r3, [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++)
be7c: e2855001 add r5, r5, #1
be80: e286600c add r6, r6, #12
be84: e2844010 add r4, r4, #16
be88: e5983000 ldr r3, [r8]
be8c: e1550003 cmp r5, r3
be90: 3affffcc bcc bdc8 <ramdisk_initialize+0x40>
free(r->area);
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
be94: e3a00000 mov r0, #0
}
be98: e28dd01c add sp, sp, #28
be9c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000aae4 <ramdisk_ioctl>:
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
aae4: e59fc108 ldr ip, [pc, #264] ; abf4 <ramdisk_ioctl+0x110>
aae8: e151000c cmp r1, ip
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
aaec: e92d41f0 push {r4, r5, r6, r7, r8, lr}
aaf0: e1a04002 mov r4, r2
static inline void *rtems_disk_get_driver_data(
const rtems_disk_device *dd
)
{
return dd->driver_data;
aaf4: e590503c ldr r5, [r0, #60] ; 0x3c
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
aaf8: 0a000030 beq abc0 <ramdisk_ioctl+0xdc>
aafc: e59fc0f4 ldr ip, [pc, #244] ; abf8 <ramdisk_ioctl+0x114>
ab00: e151000c cmp r1, ip
ab04: 1a000033 bne abd8 <ramdisk_ioctl+0xf4>
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
ab08: e5927000 ldr r7, [r2]
ab0c: e3570000 cmp r7, #0
#endif
static int
ramdisk_read(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *from = rd->area;
ab10: 05958008 ldreq r8, [r5, #8]
#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++)
ab14: 02826018 addeq r6, r2, #24
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
ab18: 0a000009 beq ab44 <ramdisk_ioctl+0x60>
ab1c: e3570001 cmp r7, #1
ab20: 1a000021 bne abac <ramdisk_ioctl+0xc8>
ab24: ea00000b b ab58 <ramdisk_ioctl+0x74>
#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);
ab28: e5163010 ldr r3, [r6, #-16]
ab2c: e5951000 ldr r1, [r5]
ab30: e5160008 ldr r0, [r6, #-8]
ab34: e0218193 mla r1, r3, r1, r8
ab38: e516200c ldr r2, [r6, #-12]
ab3c: eb001d07 bl 11f60 <memcpy>
#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++)
ab40: e2877001 add r7, r7, #1
ab44: e5943010 ldr r3, [r4, #16]
ab48: e1570003 cmp r7, r3
ab4c: e2866010 add r6, r6, #16
ab50: 3afffff4 bcc ab28 <ramdisk_ioctl+0x44>
ab54: ea00000e b ab94 <ramdisk_ioctl+0xb0>
}
static int
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *to = rd->area;
ab58: e5958008 ldr r8, [r5, #8]
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
ab5c: e2826018 add r6, r2, #24
ab60: e3a07000 mov r7, #0
ab64: ea000006 b ab84 <ramdisk_ioctl+0xa0>
#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);
ab68: e5163010 ldr r3, [r6, #-16]
ab6c: e5950000 ldr r0, [r5]
ab70: e5161008 ldr r1, [r6, #-8]
ab74: e0208093 mla r0, r3, r0, r8
ab78: e516200c ldr r2, [r6, #-12]
ab7c: eb001cf7 bl 11f60 <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++)
ab80: e2877001 add r7, r7, #1
ab84: e5943010 ldr r3, [r4, #16]
ab88: e1570003 cmp r7, r3
ab8c: e2866010 add r6, r6, #16
ab90: 3afffff4 bcc ab68 <ramdisk_ioctl+0x84>
static inline void rtems_blkdev_request_done(
rtems_blkdev_request *req,
rtems_status_code status
)
{
(*req->done)(req, status);
ab94: e1a00004 mov r0, r4
ab98: e3a01000 mov r1, #0
ab9c: e1a0e00f mov lr, pc
aba0: 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);
aba4: e3a00000 mov r0, #0
aba8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
default:
errno = EINVAL;
abac: eb001ab1 bl 11678 <__errno> <== NOT EXECUTED
abb0: e3a03016 mov r3, #22 <== NOT EXECUTED
abb4: e5803000 str r3, [r0] <== NOT EXECUTED
return -1;
abb8: e3e00000 mvn r0, #0 <== NOT EXECUTED
abbc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
}
break;
}
case RTEMS_BLKIO_DELETED:
if (rd->free_at_delete_request) {
abc0: e5d5300f ldrb r3, [r5, #15]
abc4: e3530000 cmp r3, #0
abc8: 0a000004 beq abe0 <ramdisk_ioctl+0xfc>
ramdisk_free(rd);
abcc: e1a00005 mov r0, r5
abd0: eb000027 bl ac74 <ramdisk_free>
abd4: ea000001 b abe0 <ramdisk_ioctl+0xfc>
break;
}
errno = EINVAL;
return -1;
}
abd8: e8bd41f0 pop {r4, r5, r6, r7, r8, lr}
ramdisk_free(rd);
}
break;
default:
return rtems_blkdev_ioctl (dd, req, argp);
abdc: ea000955 b d138 <rtems_blkdev_ioctl>
break;
}
errno = EINVAL;
abe0: eb001aa4 bl 11678 <__errno>
abe4: e3a03016 mov r3, #22
abe8: e5803000 str r3, [r0]
return -1;
abec: e3e00000 mvn r0, #0
}
abf0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
0000ac9c <ramdisk_register>:
rtems_blkdev_bnum media_block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
ac9c: e92d47ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, lr}
aca0: e1a07000 mov r7, r0
aca4: e20240ff and r4, r2, #255 ; 0xff
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_device_major_number major = 0;
aca8: e3a00000 mov r0, #0
acac: e28d2010 add r2, sp, #16
rtems_blkdev_bnum media_block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
acb0: e1a06001 mov r6, r1
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_device_major_number major = 0;
acb4: e5220004 str r0, [r2, #-4]!
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
acb8: e59f1074 ldr r1, [pc, #116] ; ad34 <ramdisk_register+0x98>
rtems_blkdev_bnum media_block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
acbc: e1a08003 mov r8, r3
acc0: 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);
acc4: ebfff355 bl 7a20 <rtems_io_register_driver>
if (sc != RTEMS_SUCCESSFUL) {
acc8: e250a000 subs sl, r0, #0
accc: 1a000015 bne ad28 <ramdisk_register+0x8c>
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, media_block_size, media_block_count, trace);
acd0: e1a01007 mov r1, r7
acd4: e1a02006 mov r2, r6
acd8: e1a03004 mov r3, r4
acdc: ebffffc6 bl abfc <ramdisk_allocate>
if (rd == NULL) {
ace0: e2505000 subs r5, r0, #0
ace4: 0a00000d beq ad20 <ramdisk_register+0x84>
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
ace8: e59d400c ldr r4, [sp, #12]
return RTEMS_UNSATISFIED;
}
dev = rtems_filesystem_make_dev_t(major, 0);
sc = rtems_disk_create_phys(
acec: e59f3044 ldr r3, [pc, #68] ; ad38 <ramdisk_register+0x9c>
acf0: e1a00004 mov r0, r4
acf4: e88d0128 stm sp, {r3, r5, r8}
acf8: e1a0100a mov r1, sl
acfc: e1a02007 mov r2, r7
ad00: e1a03006 mov r3, r6
ad04: ebffde9b bl 2778 <rtems_disk_create_phys>
media_block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
ad08: e3500000 cmp r0, #0
rtems_io_unregister_driver(major);
return RTEMS_UNSATISFIED;
}
*dev_ptr = dev;
ad0c: 05894000 streq r4, [r9]
ad10: 05890004 streq r0, [r9, #4]
media_block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
ad14: 0a000004 beq ad2c <ramdisk_register+0x90>
ramdisk_free(rd);
ad18: e1a00005 mov r0, r5 <== NOT EXECUTED
ad1c: ebffffd4 bl ac74 <ramdisk_free> <== NOT EXECUTED
rtems_io_unregister_driver(major);
ad20: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED
ad24: ebfff39b bl 7b98 <rtems_io_unregister_driver> <== NOT EXECUTED
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
if (sc != RTEMS_SUCCESSFUL) {
return RTEMS_UNSATISFIED;
ad28: e3a0000d mov r0, #13 <== NOT EXECUTED
}
*dev_ptr = dev;
return RTEMS_SUCCESSFUL;
}
ad2c: e28dd010 add sp, sp, #16
ad30: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
00018a14 <read>:
size_t count
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
18a14: e59fc07c ldr ip, [pc, #124] ; 18a98 <read+0x84> 18a18: e59cc000 ldr ip, [ip] 18a1c: e150000c cmp r0, ip
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
18a20: e92d4030 push {r4, r5, lr}
18a24: e1a04001 mov r4, r1
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
18a28: 2a00000f bcs 18a6c <read+0x58>
iop = rtems_libio_iop( fd );
18a2c: e59fc068 ldr ip, [pc, #104] ; 18a9c <read+0x88> 18a30: e59cc000 ldr ip, [ip] 18a34: e3a05030 mov r5, #48 ; 0x30 18a38: e020c095 mla r0, r5, r0, ip
rtems_libio_check_is_open( iop );
18a3c: e590c00c ldr ip, [r0, #12] 18a40: e31c0c01 tst ip, #256 ; 0x100
18a44: 0a000008 beq 18a6c <read+0x58> rtems_libio_check_buffer( buffer );
18a48: e3510000 cmp r1, #0
18a4c: 1a000002 bne 18a5c <read+0x48>
18a50: ebffd337 bl d734 <__errno> <== NOT EXECUTED 18a54: e3a03016 mov r3, #22 <== NOT EXECUTED 18a58: ea000005 b 18a74 <read+0x60> <== NOT EXECUTED
rtems_libio_check_count( count );
18a5c: e3520000 cmp r2, #0
18a60: 0a00000a beq 18a90 <read+0x7c> rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
18a64: e31c0002 tst ip, #2
18a68: 1a000004 bne 18a80 <read+0x6c>
18a6c: ebffd330 bl d734 <__errno>
18a70: e3a03009 mov r3, #9
18a74: e5803000 str r3, [r0]
18a78: e3e00000 mvn r0, #0
18a7c: e8bd8030 pop {r4, r5, pc}
/*
* Now process the read().
*/
return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
18a80: e5903020 ldr r3, [r0, #32]
18a84: e1a0e00f mov lr, pc
18a88: e593f008 ldr pc, [r3, #8]
18a8c: e8bd8030 pop {r4, r5, pc}
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
18a90: e1a00002 mov r0, r2
/*
* Now process the read().
*/
return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
}
18a94: e8bd8030 pop {r4, r5, pc}
000036c0 <read_extended_partition>:
* RTEMS_NO_MEMOTY if cannot allocate memory for part_desc_t strucure,
* RTEMS_INTERNAL_ERROR if other error occurs.
*/
static rtems_status_code
read_extended_partition(int fd, uint32_t start, rtems_part_desc_t *ext_part)
{
36c0: e92d4ff3 push {r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr}
int i;
rtems_sector_data_t *sector = NULL;
36c4: e3a03000 mov r3, #0
uint32_t here;
uint8_t *data;
rtems_part_desc_t *new_part_desc;
rtems_status_code rc;
if ((ext_part == NULL) || (ext_part->disk_desc == NULL))
36c8: e2525000 subs r5, r2, #0
* RTEMS_NO_MEMOTY if cannot allocate memory for part_desc_t strucure,
* RTEMS_INTERNAL_ERROR if other error occurs.
*/
static rtems_status_code
read_extended_partition(int fd, uint32_t start, rtems_part_desc_t *ext_part)
{
36cc: e1a09000 mov r9, r0
36d0: e1a0a001 mov sl, r1
int i;
rtems_sector_data_t *sector = NULL;
36d4: e58d3000 str r3, [sp]
uint32_t here;
uint8_t *data;
rtems_part_desc_t *new_part_desc;
rtems_status_code rc;
if ((ext_part == NULL) || (ext_part->disk_desc == NULL))
36d8: 0a000047 beq 37fc <read_extended_partition+0x13c>
36dc: e5953010 ldr r3, [r5, #16]
36e0: e3530000 cmp r3, #0
36e4: 0a000044 beq 37fc <read_extended_partition+0x13c>
{
return RTEMS_INTERNAL_ERROR;
}
/* get start sector of current extended partition */
here = ext_part->start;
36e8: e5958004 ldr r8, [r5, #4]
/* get first extended partition sector */
rc = get_sector(fd, here, §or);
36ec: e1a0200d mov r2, sp
36f0: e1a01008 mov r1, r8
36f4: ebffffa0 bl 357c <get_sector>
if (rc != RTEMS_SUCCESSFUL)
36f8: e2504000 subs r4, r0, #0
36fc: e59d0000 ldr r0, [sp]
3700: 0a000002 beq 3710 <read_extended_partition+0x50>
{
if (sector)
3704: e3500000 cmp r0, #0 <== NOT EXECUTED
3708: 1a000039 bne 37f4 <read_extended_partition+0x134> <== NOT EXECUTED
370c: ea00003b b 3800 <read_extended_partition+0x140> <== NOT EXECUTED
static bool
msdos_signature_check (rtems_sector_data_t *sector)
{
uint8_t *p = sector->data + RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_OFFSET;
return ((p[0] == RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_DATA1) &&
3710: e5d03202 ldrb r3, [r0, #514] ; 0x202
3714: e3530055 cmp r3, #85 ; 0x55
3718: 1a000003 bne 372c <read_extended_partition+0x6c>
* RTEMS_SUCCESSFUL if success,
* RTEMS_NO_MEMOTY if cannot allocate memory for part_desc_t strucure,
* RTEMS_INTERNAL_ERROR if other error occurs.
*/
static rtems_status_code
read_extended_partition(int fd, uint32_t start, rtems_part_desc_t *ext_part)
371c: e5d04203 ldrb r4, [r0, #515] ; 0x203
3720: e24430aa sub r3, r4, #170 ; 0xaa
3724: e2734000 rsbs r4, r3, #0
3728: e0a44003 adc r4, r4, r3
if (sector)
free(sector);
return rc;
}
if (!msdos_signature_check(sector))
372c: e31400ff tst r4, #255 ; 0xff
3730: 1a000001 bne 373c <read_extended_partition+0x7c>
{
free(sector);
3734: eb00033e bl 4434 <free> <== NOT EXECUTED
3738: ea00002f b 37fc <read_extended_partition+0x13c> <== NOT EXECUTED
* RTEMS_SUCCESSFUL if success, * RTEMS_NO_MEMOTY if cannot allocate memory for part_desc_t strucure, * RTEMS_INTERNAL_ERROR if other error occurs. */ static rtems_status_code read_extended_partition(int fd, uint32_t start, rtems_part_desc_t *ext_part)
373c: e2807e1d add r7, r0, #464 ; 0x1d0
3740: e2877002 add r7, r7, #2
}
if (!msdos_signature_check(sector))
{
free(sector);
return RTEMS_INTERNAL_ERROR;
3744: e1a06005 mov r6, r5
* RTEMS_SUCCESSFUL if success, * RTEMS_NO_MEMOTY if cannot allocate memory for part_desc_t strucure, * RTEMS_INTERNAL_ERROR if other error occurs. */ static rtems_status_code read_extended_partition(int fd, uint32_t start, rtems_part_desc_t *ext_part)
3748: e285b010 add fp, r5, #16
374c: e2470010 sub r0, r7, #16
3750: e28d1004 add r1, sp, #4
3754: ebffffac bl 360c <data_to_part_desc.part.1>
{
/* if data_to_part_desc fails skip this partition
* and parse the next one
*/
rc = data_to_part_desc(data, &new_part_desc);
if (rc != RTEMS_SUCCESSFUL)
3758: e2504000 subs r4, r0, #0
375c: 1a000023 bne 37f0 <read_extended_partition+0x130>
{
free(sector);
return rc;
}
if (new_part_desc == NULL)
3760: e59d2004 ldr r2, [sp, #4]
3764: e3520000 cmp r2, #0
3768: 0a00001c beq 37e0 <read_extended_partition+0x120>
{
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
continue;
}
ext_part->sub_part[i] = new_part_desc;
376c: e5862018 str r2, [r6, #24]
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
if (is_extended(new_part_desc->sys_type))
3770: e5d21001 ldrb r1, [r2, #1]
continue;
}
ext_part->sub_part[i] = new_part_desc;
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
3774: e5953010 ldr r3, [r5, #16]
if (is_extended(new_part_desc->sys_type))
3778: e3510005 cmp r1, #5
377c: 13510085 cmpne r1, #133 ; 0x85
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
continue;
}
ext_part->sub_part[i] = new_part_desc;
new_part_desc->ext_part = ext_part;
3780: e5825014 str r5, [r2, #20]
new_part_desc->disk_desc = ext_part->disk_desc;
3784: e5823010 str r3, [r2, #16]
if (is_extended(new_part_desc->sys_type))
3788: 1a000007 bne 37ac <read_extended_partition+0xec>
{
new_part_desc->log_id = EMPTY_PARTITION;
new_part_desc->start += start;
378c: e5923004 ldr r3, [r2, #4]
3790: e083300a add r3, r3, sl
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
if (is_extended(new_part_desc->sys_type))
{
new_part_desc->log_id = EMPTY_PARTITION;
3794: e5c24002 strb r4, [r2, #2]
new_part_desc->start += start;
3798: e5823004 str r3, [r2, #4]
read_extended_partition(fd, start, new_part_desc);
379c: e1a00009 mov r0, r9
37a0: e1a0100a mov r1, sl
37a4: ebffffc5 bl 36c0 <read_extended_partition>
37a8: ea00000c b 37e0 <read_extended_partition+0x120>
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
37ac: e5931024 ldr r1, [r3, #36] ; 0x24
37b0: e281000a add r0, r1, #10
new_part_desc->log_id = ++disk_desc->last_log_id;
37b4: e2811001 add r1, r1, #1
37b8: e5831024 str r1, [r3, #36] ; 0x24
read_extended_partition(fd, start, new_part_desc);
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
37bc: e7832100 str r2, [r3, r0, lsl #2]
new_part_desc->log_id = ++disk_desc->last_log_id;
new_part_desc->start += here;
37c0: e5923004 ldr r3, [r2, #4]
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
new_part_desc->log_id = ++disk_desc->last_log_id;
37c4: e5c21002 strb r1, [r2, #2]
new_part_desc->start += here;
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
37c8: e5921008 ldr r1, [r2, #8]
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
new_part_desc->log_id = ++disk_desc->last_log_id;
new_part_desc->start += here;
37cc: e0883003 add r3, r8, r3
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
37d0: e2411001 sub r1, r1, #1
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
new_part_desc->log_id = ++disk_desc->last_log_id;
new_part_desc->start += here;
37d4: e5823004 str r3, [r2, #4]
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
37d8: e0813003 add r3, r1, r3
37dc: e582300c str r3, [r2, #12]
37e0: e2866004 add r6, r6, #4
/* read and process up to 4 logical partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (i = 0; i < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER; i++)
37e4: e156000b cmp r6, fp
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
new_part_desc->log_id = ++disk_desc->last_log_id;
new_part_desc->start += here;
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
37e8: e2877010 add r7, r7, #16
/* read and process up to 4 logical partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (i = 0; i < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER; i++)
37ec: 1affffd6 bne 374c <read_extended_partition+0x8c>
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
37f0: e59d0000 ldr r0, [sp]
37f4: eb00030e bl 4434 <free>
return RTEMS_SUCCESSFUL;
37f8: ea000000 b 3800 <read_extended_partition+0x140>
rtems_part_desc_t *new_part_desc;
rtems_status_code rc;
if ((ext_part == NULL) || (ext_part->disk_desc == NULL))
{
return RTEMS_INTERNAL_ERROR;
37fc: e3a04019 mov r4, #25 <== NOT EXECUTED
}
free(sector);
return RTEMS_SUCCESSFUL;
}
3800: e1a00004 mov r0, r4
3804: e8bd8ffc pop {r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000309c <realloc>:
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
309c: e59f3118 ldr r3, [pc, #280] ; 31bc <realloc+0x120>
30a0: e5932010 ldr r2, [r3, #16]
30a4: e2822001 add r2, r2, #1
void *realloc(
void *ptr,
size_t size
)
{
30a8: e92d40f1 push {r0, r4, r5, r6, r7, lr}
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30ac: e5832010 str r2, [r3, #16]
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
30b0: e59f3108 ldr r3, [pc, #264] ; 31c0 <realloc+0x124>
30b4: e5933000 ldr r3, [r3]
30b8: e3530003 cmp r3, #3
void *realloc(
void *ptr,
size_t size
)
{
30bc: e1a04000 mov r4, r0
30c0: 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())) {
30c4: 1a000008 bne 30ec <realloc+0x50>
* This routine returns true if thread dispatch indicates
* that we are in a critical section.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Dispatch_in_critical_section(void)
{
if ( _Thread_Dispatch_disable_level == 0 )
30c8: e59f30f4 ldr r3, [pc, #244] ; 31c4 <realloc+0x128>
30cc: e5933000 ldr r3, [r3]
30d0: e3530000 cmp r3, #0
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
30d4: 13a04000 movne r4, #0
30d8: 1a000034 bne 31b0 <realloc+0x114>
if (_ISR_Nest_level > 0)
30dc: e59f20e4 ldr r2, [pc, #228] ; 31c8 <realloc+0x12c>
30e0: e5922000 ldr r2, [r2]
30e4: e3520000 cmp r2, #0
30e8: 1a00002d bne 31a4 <realloc+0x108>
}
/*
* Continue with realloc().
*/
if ( !ptr )
30ec: e3540000 cmp r4, #0
30f0: 1a000003 bne 3104 <realloc+0x68>
return malloc( size );
30f4: e1a00005 mov r0, r5
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
30f8: e28dd004 add sp, sp, #4
30fc: e8bd40f0 pop {r4, r5, r6, r7, lr}
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
3100: eafffd4d b 263c <malloc>
if ( !size ) {
3104: e3550000 cmp r5, #0
3108: 1a000003 bne 311c <realloc+0x80>
free( ptr );
310c: e1a00004 mov r0, r4 <== NOT EXECUTED
3110: ebfffc84 bl 2328 <free> <== NOT EXECUTED
return (void *) 0;
3114: e1a04005 mov r4, r5 <== NOT EXECUTED
3118: ea000024 b 31b0 <realloc+0x114> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
311c: e59f60a8 ldr r6, [pc, #168] ; 31cc <realloc+0x130>
3120: e1a01004 mov r1, r4
3124: e5960000 ldr r0, [r6]
3128: e1a0200d mov r2, sp
312c: eb00127d bl 7b28 <_Protected_heap_Get_block_size>
3130: e2507000 subs r7, r0, #0
3134: 1a000004 bne 314c <realloc+0xb0>
errno = EINVAL;
3138: eb00297d bl d734 <__errno>
313c: e3a03016 mov r3, #22
3140: e5803000 str r3, [r0]
return (void *) 0;
3144: e1a04007 mov r4, r7
3148: ea000018 b 31b0 <realloc+0x114>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
314c: e5960000 ldr r0, [r6]
3150: e1a01004 mov r1, r4
3154: e1a02005 mov r2, r5
3158: eb001285 bl 7b74 <_Protected_heap_Resize_block>
315c: e3500000 cmp r0, #0
3160: 1a000012 bne 31b0 <realloc+0x114>
* 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 );
3164: e1a00005 mov r0, r5
3168: ebfffd33 bl 263c <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
316c: e59f3048 ldr r3, [pc, #72] ; 31bc <realloc+0x120>
3170: e5932004 ldr r2, [r3, #4]
if ( !new_area ) {
3174: e2506000 subs r6, r0, #0
* and the C Standard.
*/
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
3178: e2422001 sub r2, r2, #1
317c: e5832004 str r2, [r3, #4]
if ( !new_area ) {
3180: 0a000009 beq 31ac <realloc+0x110>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
3184: e59d2000 ldr r2, [sp]
3188: e1a01004 mov r1, r4
318c: e1550002 cmp r5, r2
3190: 31a02005 movcc r2, r5
3194: eb002ba0 bl e01c <memcpy>
free( ptr );
3198: e1a00004 mov r0, r4
319c: ebfffc61 bl 2328 <free>
31a0: ea000001 b 31ac <realloc+0x110>
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
if (_ISR_Nest_level > 0)
return (void *) 0;
31a4: e1a04003 mov r4, r3 <== NOT EXECUTED
31a8: ea000000 b 31b0 <realloc+0x114> <== NOT EXECUTED
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
31ac: e1a04006 mov r4, r6
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
31b0: e1a00004 mov r0, r4
31b4: e28dd004 add sp, sp, #4
31b8: e8bd80f0 pop {r4, r5, r6, r7, pc}
00006810 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
6810: e92d41f0 push {r4, r5, r6, r7, r8, lr}
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
6814: e59f41e4 ldr r4, [pc, #484] ; 6a00 <rtems_aio_enqueue+0x1f0>
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
6818: e24dd024 sub sp, sp, #36 ; 0x24
681c: e1a06000 mov r6, r0
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
6820: e1a00004 mov r0, r4
6824: eb000255 bl 7180 <pthread_mutex_lock>
if (result != 0) {
6828: e2505000 subs r5, r0, #0
682c: 0a000002 beq 683c <rtems_aio_enqueue+0x2c>
free (req);
6830: e1a00006 mov r0, r6 <== NOT EXECUTED
6834: ebfff02a bl 28e4 <free> <== NOT EXECUTED
return result;
6838: ea00006d b 69f4 <rtems_aio_enqueue+0x1e4> <== NOT EXECUTED
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
683c: eb000464 bl 79d4 <pthread_self>
6840: e28d1020 add r1, sp, #32
6844: e1a0200d mov r2, sp
6848: eb000370 bl 7610 <pthread_getschedparam>
req->caller_thread = pthread_self ();
684c: eb000460 bl 79d4 <pthread_self>
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
6850: e5963014 ldr r3, [r6, #20]
6854: e59d1000 ldr r1, [sp]
6858: e5932014 ldr r2, [r3, #20]
685c: e0622001 rsb r2, r2, r1
6860: e586200c str r2, [r6, #12]
req->policy = policy;
6864: e59d2020 ldr r2, [sp, #32]
6868: e5862008 str r2, [r6, #8]
req->aiocbp->error_code = EINPROGRESS;
686c: e3a02077 mov r2, #119 ; 0x77
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
6870: e5860010 str r0, [r6, #16]
req->priority = param.sched_priority - req->aiocbp->aio_reqprio; req->policy = policy; req->aiocbp->error_code = EINPROGRESS;
6874: e5832030 str r2, [r3, #48] ; 0x30
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
6878: e5942068 ldr r2, [r4, #104] ; 0x68
687c: e3520000 cmp r2, #0
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
6880: e5835034 str r5, [r3, #52] ; 0x34
if ((aio_request_queue.idle_threads == 0) &&
6884: 1a00002d bne 6940 <rtems_aio_enqueue+0x130>
6888: e5942064 ldr r2, [r4, #100] ; 0x64
688c: e3520004 cmp r2, #4
6890: ca00002a bgt 6940 <rtems_aio_enqueue+0x130>
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
6894: e5931000 ldr r1, [r3]
6898: e2840048 add r0, r4, #72 ; 0x48
689c: e3a02001 mov r2, #1
68a0: ebffff83 bl 66b4 <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
68a4: e5903018 ldr r3, [r0, #24]
68a8: e3530001 cmp r3, #1
if ((aio_request_queue.idle_threads == 0) &&
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
68ac: e1a07000 mov r7, r0
68b0: e2808008 add r8, r0, #8
if (r_chain->new_fd == 1) {
68b4: 1a000017 bne 6918 <rtems_aio_enqueue+0x108>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
68b8: e1a01006 mov r1, r6
68bc: e1a00008 mov r0, r8
68c0: eb000890 bl 8b08 <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; pthread_mutex_init (&r_chain->mutex, NULL);
68c4: e1a01005 mov r1, r5
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
if (r_chain->new_fd == 1) {
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
68c8: e5875018 str r5, [r7, #24]
pthread_mutex_init (&r_chain->mutex, NULL);
68cc: e287001c add r0, r7, #28
68d0: eb0001d9 bl 703c <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
68d4: e1a01005 mov r1, r5
68d8: e2870020 add r0, r7, #32
68dc: eb0000ef bl 6ca0 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
68e0: e1a03007 mov r3, r7
68e4: e28d001c add r0, sp, #28
68e8: e2841008 add r1, r4, #8
68ec: e59f2110 ldr r2, [pc, #272] ; 6a04 <rtems_aio_enqueue+0x1f4>
68f0: eb0002b1 bl 73bc <pthread_create>
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
68f4: e2506000 subs r6, r0, #0
pthread_mutex_unlock (&aio_request_queue.mutex); return result; } ++aio_request_queue.active_threads;
68f8: 05943064 ldreq r3, [r4, #100] ; 0x64
68fc: 02833001 addeq r3, r3, #1
6900: 05843064 streq r3, [r4, #100] ; 0x64
pthread_cond_init (&r_chain->cond, NULL);
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
6904: 0a000038 beq 69ec <rtems_aio_enqueue+0x1dc>
pthread_mutex_unlock (&aio_request_queue.mutex);
6908: e1a00004 mov r0, r4 <== NOT EXECUTED
690c: eb00023a bl 71fc <pthread_mutex_unlock> <== NOT EXECUTED
return result;
6910: e1a05006 mov r5, r6 <== NOT EXECUTED
6914: ea000036 b 69f4 <rtems_aio_enqueue+0x1e4> <== NOT EXECUTED
}
++aio_request_queue.active_threads;
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
6918: e280401c add r4, r0, #28
691c: e1a00004 mov r0, r4
6920: eb000216 bl 7180 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
6924: e1a00008 mov r0, r8
6928: e1a01006 mov r1, r6
692c: ebffff1c bl 65a4 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
6930: e2870020 add r0, r7, #32
6934: eb000109 bl 6d60 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
6938: e1a00004 mov r0, r4
693c: ea00000e b 697c <rtems_aio_enqueue+0x16c>
else
{
/* the maximum number of threads has been already created
even though some of them might be idle.
The request belongs to one of the active fd chain */
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
6940: e59f00c0 ldr r0, [pc, #192] ; 6a08 <rtems_aio_enqueue+0x1f8>
6944: e5931000 ldr r1, [r3]
6948: e3a02000 mov r2, #0
694c: ebffff58 bl 66b4 <rtems_aio_search_fd>
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
6950: e2504000 subs r4, r0, #0
6954: 0a00000a beq 6984 <rtems_aio_enqueue+0x174>
{
pthread_mutex_lock (&r_chain->mutex);
6958: e284701c add r7, r4, #28
695c: e1a00007 mov r0, r7
6960: eb000206 bl 7180 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
6964: e2840008 add r0, r4, #8
6968: e1a01006 mov r1, r6
696c: ebffff0c bl 65a4 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
6970: e2840020 add r0, r4, #32
6974: eb0000f9 bl 6d60 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
6978: e1a00007 mov r0, r7
697c: eb00021e bl 71fc <pthread_mutex_unlock>
6980: ea000019 b 69ec <rtems_aio_enqueue+0x1dc>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
6984: e5963014 ldr r3, [r6, #20]
6988: e59f007c ldr r0, [pc, #124] ; 6a0c <rtems_aio_enqueue+0x1fc>
698c: e5931000 ldr r1, [r3]
6990: e3a02001 mov r2, #1
6994: ebffff46 bl 66b4 <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
6998: e5903018 ldr r3, [r0, #24]
699c: e3530001 cmp r3, #1
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
69a0: e1a07000 mov r7, r0
69a4: e1a01006 mov r1, r6
69a8: e2800008 add r0, r0, #8
if (r_chain->new_fd == 1) {
69ac: 1a000008 bne 69d4 <rtems_aio_enqueue+0x1c4>
69b0: eb000854 bl 8b08 <_Chain_Insert>
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
69b4: e1a01004 mov r1, r4
if (r_chain->new_fd == 1) {
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
69b8: e5874018 str r4, [r7, #24]
pthread_mutex_init (&r_chain->mutex, NULL);
69bc: e287001c add r0, r7, #28
69c0: eb00019d bl 703c <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
69c4: e2870020 add r0, r7, #32
69c8: e1a01004 mov r1, r4
69cc: eb0000b3 bl 6ca0 <pthread_cond_init>
69d0: ea000000 b 69d8 <rtems_aio_enqueue+0x1c8>
} else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req);
69d4: ebfffef2 bl 65a4 <rtems_aio_insert_prio>
if (aio_request_queue.idle_threads > 0)
69d8: e59f0020 ldr r0, [pc, #32] ; 6a00 <rtems_aio_enqueue+0x1f0>
69dc: e5903068 ldr r3, [r0, #104] ; 0x68
69e0: e3530000 cmp r3, #0
pthread_cond_signal (&aio_request_queue.new_req);
69e4: c2800004 addgt r0, r0, #4
69e8: cb0000dc blgt 6d60 <pthread_cond_signal>
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
69ec: e59f000c ldr r0, [pc, #12] ; 6a00 <rtems_aio_enqueue+0x1f0>
69f0: eb000201 bl 71fc <pthread_mutex_unlock>
return 0; }
69f4: e1a00005 mov r0, r5
69f8: e28dd024 add sp, sp, #36 ; 0x24
69fc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
00006338 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
6338: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
633c: e59f425c ldr r4, [pc, #604] ; 65a0 <rtems_aio_handle+0x268>
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
6340: e24dd02c sub sp, sp, #44 ; 0x2c
6344: e1a05000 mov r5, r0
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
6348: e284904c add r9, r4, #76 ; 0x4c
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
634c: e285801c add r8, r5, #28
6350: e1a00008 mov r0, r8
6354: eb000389 bl 7180 <pthread_mutex_lock>
if (result != 0)
6358: e250a000 subs sl, r0, #0
635c: 1a00008c bne 6594 <rtems_aio_handle+0x25c>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
6360: e5956008 ldr r6, [r5, #8]
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
6364: e285300c add r3, r5, #12
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
6368: e1560003 cmp r6, r3
636c: 0a000035 beq 6448 <rtems_aio_handle+0x110>
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
6370: eb000597 bl 79d4 <pthread_self>
6374: e28d1028 add r1, sp, #40 ; 0x28
6378: e28d2004 add r2, sp, #4
637c: eb0004a3 bl 7610 <pthread_getschedparam>
param.sched_priority = req->priority;
6380: e596300c ldr r3, [r6, #12]
6384: e58d3004 str r3, [sp, #4]
pthread_setschedparam (pthread_self(), req->policy, ¶m);
6388: eb000591 bl 79d4 <pthread_self>
638c: e28d2004 add r2, sp, #4
6390: e5961008 ldr r1, [r6, #8]
6394: eb000593 bl 79e8 <pthread_setschedparam>
6398: e1a00006 mov r0, r6
639c: eb0009c4 bl 8ab4 <_Chain_Extract>
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
63a0: e1a00008 mov r0, r8
63a4: eb000394 bl 71fc <pthread_mutex_unlock>
switch (req->aiocbp->aio_lio_opcode) {
63a8: e5962014 ldr r2, [r6, #20]
63ac: e592302c ldr r3, [r2, #44] ; 0x2c
63b0: e3530002 cmp r3, #2
63b4: 0a00000b beq 63e8 <rtems_aio_handle+0xb0>
63b8: e3530003 cmp r3, #3
63bc: 0a000011 beq 6408 <rtems_aio_handle+0xd0>
63c0: e3530001 cmp r3, #1
63c4: 1a000013 bne 6418 <rtems_aio_handle+0xe0>
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
63c8: e5921008 ldr r1, [r2, #8]
63cc: e5923004 ldr r3, [r2, #4]
63d0: e58d1000 str r1, [sp]
63d4: e282100c add r1, r2, #12
63d8: e5920000 ldr r0, [r2]
63dc: e8910006 ldm r1, {r1, r2}
63e0: eb00281b bl 10454 <pread>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
63e4: ea000009 b 6410 <rtems_aio_handle+0xd8>
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
63e8: e5921008 ldr r1, [r2, #8]
63ec: e5923004 ldr r3, [r2, #4]
63f0: e58d1000 str r1, [sp]
63f4: e282100c add r1, r2, #12
63f8: e5920000 ldr r0, [r2]
63fc: e8910006 ldm r1, {r1, r2}
6400: eb002856 bl 10560 <pwrite>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
6404: ea000001 b 6410 <rtems_aio_handle+0xd8>
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
6408: e5920000 ldr r0, [r2] <== NOT EXECUTED
640c: eb001907 bl c830 <fsync> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
6410: e3700001 cmn r0, #1
6414: 1a000006 bne 6434 <rtems_aio_handle+0xfc>
req->aiocbp->return_value = -1;
6418: e5966014 ldr r6, [r6, #20] <== NOT EXECUTED
641c: e3e03000 mvn r3, #0 <== NOT EXECUTED
6420: e5863034 str r3, [r6, #52] ; 0x34 <== NOT EXECUTED
req->aiocbp->error_code = errno;
6424: eb002530 bl f8ec <__errno> <== NOT EXECUTED
6428: e5903000 ldr r3, [r0] <== NOT EXECUTED
642c: e5863030 str r3, [r6, #48] ; 0x30 <== NOT EXECUTED
6430: eaffffc5 b 634c <rtems_aio_handle+0x14> <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
6434: e5963014 ldr r3, [r6, #20]
req->aiocbp->error_code = 0;
6438: e3a02000 mov r2, #0
}
if (result == -1) {
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
643c: e5830034 str r0, [r3, #52] ; 0x34
req->aiocbp->error_code = 0;
6440: e5832030 str r2, [r3, #48] ; 0x30
6444: eaffffc0 b 634c <rtems_aio_handle+0x14>
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
6448: e59f7150 ldr r7, [pc, #336] ; 65a0 <rtems_aio_handle+0x268>
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
644c: e1a00008 mov r0, r8
6450: eb000369 bl 71fc <pthread_mutex_unlock>
pthread_mutex_lock (&aio_request_queue.mutex);
6454: e1a00007 mov r0, r7
6458: eb000348 bl 7180 <pthread_mutex_lock>
if (rtems_chain_is_empty (chain))
645c: e5953008 ldr r3, [r5, #8]
6460: e1530006 cmp r3, r6
6464: 1a000047 bne 6588 <rtems_aio_handle+0x250>
{
clock_gettime (CLOCK_REALTIME, &timeout);
6468: e28d1020 add r1, sp, #32
646c: e3a00001 mov r0, #1
6470: eb0001b0 bl 6b38 <clock_gettime>
timeout.tv_sec += 3;
6474: e59d3020 ldr r3, [sp, #32]
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
6478: e2856020 add r6, r5, #32
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
647c: e2833003 add r3, r3, #3
timeout.tv_nsec = 0; result = pthread_cond_timedwait (&r_chain->cond,
6480: e1a00006 mov r0, r6
6484: e1a01007 mov r1, r7
6488: e28d2020 add r2, sp, #32
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
648c: e58d3020 str r3, [sp, #32]
timeout.tv_nsec = 0;
6490: e58da024 str sl, [sp, #36] ; 0x24
result = pthread_cond_timedwait (&r_chain->cond,
6494: eb000248 bl 6dbc <pthread_cond_timedwait>
&aio_request_queue.mutex,
&timeout);
/* If no requests were added to the chain we delete the fd chain from
the queue and start working with idle fd chains */
if (result == ETIMEDOUT) {
6498: e3500074 cmp r0, #116 ; 0x74
649c: 1a000039 bne 6588 <rtems_aio_handle+0x250>
64a0: e1a00005 mov r0, r5
64a4: eb000982 bl 8ab4 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex);
64a8: e1a00008 mov r0, r8
64ac: eb000296 bl 6f0c <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->cond);
64b0: e1a00006 mov r0, r6
64b4: eb0001c9 bl 6be0 <pthread_cond_destroy>
free (r_chain);
64b8: e1a00005 mov r0, r5
64bc: ebfff108 bl 28e4 <free>
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
64c0: e5942054 ldr r2, [r4, #84] ; 0x54
64c4: e2873058 add r3, r7, #88 ; 0x58
64c8: e1520003 cmp r2, r3
64cc: 1a000018 bne 6534 <rtems_aio_handle+0x1fc>
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
64d0: e5943068 ldr r3, [r4, #104] ; 0x68
64d4: e2833001 add r3, r3, #1
64d8: e5843068 str r3, [r4, #104] ; 0x68
--aio_request_queue.active_threads;
64dc: e5943064 ldr r3, [r4, #100] ; 0x64
clock_gettime (CLOCK_REALTIME, &timeout);
64e0: e28d1020 add r1, sp, #32
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
64e4: e2433001 sub r3, r3, #1
clock_gettime (CLOCK_REALTIME, &timeout);
64e8: e3a00001 mov r0, #1
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
64ec: e5843064 str r3, [r4, #100] ; 0x64
clock_gettime (CLOCK_REALTIME, &timeout);
64f0: eb000190 bl 6b38 <clock_gettime>
timeout.tv_sec += 3;
64f4: e59d3020 ldr r3, [sp, #32]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
64f8: e2870004 add r0, r7, #4
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
64fc: e2833003 add r3, r3, #3
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
6500: e1a01007 mov r1, r7
6504: e28d2020 add r2, sp, #32
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
6508: e58d3020 str r3, [sp, #32]
timeout.tv_nsec = 0;
650c: e58da024 str sl, [sp, #36] ; 0x24
result = pthread_cond_timedwait (&aio_request_queue.new_req,
6510: eb000229 bl 6dbc <pthread_cond_timedwait>
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
6514: e3500074 cmp r0, #116 ; 0x74
6518: 1a000005 bne 6534 <rtems_aio_handle+0x1fc>
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
651c: e5973068 ldr r3, [r7, #104] ; 0x68
pthread_mutex_unlock (&aio_request_queue.mutex);
6520: e1a00007 mov r0, r7
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
6524: e2433001 sub r3, r3, #1
6528: e5873068 str r3, [r7, #104] ; 0x68
pthread_mutex_unlock (&aio_request_queue.mutex);
652c: eb000332 bl 71fc <pthread_mutex_unlock>
return NULL;
6530: ea000017 b 6594 <rtems_aio_handle+0x25c>
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
6534: e5943068 ldr r3, [r4, #104] ; 0x68
6538: e2433001 sub r3, r3, #1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
653c: e5945054 ldr r5, [r4, #84] ; 0x54
6540: e5843068 str r3, [r4, #104] ; 0x68
++aio_request_queue.active_threads;
6544: e5943064 ldr r3, [r4, #100] ; 0x64
6548: e1a00005 mov r0, r5
654c: e2833001 add r3, r3, #1
6550: e5843064 str r3, [r4, #100] ; 0x64
6554: eb000956 bl 8ab4 <_Chain_Extract>
6558: e5943048 ldr r3, [r4, #72] ; 0x48
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
655c: e5952014 ldr r2, [r5, #20]
6560: ea000000 b 6568 <rtems_aio_handle+0x230>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
6564: e5933000 ldr r3, [r3]
6568: e5931014 ldr r1, [r3, #20]
656c: e1510002 cmp r1, r2
6570: aa000001 bge 657c <rtems_aio_handle+0x244>
6574: e1530009 cmp r3, r9
6578: 1afffff9 bne 6564 <rtems_aio_handle+0x22c>
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
657c: e5930004 ldr r0, [r3, #4]
6580: e1a01005 mov r1, r5
6584: eb00095f bl 8b08 <_Chain_Insert>
}
}
/* If there was a request added in the initial fd chain then release
the mutex and process it */
pthread_mutex_unlock (&aio_request_queue.mutex);
6588: e59f0010 ldr r0, [pc, #16] ; 65a0 <rtems_aio_handle+0x268>
658c: eb00031a bl 71fc <pthread_mutex_unlock>
6590: eaffff6d b 634c <rtems_aio_handle+0x14>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
6594: e3a00000 mov r0, #0
6598: e28dd02c add sp, sp, #44 ; 0x2c
659c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
000065f4 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
65f4: e92d4010 push {r4, lr}
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
65f8: e59f00a4 ldr r0, [pc, #164] ; 66a4 <rtems_aio_init+0xb0>
65fc: eb00034f bl 7340 <pthread_attr_init>
if (result != 0)
6600: e2504000 subs r4, r0, #0
6604: 1a000024 bne 669c <rtems_aio_init+0xa8>
return result;
result =
6608: e59f0094 ldr r0, [pc, #148] ; 66a4 <rtems_aio_init+0xb0>
660c: e1a01004 mov r1, r4
6610: eb00035b bl 7384 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
6614: e3500000 cmp r0, #0
pthread_attr_destroy (&aio_request_queue.attr);
6618: 159f0084 ldrne r0, [pc, #132] ; 66a4 <rtems_aio_init+0xb0>
661c: 1b00033e blne 731c <pthread_attr_destroy>
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
6620: e59f0080 ldr r0, [pc, #128] ; 66a8 <rtems_aio_init+0xb4>
6624: e3a01000 mov r1, #0
6628: eb000283 bl 703c <pthread_mutex_init>
if (result != 0)
662c: e3500000 cmp r0, #0
pthread_attr_destroy (&aio_request_queue.attr);
6630: 159f006c ldrne r0, [pc, #108] ; 66a4 <rtems_aio_init+0xb0>
6634: 1b000338 blne 731c <pthread_attr_destroy>
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
6638: e59f006c ldr r0, [pc, #108] ; 66ac <rtems_aio_init+0xb8>
663c: e3a01000 mov r1, #0
6640: eb000196 bl 6ca0 <pthread_cond_init>
if (result != 0) {
6644: e2504000 subs r4, r0, #0
6648: 0a000003 beq 665c <rtems_aio_init+0x68>
pthread_mutex_destroy (&aio_request_queue.mutex);
664c: e59f0054 ldr r0, [pc, #84] ; 66a8 <rtems_aio_init+0xb4> <== NOT EXECUTED
6650: eb00022d bl 6f0c <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
6654: e59f0048 ldr r0, [pc, #72] ; 66a4 <rtems_aio_init+0xb0> <== NOT EXECUTED
6658: eb00032f bl 731c <pthread_attr_destroy> <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
665c: e59f3044 ldr r3, [pc, #68] ; 66a8 <rtems_aio_init+0xb4>
6660: e283204c add r2, r3, #76 ; 0x4c
head->previous = NULL; tail->previous = head;
6664: e2831048 add r1, r3, #72 ; 0x48
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
6668: e5832048 str r2, [r3, #72] ; 0x48
head->previous = NULL;
666c: e3a02000 mov r2, #0
6670: e583204c str r2, [r3, #76] ; 0x4c
tail->previous = head;
6674: e5831050 str r1, [r3, #80] ; 0x50
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
6678: e5832058 str r2, [r3, #88] ; 0x58
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
667c: e2831058 add r1, r3, #88 ; 0x58
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
6680: e5832064 str r2, [r3, #100] ; 0x64
aio_request_queue.idle_threads = 0;
6684: e5832068 str r2, [r3, #104] ; 0x68
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
6688: e59f2020 ldr r2, [pc, #32] ; 66b0 <rtems_aio_init+0xbc>
668c: e5831054 str r1, [r3, #84] ; 0x54
head->previous = NULL; tail->previous = head;
6690: e2831054 add r1, r3, #84 ; 0x54
6694: e583105c str r1, [r3, #92] ; 0x5c
6698: e5832060 str r2, [r3, #96] ; 0x60
return result;
}
669c: e1a00004 mov r0, r4
66a0: e8bd8010 pop {r4, pc}
000065a4 <rtems_aio_insert_prio>:
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
65a4: e1a02000 mov r2, r0
65a8: e4923004 ldr r3, [r2], #4
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
65ac: e1530002 cmp r3, r2
* NONE
*/
static void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
65b0: e1a0c001 mov ip, r1
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
65b4: 0a00000d beq 65f0 <rtems_aio_insert_prio+0x4c>
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
65b8: e5931014 ldr r1, [r3, #20]
while (req->aiocbp->aio_reqprio > prio &&
65bc: e59c0014 ldr r0, [ip, #20]
if (rtems_chain_is_empty (chain)) {
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
65c0: e5911014 ldr r1, [r1, #20]
while (req->aiocbp->aio_reqprio > prio &&
65c4: e5900014 ldr r0, [r0, #20]
65c8: ea000002 b 65d8 <rtems_aio_insert_prio+0x34>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
65cc: e5933000 ldr r3, [r3] <== NOT EXECUTED
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
65d0: e5931014 ldr r1, [r3, #20] <== NOT EXECUTED
65d4: e5911014 ldr r1, [r1, #20] <== NOT EXECUTED
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
65d8: e1500001 cmp r0, r1
65dc: da000001 ble 65e8 <rtems_aio_insert_prio+0x44>
65e0: e1530002 cmp r3, r2 <== NOT EXECUTED
65e4: 1afffff8 bne 65cc <rtems_aio_insert_prio+0x28> <== NOT EXECUTED
65e8: e5930004 ldr r0, [r3, #4]
65ec: e1a0100c mov r1, ip
65f0: ea000944 b 8b08 <_Chain_Insert>
000067a8 <rtems_aio_remove_req>:
* AIO_NOTCANCELED - if request was not canceled
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
67a8: e92d4010 push {r4, lr}
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
67ac: e4904004 ldr r4, [r0], #4
if (rtems_chain_is_empty (chain))
67b0: e1540000 cmp r4, r0
67b4: 1a000005 bne 67d0 <rtems_aio_remove_req+0x28>
67b8: ea000012 b 6808 <rtems_aio_remove_req+0x60>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
67bc: e5944000 ldr r4, [r4] <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
67c0: e1540000 cmp r4, r0 <== NOT EXECUTED
67c4: 1a000001 bne 67d0 <rtems_aio_remove_req+0x28> <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
67c8: e3a00001 mov r0, #1 <== NOT EXECUTED
67cc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
67d0: e5943014 ldr r3, [r4, #20]
67d4: e1530001 cmp r3, r1
67d8: 1afffff7 bne 67bc <rtems_aio_remove_req+0x14>
67dc: e1a00004 mov r0, r4
67e0: eb0008b3 bl 8ab4 <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
67e4: e5943014 ldr r3, [r4, #20]
67e8: e3a0208c mov r2, #140 ; 0x8c
67ec: e5832030 str r2, [r3, #48] ; 0x30
current->aiocbp->return_value = -1;
67f0: e3e02000 mvn r2, #0
free (current);
67f4: e1a00004 mov r0, r4
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
current->aiocbp->return_value = -1;
67f8: e5832034 str r2, [r3, #52] ; 0x34
free (current);
67fc: ebfff038 bl 28e4 <free>
}
return AIO_CANCELED;
6800: e3a00000 mov r0, #0
6804: e8bd8010 pop {r4, pc}
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
6808: e3a00002 mov r0, #2
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
680c: e8bd8010 pop {r4, pc}
0000b228 <rtems_bdbuf_add_to_modified_list_after_access>:
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)
b228: e59f3098 ldr r3, [pc, #152] ; b2c8 <rtems_bdbuf_add_to_modified_list_after_access+0xa0>
b22c: e5d32030 ldrb r2, [r3, #48] ; 0x30
b230: e3520000 cmp r2, #0
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
b234: e92d4010 push {r4, lr}
b238: e1a04000 mov r4, r0
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)
b23c: 0a000007 beq b260 <rtems_bdbuf_add_to_modified_list_after_access+0x38>
b240: e5932038 ldr r2, [r3, #56] ; 0x38 <== NOT EXECUTED
b244: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED
b248: e1520003 cmp r2, r3 <== NOT EXECUTED
b24c: 1a000003 bne b260 <rtems_bdbuf_add_to_modified_list_after_access+0x38><== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
b250: ebffff37 bl af34 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
/*
* Wait for the sync lock.
*/
rtems_bdbuf_lock_sync ();
b254: ebffff28 bl aefc <rtems_bdbuf_lock_sync> <== NOT EXECUTED
rtems_bdbuf_unlock_sync ();
b258: ebffff3e bl af58 <rtems_bdbuf_unlock_sync> <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
b25c: ebffff1b bl aed0 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
* 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
b260: e5943020 ldr r3, [r4, #32]
b264: e3530003 cmp r3, #3
b268: 13530005 cmpne r3, #5
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
bd->hold_timer = bdbuf_config.swap_block_hold;
b26c: 059f3058 ldreq r3, [pc, #88] ; b2cc <rtems_bdbuf_add_to_modified_list_after_access+0xa4>
b270: 05933010 ldreq r3, [r3, #16]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
b274: e59f004c ldr r0, [pc, #76] ; b2c8 <rtems_bdbuf_add_to_modified_list_after_access+0xa0>
b278: 0584302c streq r3, [r4, #44] ; 0x2c
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
b27c: e3a03007 mov r3, #7
b280: e5843020 str r3, [r4, #32]
b284: e5903054 ldr r3, [r0, #84] ; 0x54
the_node->next = tail;
b288: e2802050 add r2, r0, #80 ; 0x50
b28c: e5842000 str r2, [r4]
tail->previous = the_node;
b290: e5804054 str r4, [r0, #84] ; 0x54
old_last->next = the_node;
b294: e5834000 str r4, [r3]
the_node->previous = old_last;
b298: e5843004 str r3, [r4, #4]
bd->hold_timer = bdbuf_config.swap_block_hold;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append_unprotected (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
b29c: e5943024 ldr r3, [r4, #36] ; 0x24
b2a0: e3530000 cmp r3, #0
b2a4: 0a000002 beq b2b4 <rtems_bdbuf_add_to_modified_list_after_access+0x8c>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
b2a8: e2800064 add r0, r0, #100 ; 0x64
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
}
b2ac: e8bd4010 pop {r4, lr}
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append_unprotected (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
b2b0: eaffffd2 b b200 <rtems_bdbuf_wake>
else if (rtems_bdbuf_has_buffer_waiters ())
b2b4: e5903074 ldr r3, [r0, #116] ; 0x74
b2b8: e3530000 cmp r3, #0
b2bc: 08bd8010 popeq {r4, pc}
rtems_bdbuf_wake_swapper ();
}
b2c0: e8bd4010 pop {r4, lr}
rtems_chain_append_unprotected (&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 ();
b2c4: eaffff2c b af7c <rtems_bdbuf_wake_swapper>
0000b02c <rtems_bdbuf_anonymous_wait>:
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
b02c: e5903000 ldr r3, [r0]
b030: 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)
{
b034: e92d4030 push {r4, r5, lr}
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
b038: 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)
{
b03c: 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 ();
b040: ebffffe1 bl afcc <rtems_bdbuf_disable_preemption>
b044: e1a05000 mov r5, r0
/*
* Unlock the cache, wait, and lock the cache when we return.
*/
rtems_bdbuf_unlock_cache ();
b048: ebffffb9 bl af34 <rtems_bdbuf_unlock_cache>
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
b04c: e3a01000 mov r1, #0
b050: e5940004 ldr r0, [r4, #4]
b054: e1a02001 mov r2, r1
b058: ebfff085 bl 7274 <rtems_semaphore_obtain>
if (sc == RTEMS_TIMEOUT)
b05c: e3500006 cmp r0, #6
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_TO);
b060: 03a00003 moveq r0, #3
*/
rtems_bdbuf_unlock_cache ();
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
if (sc == RTEMS_TIMEOUT)
b064: 0a000002 beq b074 <rtems_bdbuf_anonymous_wait+0x48>
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_TO);
if (sc != RTEMS_UNSATISFIED)
b068: e350000d cmp r0, #13
b06c: 0a000001 beq b078 <rtems_bdbuf_anonymous_wait+0x4c>
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_2);
b070: e3a00002 mov r0, #2 <== NOT EXECUTED
b074: ebffff91 bl aec0 <rtems_bdbuf_fatal> <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
b078: ebffff94 bl aed0 <rtems_bdbuf_lock_cache>
rtems_bdbuf_restore_preemption (prev_mode);
b07c: e1a00005 mov r0, r5
b080: ebffffde bl b000 <rtems_bdbuf_restore_preemption>
--waiters->count;
b084: e5943000 ldr r3, [r4]
b088: e2433001 sub r3, r3, #1
b08c: e5843000 str r3, [r4]
}
b090: e8bd8030 pop {r4, r5, pc}
0000b2d0 <rtems_bdbuf_create_task.constprop.10>:
return NULL;
}
static rtems_status_code
rtems_bdbuf_create_task(
b2d0: e92d4073 push {r0, r1, r4, r5, r6, lr}
b2d4: e1a05003 mov r5, r3
rtems_task_argument arg,
rtems_id *id
)
{
rtems_status_code sc;
size_t stack_size = bdbuf_config.task_stack_size ?
b2d8: e59f3050 ldr r3, [pc, #80] ; b330 <rtems_bdbuf_create_task.constprop.10+0x60>
return NULL;
}
static rtems_status_code
rtems_bdbuf_create_task(
b2dc: e1a06002 mov r6, r2
rtems_task_argument arg,
rtems_id *id
)
{
rtems_status_code sc;
size_t stack_size = bdbuf_config.task_stack_size ?
b2e0: e593201c ldr r2, [r3, #28]
bdbuf_config.task_stack_size : RTEMS_BDBUF_TASK_STACK_SIZE_DEFAULT;
priority = priority != 0 ? priority : default_priority;
sc = rtems_task_create (name,
b2e4: e3a03000 mov r3, #0
b2e8: e1510003 cmp r1, r3
return NULL;
}
static rtems_status_code
rtems_bdbuf_create_task(
b2ec: e59d4018 ldr r4, [sp, #24]
size_t stack_size = bdbuf_config.task_stack_size ?
bdbuf_config.task_stack_size : RTEMS_BDBUF_TASK_STACK_SIZE_DEFAULT;
priority = priority != 0 ? priority : default_priority;
sc = rtems_task_create (name,
b2f0: 03a0100f moveq r1, #15
b2f4: e1520003 cmp r2, r3
b2f8: e88d0018 stm sp, {r3, r4}
b2fc: 03a02a01 moveq r2, #4096 ; 0x1000
b300: e3a03b01 mov r3, #1024 ; 0x400
b304: ebfff05b bl 7478 <rtems_task_create>
stack_size,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
id);
if (sc == RTEMS_SUCCESSFUL)
b308: e3500000 cmp r0, #0
b30c: 1a000005 bne b328 <rtems_bdbuf_create_task.constprop.10+0x58>
sc = rtems_task_start (*id, entry, arg);
b310: e5940000 ldr r0, [r4]
b314: e1a01006 mov r1, r6
b318: e1a02005 mov r2, r5
return sc;
}
b31c: e28dd008 add sp, sp, #8
b320: e8bd4070 pop {r4, r5, r6, lr}
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
id);
if (sc == RTEMS_SUCCESSFUL)
sc = rtems_task_start (*id, entry, arg);
b324: eafff0e4 b 76bc <rtems_task_start>
return sc;
}
b328: e28dd008 add sp, sp, #8 <== NOT EXECUTED
b32c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
0000aec0 <rtems_bdbuf_fatal>:
#define RTEMS_BDBUF_AVL_MAX_HEIGHT (32)
#endif
static void
rtems_bdbuf_fatal (rtems_fatal_code error)
{
aec0: e1a01000 mov r1, r0 <== NOT EXECUTED
aec4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_fatal (RTEMS_FATAL_SOURCE_BDBUF, error);
aec8: e3a00003 mov r0, #3 <== NOT EXECUTED
aecc: ebfff297 bl 7930 <rtems_fatal> <== NOT EXECUTED
0000af28 <rtems_bdbuf_fatal_with_state>:
}
static void
rtems_bdbuf_fatal_with_state (rtems_bdbuf_buf_state state,
rtems_bdbuf_fatal_code error)
{
af28: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_bdbuf_fatal ((((uint32_t) state) << 16) | error);
af2c: e1810800 orr r0, r1, r0, lsl #16 <== NOT EXECUTED
af30: ebffffe2 bl aec0 <rtems_bdbuf_fatal> <== NOT EXECUTED
0000c910 <rtems_bdbuf_get>:
rtems_status_code
rtems_bdbuf_get (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
c910: e92d4070 push {r4, r5, r6, lr}
c914: e1a04000 mov r4, r0
c918: e1a06001 mov r6, r1
c91c: e1a05002 mov r5, r2
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block;
rtems_bdbuf_lock_cache ();
c920: ebfff96a bl aed0 <rtems_bdbuf_lock_cache>
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
c924: e5943028 ldr r3, [r4, #40] ; 0x28
c928: e1560003 cmp r6, r3
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
}
else
{
sc = RTEMS_INVALID_ID;
c92c: 23a06004 movcs r6, #4
rtems_bdbuf_get (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
c930: 23a04000 movcs r4, #0
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
c934: 2a000022 bcs c9c4 <rtems_bdbuf_get+0xb4>
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
c938: e5943030 ldr r3, [r4, #48] ; 0x30
c93c: e3530000 cmp r3, #0
return block << dd->block_to_media_block_shift;
c940: a1a06316 lslge r6, r6, r3
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
c944: aa000007 bge c968 <rtems_bdbuf_get+0x58>
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
c948: e5940024 ldr r0, [r4, #36] ; 0x24 <== NOT EXECUTED
c94c: e0832096 umull r2, r3, r6, r0 <== NOT EXECUTED
c950: e1a00002 mov r0, r2 <== NOT EXECUTED
c954: e1a01003 mov r1, r3 <== NOT EXECUTED
c958: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
c95c: e3a03000 mov r3, #0 <== NOT EXECUTED
c960: eb003c36 bl 1ba40 <__udivdi3> <== NOT EXECUTED
c964: e1a06000 mov r6, r0 <== NOT EXECUTED
/*
* Compute the media block number. Drivers work with media block number not
* the block number a BD may have as this depends on the block size set by
* the user.
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
c968: e5941018 ldr r1, [r4, #24]
*/
if (rtems_bdbuf_tracer)
printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block, block, (unsigned) dd->dev);
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
c96c: e1a00004 mov r0, r4
c970: e0861001 add r1, r6, r1
c974: ebfffc39 bl ba60 <rtems_bdbuf_get_buffer_for_access>
c978: e1a04000 mov r4, r0
switch (bd->state)
c97c: e5900020 ldr r0, [r0, #32]
c980: e3500002 cmp r0, #2
c984: 0a000004 beq c99c <rtems_bdbuf_get+0x8c>
c988: e3500007 cmp r0, #7
c98c: 0a000008 beq c9b4 <rtems_bdbuf_get+0xa4>
c990: e3500001 cmp r0, #1
c994: 1a000008 bne c9bc <rtems_bdbuf_get+0xac>
c998: ea000001 b c9a4 <rtems_bdbuf_get+0x94>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c99c: e3a03003 mov r3, #3
c9a0: ea000000 b c9a8 <rtems_bdbuf_get+0x98>
c9a4: e3a03005 mov r3, #5
c9a8: e5843020 str r3, [r4, #32]
c9ac: e3a06000 mov r6, #0
c9b0: ea000003 b c9c4 <rtems_bdbuf_get+0xb4>
c9b4: e3a03004 mov r3, #4
c9b8: eafffffa b c9a8 <rtems_bdbuf_get+0x98>
* record of this so just gets the block to fill.
*/
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_2);
c9bc: e3a0100f mov r1, #15 <== NOT EXECUTED
c9c0: ebfff958 bl af28 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
c9c4: ebfff95a bl af34 <rtems_bdbuf_unlock_cache>
*bd_ptr = bd;
c9c8: e5854000 str r4, [r5]
return sc;
}
c9cc: e1a00006 mov r0, r6
c9d0: e8bd8070 pop {r4, r5, r6, pc}
0000ba60 <rtems_bdbuf_get_buffer_for_access>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
ba60: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
ba64: e59f41b8 ldr r4, [pc, #440] ; bc24 <rtems_bdbuf_get_buffer_for_access+0x1c4>
}
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
ba68: e1a05000 mov r5, r0
ba6c: e1a06001 mov r6, r1
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
ba70: e284705c add r7, r4, #92 ; 0x5c
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
ba74: e594003c ldr r0, [r4, #60] ; 0x3c
ba78: e1a01005 mov r1, r5
ba7c: e1a02006 mov r2, r6
ba80: ebfffdbd bl b17c <rtems_bdbuf_avl_search.isra.0>
if (bd != NULL)
ba84: e2508000 subs r8, r0, #0
ba88: 0a000033 beq bb5c <rtems_bdbuf_get_buffer_for_access+0xfc>
{
if (bd->group->bds_per_group != dd->bds_per_group)
ba8c: e5983028 ldr r3, [r8, #40] ; 0x28
ba90: e5932008 ldr r2, [r3, #8]
ba94: e5953034 ldr r3, [r5, #52] ; 0x34
ba98: e1520003 cmp r2, r3
ba9c: 0a00003a beq bb8c <rtems_bdbuf_get_buffer_for_access+0x12c>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
baa0: e3a0a008 mov sl, #8
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
baa4: e5980020 ldr r0, [r8, #32]
baa8: e350000a cmp r0, #10
baac: 979ff100 ldrls pc, [pc, r0, lsl #2]
bab0: ea000020 b bb38 <rtems_bdbuf_get_buffer_for_access+0xd8> <== NOT EXECUTED
bab4: 0000bb40 .word 0x0000bb40 <== NOT EXECUTED
bab8: 0000bb0c .word 0x0000bb0c <== NOT EXECUTED
babc: 0000bb0c .word 0x0000bb0c <== NOT EXECUTED
bac0: 0000bb1c .word 0x0000bb1c <== NOT EXECUTED
bac4: 0000bb1c .word 0x0000bb1c <== NOT EXECUTED
bac8: 0000bb1c .word 0x0000bb1c <== NOT EXECUTED
bacc: 0000bb1c .word 0x0000bb1c <== NOT EXECUTED
bad0: 0000bae0 .word 0x0000bae0 <== NOT EXECUTED
bad4: 0000bb28 .word 0x0000bb28 <== NOT EXECUTED
bad8: 0000bb28 .word 0x0000bb28 <== NOT EXECUTED
badc: 0000bb28 .word 0x0000bb28 <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
bae0: e898000c ldm r8, {r2, r3} <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
bae4: e588a020 str sl, [r8, #32] <== NOT EXECUTED
next->previous = previous;
bae8: e5823004 str r3, [r2, #4] <== NOT EXECUTED
previous->next = next;
baec: e5832000 str r2, [r3] <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
baf0: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED
the_node->next = tail;
baf4: e5887000 str r7, [r8] <== NOT EXECUTED
tail->previous = the_node;
baf8: e5848060 str r8, [r4, #96] ; 0x60 <== NOT EXECUTED
old_last->next = the_node;
bafc: e5838000 str r8, [r3] <== NOT EXECUTED
the_node->previous = old_last;
bb00: e5883004 str r3, [r8, #4] <== 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_unprotected (&bd->link);
rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);
rtems_bdbuf_wake_swapper ();
bb04: ebfffd1c bl af7c <rtems_bdbuf_wake_swapper> <== NOT EXECUTED
bb08: eaffffe5 b baa4 <rtems_bdbuf_get_buffer_for_access+0x44> <== 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)
bb0c: e5983024 ldr r3, [r8, #36] ; 0x24
bb10: e3530000 cmp r3, #0
bb14: 0a000009 beq bb40 <rtems_bdbuf_get_buffer_for_access+0xe0>
bb18: ea000018 b bb80 <rtems_bdbuf_get_buffer_for_access+0x120>
}
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);
bb1c: e1a00008 mov r0, r8
bb20: e59f1100 ldr r1, [pc, #256] ; bc28 <rtems_bdbuf_get_buffer_for_access+0x1c8>
bb24: ea000001 b bb30 <rtems_bdbuf_get_buffer_for_access+0xd0>
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);
bb28: e59f10fc ldr r1, [pc, #252] ; bc2c <rtems_bdbuf_get_buffer_for_access+0x1cc><== NOT EXECUTED
bb2c: e1a00008 mov r0, r8 <== NOT EXECUTED
bb30: ebfffd57 bl b094 <rtems_bdbuf_wait>
bb34: eaffffda b baa4 <rtems_bdbuf_get_buffer_for_access+0x44>
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_8);
bb38: e3a01014 mov r1, #20 <== NOT EXECUTED
bb3c: ea000031 b bc08 <rtems_bdbuf_get_buffer_for_access+0x1a8> <== NOT EXECUTED
{
if (bd->group->bds_per_group != dd->bds_per_group)
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
bb40: e1a00008 mov r0, r8 <== NOT EXECUTED
bb44: ebfffec9 bl b670 <rtems_bdbuf_remove_from_tree_and_lru_list><== NOT EXECUTED
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
bb48: e1a00008 mov r0, r8 <== NOT EXECUTED
bb4c: ebfffc7a bl ad3c <rtems_bdbuf_make_free_and_add_to_lru_list><== NOT EXECUTED
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
bb50: e59f00d8 ldr r0, [pc, #216] ; bc30 <rtems_bdbuf_get_buffer_for_access+0x1d0><== NOT EXECUTED
bb54: ebfffda9 bl b200 <rtems_bdbuf_wake> <== NOT EXECUTED
bb58: eaffffc5 b ba74 <rtems_bdbuf_get_buffer_for_access+0x14> <== NOT EXECUTED
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
bb5c: e1a00005 mov r0, r5
bb60: e1a01006 mov r1, r6
bb64: ebfffed1 bl b6b0 <rtems_bdbuf_get_buffer_from_lru_list>
if (bd == NULL)
bb68: e2508000 subs r8, r0, #0
bb6c: 1a000006 bne bb8c <rtems_bdbuf_get_buffer_for_access+0x12c>
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
bb70: e594204c ldr r2, [r4, #76] ; 0x4c
bb74: e59f30b8 ldr r3, [pc, #184] ; bc34 <rtems_bdbuf_get_buffer_for_access+0x1d4>
bb78: e1520003 cmp r2, r3
rtems_bdbuf_wake_swapper ();
bb7c: 1bfffcfe blne af7c <rtems_bdbuf_wake_swapper>
rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);
bb80: e59f00a8 ldr r0, [pc, #168] ; bc30 <rtems_bdbuf_get_buffer_for_access+0x1d0>
bb84: ebfffd28 bl b02c <rtems_bdbuf_anonymous_wait>
bb88: eaffffb9 b ba74 <rtems_bdbuf_get_buffer_for_access+0x14>
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
bb8c: e5980020 ldr r0, [r8, #32]
bb90: e2403001 sub r3, r0, #1
bb94: e3530009 cmp r3, #9
bb98: 979ff103 ldrls pc, [pc, r3, lsl #2]
bb9c: ea000018 b bc04 <rtems_bdbuf_get_buffer_for_access+0x1a4> <== NOT EXECUTED
bba0: 0000bc0c .word 0x0000bc0c <== NOT EXECUTED
bba4: 0000bbd8 .word 0x0000bbd8 <== NOT EXECUTED
bba8: 0000bbe8 .word 0x0000bbe8 <== NOT EXECUTED
bbac: 0000bbe8 .word 0x0000bbe8 <== NOT EXECUTED
bbb0: 0000bbe8 .word 0x0000bbe8 <== NOT EXECUTED
bbb4: 0000bbe8 .word 0x0000bbe8 <== NOT EXECUTED
bbb8: 0000bbc8 .word 0x0000bbc8 <== NOT EXECUTED
bbbc: 0000bbf4 .word 0x0000bbf4 <== NOT EXECUTED
bbc0: 0000bbf4 .word 0x0000bbf4 <== NOT EXECUTED
bbc4: 0000bbf4 .word 0x0000bbf4 <== NOT EXECUTED
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
bbc8: e5983028 ldr r3, [r8, #40] ; 0x28
bbcc: e593200c ldr r2, [r3, #12]
bbd0: e2422001 sub r2, r2, #1
bbd4: e583200c str r2, [r3, #12]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
bbd8: e898000c ldm r8, {r2, r3}
next->previous = previous;
bbdc: e5823004 str r3, [r2, #4]
previous->next = next;
bbe0: e5832000 str r2, [r3]
bbe4: ea000008 b bc0c <rtems_bdbuf_get_buffer_for_access+0x1ac>
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);
bbe8: e1a00008 mov r0, r8
bbec: e59f1034 ldr r1, [pc, #52] ; bc28 <rtems_bdbuf_get_buffer_for_access+0x1c8>
bbf0: ea000001 b bbfc <rtems_bdbuf_get_buffer_for_access+0x19c>
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);
bbf4: e59f1030 ldr r1, [pc, #48] ; bc2c <rtems_bdbuf_get_buffer_for_access+0x1cc>
bbf8: e1a00008 mov r0, r8
bbfc: ebfffd24 bl b094 <rtems_bdbuf_wait>
bc00: eaffffe1 b bb8c <rtems_bdbuf_get_buffer_for_access+0x12c>
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_7);
bc04: e3a01013 mov r1, #19 <== NOT EXECUTED
bc08: ebfffcc6 bl af28 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
bc0c: e5983028 ldr r3, [r8, #40] ; 0x28
bc10: e593200c ldr r2, [r3, #12]
bc14: e2822001 add r2, r2, #1
bc18: e583200c str r2, [r3, #12]
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
return bd;
}
bc1c: e1a00008 mov r0, r8
bc20: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
0000ba08 <rtems_bdbuf_get_buffer_for_read_ahead>:
rtems_bdbuf_get_buffer_for_read_ahead (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
ba08: e59f304c ldr r3, [pc, #76] ; ba5c <rtems_bdbuf_get_buffer_for_read_ahead+0x54>
}
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_read_ahead (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
ba0c: e92d4030 push {r4, r5, lr}
ba10: e1a05000 mov r5, r0
ba14: e1a04001 mov r4, r1
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
ba18: e593003c ldr r0, [r3, #60] ; 0x3c
ba1c: e1a01005 mov r1, r5
ba20: e1a02004 mov r2, r4
ba24: ebfffdd4 bl b17c <rtems_bdbuf_avl_search.isra.0>
if (bd == NULL)
ba28: e3500000 cmp r0, #0
ba2c: 1a000008 bne ba54 <rtems_bdbuf_get_buffer_for_read_ahead+0x4c>
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
ba30: e1a00005 mov r0, r5
ba34: e1a01004 mov r1, r4
ba38: ebffff1c bl b6b0 <rtems_bdbuf_get_buffer_from_lru_list>
if (bd != NULL)
ba3c: e3500000 cmp r0, #0
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
ba40: 15903028 ldrne r3, [r0, #40] ; 0x28
ba44: 1593200c ldrne r2, [r3, #12]
ba48: 12822001 addne r2, r2, #1
ba4c: 1583200c strne r2, [r3, #12]
ba50: e8bd8030 pop {r4, r5, pc}
else
/*
* The buffer is in the cache. So it is already available or in use, and
* thus no need for a read ahead.
*/
bd = NULL;
ba54: e3a00000 mov r0, #0 <== NOT EXECUTED
return bd;
}
ba58: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
0000b6b0 <rtems_bdbuf_get_buffer_from_lru_list>:
}
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_from_lru_list (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
b6b0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
b6b4: e59f7340 ldr r7, [pc, #832] ; b9fc <rtems_bdbuf_get_buffer_from_lru_list+0x34c>
b6b8: e24dd088 sub sp, sp, #136 ; 0x88
b6bc: e1a06000 mov r6, r0
b6c0: e58d1004 str r1, [sp, #4]
b6c4: e5975040 ldr r5, [r7, #64] ; 0x40
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)
b6c8: e3a09038 mov r9, #56 ; 0x38
rtems_bdbuf_get_buffer_from_lru_list (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
b6cc: ea0000c2 b b9dc <rtems_bdbuf_get_buffer_from_lru_list+0x32c>
bd->group->bds_per_group, dd->bds_per_group);
/*
* If nobody waits for this BD, we may recycle it.
*/
if (bd->waiters == 0)
b6d0: e5953024 ldr r3, [r5, #36] ; 0x24
b6d4: e3530000 cmp r3, #0
b6d8: 1a0000be bne b9d8 <rtems_bdbuf_get_buffer_from_lru_list+0x328>
{
if (bd->group->bds_per_group == dd->bds_per_group)
b6dc: e5954028 ldr r4, [r5, #40] ; 0x28
b6e0: e5968034 ldr r8, [r6, #52] ; 0x34
b6e4: e5941008 ldr r1, [r4, #8]
b6e8: e1510008 cmp r1, r8
b6ec: 1a000003 bne b700 <rtems_bdbuf_get_buffer_from_lru_list+0x50>
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
b6f0: e1a00005 mov r0, r5
b6f4: ebffffdd bl b670 <rtems_bdbuf_remove_from_tree_and_lru_list>
b6f8: e1a00005 mov r0, r5
b6fc: ea000024 b b794 <rtems_bdbuf_get_buffer_from_lru_list+0xe4>
empty_bd = bd;
}
else if (bd->group->users == 0)
b700: e594b00c ldr fp, [r4, #12]
b704: e35b0000 cmp fp, #0
b708: 1a0000b2 bne b9d8 <rtems_bdbuf_get_buffer_from_lru_list+0x328>
if (rtems_bdbuf_tracer)
printf ("bdbuf:realloc: %tu: %zd -> %zd\n",
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
b70c: e5970020 ldr r0, [r7, #32]
b710: eb003b8e bl 1a550 <__aeabi_uidiv>
for (b = 0, bd = group->bdbuf;
b714: e594a010 ldr sl, [r4, #16]
b < group->bds_per_group;
b++, bd += bufs_per_bd)
b718: e0030099 mul r3, r9, r0
b71c: ea000005 b b738 <rtems_bdbuf_get_buffer_from_lru_list+0x88>
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
b720: e1a0000a mov r0, sl
b724: e58d3000 str r3, [sp]
b728: ebffffd0 bl b670 <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)
b72c: e59d3000 ldr r3, [sp]
b730: e28bb001 add fp, fp, #1
b734: e08aa003 add sl, sl, r3
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;
b738: e5942008 ldr r2, [r4, #8]
b73c: e15b0002 cmp fp, r2
b740: 3afffff6 bcc b720 <rtems_bdbuf_get_buffer_from_lru_list+0x70>
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;
b744: e5848008 str r8, [r4, #8]
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
b748: e1a01008 mov r1, r8
b74c: e5970020 ldr r0, [r7, #32]
b750: eb003b7e bl 1a550 <__aeabi_uidiv>
for (b = 1, bd = group->bdbuf + bufs_per_bd;
b754: e00b0099 mul fp, r9, r0
b758: e594a010 ldr sl, [r4, #16]
b75c: e3a08001 mov r8, #1
b760: e08aa00b add sl, sl, fp
b764: ea000003 b b778 <rtems_bdbuf_get_buffer_from_lru_list+0xc8>
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
b768: e1a0000a mov r0, sl
b76c: ebfffd72 bl ad3c <rtems_bdbuf_make_free_and_add_to_lru_list>
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)
b770: e2888001 add r8, r8, #1
b774: e08aa00b add sl, sl, fp
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;
b778: e5943008 ldr r3, [r4, #8]
b77c: e1580003 cmp r8, r3
b780: 3afffff8 bcc b768 <rtems_bdbuf_get_buffer_from_lru_list+0xb8>
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
if (b > 1)
b784: e3580001 cmp r8, #1
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
b788: 859f0270 ldrhi r0, [pc, #624] ; ba00 <rtems_bdbuf_get_buffer_from_lru_list+0x350>
b78c: 8bfffe9b blhi b200 <rtems_bdbuf_wake>
return group->bdbuf;
b790: e5940010 ldr r0, [r4, #16]
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, dd->bds_per_group);
}
if (empty_bd != NULL)
b794: e3500000 cmp r0, #0
b798: 0a00008e beq b9d8 <rtems_bdbuf_get_buffer_from_lru_list+0x328>
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
bd->block = block;
b79c: e59d3004 ldr r3, [sp, #4]
b7a0: e5803018 str r3, [r0, #24]
bd->avl.left = NULL;
b7a4: e3a03000 mov r3, #0
static void
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
b7a8: e5806014 str r6, [r0, #20]
bd->block = block; bd->avl.left = NULL;
b7ac: e5803008 str r3, [r0, #8]
bd->avl.right = NULL;
b7b0: e580300c str r3, [r0, #12]
rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
b7b4: e59f2240 ldr r2, [pc, #576] ; b9fc <rtems_bdbuf_get_buffer_from_lru_list+0x34c>
{
bd->dd = dd ;
bd->block = block;
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
b7b8: e5803024 str r3, [r0, #36] ; 0x24
rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
b7bc: e592303c ldr r3, [r2, #60] ; 0x3c
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
b7c0: e3530000 cmp r3, #0
rtems_bdbuf_buffer* p = *root; rtems_bdbuf_buffer* q; rtems_bdbuf_buffer* p1; rtems_bdbuf_buffer* p2; rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT]; rtems_bdbuf_buffer** buf_prev = buf_stack;
b7c4: 128d5008 addne r5, sp, #8
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
b7c8: 13a04001 movne r4, #1
break;
}
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
b7cc: 13e0c000 mvnne ip, #0
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
b7d0: 1a000017 bne b834 <rtems_bdbuf_get_buffer_from_lru_list+0x184>
{
*root = node;
b7d4: e582003c str r0, [r2, #60] ; 0x3c
node->avl.left = NULL;
b7d8: e5803008 str r3, [r0, #8]
node->avl.right = NULL;
b7dc: e580300c str r3, [r0, #12]
node->avl.bal = 0;
b7e0: e5c03011 strb r3, [r0, #17]
b7e4: ea000078 b b9cc <rtems_bdbuf_get_buffer_from_lru_list+0x31c>
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
b7e8: 1a00000a bne b818 <rtems_bdbuf_get_buffer_from_lru_list+0x168>
b7ec: e5932018 ldr r2, [r3, #24]
b7f0: e59d7004 ldr r7, [sp, #4]
b7f4: e1520007 cmp r2, r7
b7f8: 2a000005 bcs b814 <rtems_bdbuf_get_buffer_from_lru_list+0x164>
{
p->avl.cache = 1;
q = p->avl.right;
b7fc: e593200c ldr r2, [r3, #12]
if (q == NULL)
b800: e3520000 cmp r2, #0
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
b804: e5c34010 strb r4, [r3, #16]
q = p->avl.right;
if (q == NULL)
b808: 1a000007 bne b82c <rtems_bdbuf_get_buffer_from_lru_list+0x17c>
{
q = node;
p->avl.right = q = node;
b80c: e583000c str r0, [r3, #12]
b810: ea00000d b b84c <rtems_bdbuf_get_buffer_from_lru_list+0x19c>
break;
}
}
else if ((p->dd != dd) || (p->block != block))
b814: 0a000076 beq b9f4 <rtems_bdbuf_get_buffer_from_lru_list+0x344>
{
p->avl.cache = -1;
q = p->avl.left;
b818: e5932008 ldr r2, [r3, #8]
if (q == NULL)
b81c: e3520000 cmp r2, #0
break;
}
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
b820: e5c3c010 strb ip, [r3, #16]
q = p->avl.left;
if (q == NULL)
{
q = node;
p->avl.left = q;
b824: 05830008 streq r0, [r3, #8]
b828: 0a000007 beq b84c <rtems_bdbuf_get_buffer_from_lru_list+0x19c>
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
b82c: e1a05001 mov r5, r1
b830: e1a03002 mov r3, r2
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
b834: e5932014 ldr r2, [r3, #20]
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
b838: e1a01005 mov r1, r5
if (((uintptr_t) p->dd < (uintptr_t) dd)
b83c: e1520006 cmp r2, r6
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
b840: e4813004 str r3, [r1], #4
if (((uintptr_t) p->dd < (uintptr_t) dd)
b844: 3affffec bcc b7fc <rtems_bdbuf_get_buffer_from_lru_list+0x14c>
b848: eaffffe6 b b7e8 <rtems_bdbuf_get_buffer_from_lru_list+0x138>
}
p = q;
}
q->avl.left = q->avl.right = NULL;
b84c: e3a01000 mov r1, #0
b850: e580100c str r1, [r0, #12]
b854: e5801008 str r1, [r0, #8]
q->avl.bal = 0;
b858: e5c01011 strb r1, [r0, #17]
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
b85c: e3a06001 mov r6, #1
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
b860: e28d7008 add r7, sp, #8
b864: ea000000 b b86c <rtems_bdbuf_get_buffer_from_lru_list+0x1bc>
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
b868: e1a0300c mov r3, ip
{
if (p->avl.cache == -1)
b86c: e1d321d0 ldrsb r2, [r3, #16]
b870: e3720001 cmn r2, #1
b874: e1d3c1d1 ldrsb ip, [r3, #17]
b878: 1a00001f bne b8fc <rtems_bdbuf_get_buffer_from_lru_list+0x24c>
{
switch (p->avl.bal)
b87c: e35c0000 cmp ip, #0
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = -1;
b880: 05c32011 strbeq r2, [r3, #17]
while (modified)
{
if (p->avl.cache == -1)
{
switch (p->avl.bal)
b884: 0a000042 beq b994 <rtems_bdbuf_get_buffer_from_lru_list+0x2e4>
b888: e35c0001 cmp ip, #1
b88c: 0a000021 beq b918 <rtems_bdbuf_get_buffer_from_lru_list+0x268>
b890: e37c0001 cmn ip, #1
b894: 1a00003e bne b994 <rtems_bdbuf_get_buffer_from_lru_list+0x2e4>
case 0:
p->avl.bal = -1;
break;
case -1:
p1 = p->avl.left;
b898: e5934008 ldr r4, [r3, #8]
if (p1->avl.bal == -1) /* simple LL-turn */
b89c: e1d421d1 ldrsb r2, [r4, #17]
b8a0: e3720001 cmn r2, #1
b8a4: e594200c ldr r2, [r4, #12]
{
p->avl.left = p1->avl.right;
b8a8: 05832008 streq r2, [r3, #8]
p1->avl.right = p;
b8ac: 0584300c streq r3, [r4, #12]
p->avl.bal = 0;
b8b0: 05c31011 strbeq r1, [r3, #17]
b8b4: 01a02004 moveq r2, r4
b8b8: 0a000031 beq b984 <rtems_bdbuf_get_buffer_from_lru_list+0x2d4>
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
b8bc: e5928008 ldr r8, [r2, #8]
b8c0: e584800c str r8, [r4, #12]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
b8c4: e592800c ldr r8, [r2, #12]
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
b8c8: e5824008 str r4, [r2, #8]
p->avl.left = p2->avl.right;
b8cc: e5838008 str r8, [r3, #8]
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
b8d0: e1d281d1 ldrsb r8, [r2, #17]
b8d4: e3780001 cmn r8, #1
b8d8: 13a08000 movne r8, #0
b8dc: 03a08001 moveq r8, #1
b8e0: e5c38011 strb r8, [r3, #17]
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
b8e4: e582300c str r3, [r2, #12]
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;
b8e8: e1d231d1 ldrsb r3, [r2, #17]
b8ec: e3530001 cmp r3, #1
b8f0: 11a0c001 movne ip, r1
b8f4: e5c4c011 strb ip, [r4, #17]
b8f8: ea000021 b b984 <rtems_bdbuf_get_buffer_from_lru_list+0x2d4>
break;
}
}
else
{
switch (p->avl.bal)
b8fc: e35c0000 cmp ip, #0
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
b900: 05c36011 strbeq r6, [r3, #17]
break;
}
}
else
{
switch (p->avl.bal)
b904: 0a000022 beq b994 <rtems_bdbuf_get_buffer_from_lru_list+0x2e4>
b908: e35c0001 cmp ip, #1
b90c: 0a000003 beq b920 <rtems_bdbuf_get_buffer_from_lru_list+0x270>
b910: e37c0001 cmn ip, #1
b914: 1a00001e bne b994 <rtems_bdbuf_get_buffer_from_lru_list+0x2e4>
{
case -1:
p->avl.bal = 0;
b918: e5c31011 strb r1, [r3, #17]
b91c: ea00001a b b98c <rtems_bdbuf_get_buffer_from_lru_list+0x2dc>
case 0:
p->avl.bal = 1;
break;
case 1:
p1 = p->avl.right;
b920: e593c00c ldr ip, [r3, #12]
if (p1->avl.bal == 1) /* simple RR-turn */
b924: e1dc21d1 ldrsb r2, [ip, #17]
b928: e3520001 cmp r2, #1
b92c: e59c2008 ldr r2, [ip, #8]
{
p->avl.right = p1->avl.left;
b930: 0583200c streq r2, [r3, #12]
p1->avl.left = p;
b934: 058c3008 streq r3, [ip, #8]
p->avl.bal = 0;
b938: 05c31011 strbeq r1, [r3, #17]
b93c: 01a0200c moveq r2, ip
b940: 0a00000f beq b984 <rtems_bdbuf_get_buffer_from_lru_list+0x2d4>
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
b944: e592400c ldr r4, [r2, #12]
b948: e58c4008 str r4, [ip, #8]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
b94c: e5924008 ldr r4, [r2, #8]
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
b950: e582c00c str ip, [r2, #12]
p->avl.right = p2->avl.left;
b954: e583400c str r4, [r3, #12]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
b958: e1d241d1 ldrsb r4, [r2, #17]
b95c: e3540001 cmp r4, #1
b960: 03a040ff moveq r4, #255 ; 0xff
b964: 13a04000 movne r4, #0
b968: e5c34011 strb r4, [r3, #17]
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
b96c: e5823008 str r3, [r2, #8]
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;
b970: e1d231d1 ldrsb r3, [r2, #17]
b974: e3730001 cmn r3, #1
b978: 11a03001 movne r3, r1
b97c: 01a03006 moveq r3, r6
b980: e5cc3011 strb r3, [ip, #17]
p = p2;
}
p->avl.bal = 0;
b984: e5c21011 strb r1, [r2, #17]
b988: e1a03002 mov r3, r2
modified = false;
b98c: e3a02000 mov r2, #0
b990: ea000000 b b998 <rtems_bdbuf_get_buffer_from_lru_list+0x2e8>
break;
}
}
else
{
switch (p->avl.bal)
b994: e3a02001 mov r2, #1
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
b998: e1550007 cmp r5, r7
b99c: 9a000008 bls b9c4 <rtems_bdbuf_get_buffer_from_lru_list+0x314>
{
p = *--buf_prev;
b9a0: e515c004 ldr ip, [r5, #-4]
if (p->avl.cache == -1)
b9a4: e1dc41d0 ldrsb r4, [ip, #16]
b9a8: e3740001 cmn r4, #1
{
p->avl.left = q;
b9ac: 058c3008 streq r3, [ip, #8]
}
else
{
p->avl.right = q;
b9b0: 158c300c strne r3, [ip, #12]
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
b9b4: e3520000 cmp r2, #0
p->avl.right = q;
}
}
else
{
*root = p;
b9b8: e2455004 sub r5, r5, #4
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
b9bc: 1affffa9 bne b868 <rtems_bdbuf_get_buffer_from_lru_list+0x1b8>
b9c0: ea000001 b b9cc <rtems_bdbuf_get_buffer_from_lru_list+0x31c>
p->avl.right = q;
}
}
else
{
*root = p;
b9c4: e59f2030 ldr r2, [pc, #48] ; b9fc <rtems_bdbuf_get_buffer_from_lru_list+0x34c>
b9c8: e582303c str r3, [r2, #60] ; 0x3c
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
b9cc: e3a03001 mov r3, #1
b9d0: e5803020 str r3, [r0, #32]
if (empty_bd != NULL)
{
rtems_bdbuf_setup_empty_buffer (empty_bd, dd, block);
return empty_bd;
b9d4: ea000004 b b9ec <rtems_bdbuf_get_buffer_from_lru_list+0x33c>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
b9d8: e5955000 ldr r5, [r5]
rtems_bdbuf_get_buffer_from_lru_list (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
b9dc: e59f3020 ldr r3, [pc, #32] ; ba04 <rtems_bdbuf_get_buffer_from_lru_list+0x354>
b9e0: e1550003 cmp r5, r3
b9e4: 1affff39 bne b6d0 <rtems_bdbuf_get_buffer_from_lru_list+0x20>
}
node = rtems_chain_next (node);
}
return NULL;
b9e8: e3a00000 mov r0, #0
}
b9ec: e28dd088 add sp, sp, #136 ; 0x88
b9f0: 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_bdbuf_fatal (RTEMS_BDBUF_FATAL_RECYCLE);
b9f4: e3a00008 mov r0, #8 <== NOT EXECUTED
b9f8: ebfffd30 bl aec0 <rtems_bdbuf_fatal> <== NOT EXECUTED
0000c4f8 <rtems_bdbuf_init>:
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
c4f8: 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())
c4fc: e59f33dc ldr r3, [pc, #988] ; c8e0 <rtems_bdbuf_init+0x3e8>
c500: e5933000 ldr r3, [r3]
c504: e3530000 cmp r3, #0
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
c508: e24dd018 sub sp, sp, #24
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
return RTEMS_CALLED_FROM_ISR;
c50c: 13a00012 movne r0, #18
rtems_mode prev_mode;
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
c510: 1a0000f0 bne c8d8 <rtems_bdbuf_init+0x3e0>
return RTEMS_CALLED_FROM_ISR;
/*
* Check the configuration table values.
*/
if ((bdbuf_config.buffer_max % bdbuf_config.buffer_min) != 0)
c514: e59f63c8 ldr r6, [pc, #968] ; c8e4 <rtems_bdbuf_init+0x3ec>
c518: e2864024 add r4, r6, #36 ; 0x24
c51c: e8940210 ldm r4, {r4, r9}
c520: e1a00009 mov r0, r9
c524: e1a01004 mov r1, r4
c528: eb00384e bl 1a668 <__umodsi3>
c52c: e3500000 cmp r0, #0
return RTEMS_INVALID_NUMBER;
c530: 13a0000a movne r0, #10
return RTEMS_CALLED_FROM_ISR;
/*
* Check the configuration table values.
*/
if ((bdbuf_config.buffer_max % bdbuf_config.buffer_min) != 0)
c534: 1a0000e7 bne c8d8 <rtems_bdbuf_init+0x3e0>
/*
* 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 ();
c538: ebfffaa3 bl afcc <rtems_bdbuf_disable_preemption>
if (bdbuf_cache.initialised)
c53c: e59f53a4 ldr r5, [pc, #932] ; c8e8 <rtems_bdbuf_init+0x3f0>
c540: e5d58095 ldrb r8, [r5, #149] ; 0x95
c544: e3580000 cmp r8, #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 ();
c548: e1a0a000 mov sl, r0
if (bdbuf_cache.initialised)
c54c: 0a000002 beq c55c <rtems_bdbuf_init+0x64>
{
rtems_bdbuf_restore_preemption (prev_mode);
c550: ebfffaaa bl b000 <rtems_bdbuf_restore_preemption> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
c554: e3a0000c mov r0, #12 <== NOT EXECUTED
c558: ea0000de b c8d8 <rtems_bdbuf_init+0x3e0> <== NOT EXECUTED
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
c55c: e1a01008 mov r1, r8
c560: e3a02098 mov r2, #152 ; 0x98
bdbuf_cache.initialised = true;
c564: e3a07001 mov r7, #1
{
rtems_bdbuf_restore_preemption (prev_mode);
return RTEMS_RESOURCE_IN_USE;
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
c568: e1a00005 mov r0, r5
c56c: eb0016b1 bl 12038 <memset>
bdbuf_cache.initialised = true; rtems_bdbuf_restore_preemption (prev_mode);
c570: e1a0000a mov r0, sl
rtems_bdbuf_restore_preemption (prev_mode);
return RTEMS_RESOURCE_IN_USE;
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
bdbuf_cache.initialised = true;
c574: e5c57095 strb r7, [r5, #149] ; 0x95
rtems_bdbuf_restore_preemption (prev_mode);
c578: ebfffaa0 bl b000 <rtems_bdbuf_restore_preemption>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
c57c: e285300c add r3, r5, #12
c580: e5853008 str r3, [r5, #8]
head->previous = NULL; tail->previous = head;
c584: e2853008 add r3, r5, #8
c588: e5853010 str r3, [r5, #16]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
c58c: e2853044 add r3, r5, #68 ; 0x44
c590: e5853040 str r3, [r5, #64] ; 0x40
head->previous = NULL; tail->previous = head;
c594: e2853040 add r3, r5, #64 ; 0x40
c598: e5853048 str r3, [r5, #72] ; 0x48
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
c59c: e2853050 add r3, r5, #80 ; 0x50
c5a0: e585304c str r3, [r5, #76] ; 0x4c
head->previous = NULL; tail->previous = head;
c5a4: e285304c add r3, r5, #76 ; 0x4c
c5a8: e5853054 str r3, [r5, #84] ; 0x54
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
c5ac: e285305c add r3, r5, #92 ; 0x5c
c5b0: e5853058 str r3, [r5, #88] ; 0x58
head->previous = NULL; tail->previous = head;
c5b4: e2853058 add r3, r5, #88 ; 0x58
c5b8: e5853060 str r3, [r5, #96] ; 0x60
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
c5bc: e285308c add r3, r5, #140 ; 0x8c
c5c0: e5853088 str r3, [r5, #136] ; 0x88
head->previous = NULL; tail->previous = head;
c5c4: e2853088 add r3, r5, #136 ; 0x88
c5c8: e5853090 str r3, [r5, #144] ; 0x90
rtems_chain_initialize_empty (&bdbuf_cache.read_ahead_chain);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
c5cc: e2853028 add r3, r5, #40 ; 0x28
*/
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;
c5d0: e5858038 str r8, [r5, #56] ; 0x38
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
c5d4: e585800c str r8, [r5, #12]
c5d8: e5858044 str r8, [r5, #68] ; 0x44
c5dc: e5858050 str r8, [r5, #80] ; 0x50
c5e0: e585805c str r8, [r5, #92] ; 0x5c
c5e4: e585808c str r8, [r5, #140] ; 0x8c
rtems_chain_initialize_empty (&bdbuf_cache.read_ahead_chain);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
c5e8: e59f02fc ldr r0, [pc, #764] ; c8ec <rtems_bdbuf_init+0x3f4>
c5ec: e58d3000 str r3, [sp]
c5f0: e1a01007 mov r1, r7
c5f4: e1a03008 mov r3, r8
c5f8: e3a02054 mov r2, #84 ; 0x54
c5fc: ebffea8d bl 7038 <rtems_semaphore_create>
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
c600: e2508000 subs r8, r0, #0
c604: 1a000093 bne c858 <rtems_bdbuf_init+0x360>
goto error;
rtems_bdbuf_lock_cache ();
c608: ebfffa30 bl aed0 <rtems_bdbuf_lock_cache>
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'),
c60c: e285302c add r3, r5, #44 ; 0x2c
c610: e58d3000 str r3, [sp]
c614: e1a01007 mov r1, r7
c618: e59f02d0 ldr r0, [pc, #720] ; c8f0 <rtems_bdbuf_init+0x3f8>
c61c: e3a02054 mov r2, #84 ; 0x54
c620: e1a03008 mov r3, r8
c624: ebffea83 bl 7038 <rtems_semaphore_create>
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.sync_lock);
if (sc != RTEMS_SUCCESSFUL)
c628: e2501000 subs r1, r0, #0
c62c: 1a000089 bne c858 <rtems_bdbuf_init+0x360>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'),
c630: e2853068 add r3, r5, #104 ; 0x68
c634: e58d3000 str r3, [sp]
c638: e59f02b4 ldr r0, [pc, #692] ; c8f4 <rtems_bdbuf_init+0x3fc>
c63c: e1a03001 mov r3, r1
c640: e3a02024 mov r2, #36 ; 0x24
c644: ebffea7b bl 7038 <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.access_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
c648: e2501000 subs r1, r0, #0
c64c: 1a000081 bne c858 <rtems_bdbuf_init+0x360>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'),
c650: e2853070 add r3, r5, #112 ; 0x70
c654: e58d3000 str r3, [sp]
c658: e59f0298 ldr r0, [pc, #664] ; c8f8 <rtems_bdbuf_init+0x400>
c65c: e1a03001 mov r3, r1
c660: e3a02024 mov r2, #36 ; 0x24
c664: ebffea73 bl 7038 <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.transfer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
c668: e2501000 subs r1, r0, #0
c66c: 1a000079 bne c858 <rtems_bdbuf_init+0x360>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'),
c670: e2853078 add r3, r5, #120 ; 0x78
c674: e58d3000 str r3, [sp]
c678: e59f027c ldr r0, [pc, #636] ; c8fc <rtems_bdbuf_init+0x404>
c67c: e3a02024 mov r2, #36 ; 0x24
c680: e1a03001 mov r3, r1
c684: ebffea6b bl 7038 <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.buffer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
c688: e3500000 cmp r0, #0
c68c: 1a000071 bne c858 <rtems_bdbuf_init+0x360>
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
c690: e5960020 ldr r0, [r6, #32]
c694: e1a01004 mov r1, r4
c698: eb0037ac bl 1a550 <__aeabi_uidiv>
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
c69c: e1a01004 mov r1, r4
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
c6a0: e1a06000 mov r6, r0
goto error;
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
c6a4: e585001c str r0, [r5, #28]
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
c6a8: e1a00009 mov r0, r9
c6ac: eb0037a7 bl 1a550 <__aeabi_uidiv>
c6b0: 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 =
c6b4: e5850020 str r0, [r5, #32]
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
c6b8: e1a00006 mov r0, r6
c6bc: eb0037a3 bl 1a550 <__aeabi_uidiv>
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
c6c0: e1a01006 mov r1, r6
*/
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 =
c6c4: e585007c str r0, [r5, #124] ; 0x7c
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
c6c8: e1a07000 mov r7, r0
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
c6cc: e3a00038 mov r0, #56 ; 0x38
c6d0: ebffdaa2 bl 3160 <calloc>
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
c6d4: 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),
c6d8: e5850014 str r0, [r5, #20]
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
c6dc: 0a00005d beq c858 <rtems_bdbuf_init+0x360>
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
c6e0: e3a00014 mov r0, #20
c6e4: e1a01007 mov r1, r7
c6e8: ebffda9c bl 3160 <calloc>
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
c6ec: e3500000 cmp r0, #0
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
c6f0: e5850080 str r0, [r5, #128] ; 0x80
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
c6f4: 0a000057 beq c858 <rtems_bdbuf_init+0x360>
* 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,
c6f8: e59f51e8 ldr r5, [pc, #488] ; c8e8 <rtems_bdbuf_init+0x3f0>
c6fc: e3a01020 mov r1, #32
c700: e2850018 add r0, r5, #24
c704: e0020694 mul r2, r4, r6
c708: eb0006f2 bl e2d8 <rtems_memalign>
c70c: e2508000 subs r8, r0, #0
c710: 1a000050 bne c858 <rtems_bdbuf_init+0x360>
* 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;
b < bdbuf_cache.buffer_min_count;
c714: e595201c ldr r2, [r5, #28]
bd->group = group;
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
c718: e5953020 ldr r3, [r5, #32]
/*
* 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;
c71c: e285a014 add sl, r5, #20
/*
* 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,
c720: e5957080 ldr r7, [r5, #128] ; 0x80
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
c724: e89a0c00 ldm sl, {sl, fp}
b < bdbuf_cache.buffer_min_count;
c728: e58d200c str r2, [sp, #12]
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
c72c: e2432001 sub r2, r3, #1
c730: e58d2010 str r2, [sp, #16]
/*
* 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,
c734: e1a09007 mov r9, r7
c738: e58d7014 str r7, [sp, #20]
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
c73c: e1a0600a mov r6, sl
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dd = BDBUF_INVALID_DEV;
c740: e1a02008 mov r2, r8
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
c744: e285c044 add ip, r5, #68 ; 0x44
c748: e1a07003 mov r7, r3
/*
* 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,
c74c: ea000014 b c7a4 <rtems_bdbuf_init+0x2ac>
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dd = BDBUF_INVALID_DEV;
c750: e5862014 str r2, [r6, #20]
bd->group = group;
c754: e5869028 str r9, [r6, #40] ; 0x28
bd->buffer = buffer;
c758: e586b01c str fp, [r6, #28]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
c75c: e5951048 ldr r1, [r5, #72] ; 0x48
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
c760: e1a00008 mov r0, r8
the_node->next = tail;
c764: e586c000 str ip, [r6]
tail->previous = the_node; old_last->next = the_node;
c768: e5816000 str r6, [r1]
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
c76c: e5856048 str r6, [r5, #72] ; 0x48
old_last->next = the_node; the_node->previous = old_last;
c770: e5861004 str r1, [r6, #4]
c774: e1a01007 mov r1, r7
c778: e58d2008 str r2, [sp, #8]
c77c: e58dc004 str ip, [sp, #4]
c780: eb0037b8 bl 1a668 <__umodsi3>
c784: e59d3010 ldr r3, [sp, #16]
c788: e59d2008 ldr r2, [sp, #8]
c78c: e1500003 cmp r0, r3
c790: e59dc004 ldr ip, [sp, #4]
(bdbuf_cache.max_bds_per_group - 1))
group++;
c794: 02899014 addeq r9, r9, #20
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
c798: e2888001 add r8, r8, #1
c79c: e2866038 add r6, r6, #56 ; 0x38
c7a0: e08bb004 add fp, fp, r4
/*
* 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,
c7a4: e59d300c ldr r3, [sp, #12]
c7a8: e1580003 cmp r8, r3
c7ac: e59f1134 ldr r1, [pc, #308] ; c8e8 <rtems_bdbuf_init+0x3f0>
c7b0: 1affffe6 bne c750 <rtems_bdbuf_init+0x258>
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
c7b4: e5912020 ldr r2, [r1, #32]
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
c7b8: e591007c ldr r0, [r1, #124] ; 0x7c
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
c7bc: e3a01038 mov r1, #56 ; 0x38
c7c0: e59d7014 ldr r7, [sp, #20]
c7c4: e0010192 mul r1, r2, r1
c7c8: e3a03000 mov r3, #0
c7cc: ea000004 b c7e4 <rtems_bdbuf_init+0x2ec>
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
group->bdbuf = bd;
c7d0: e587a010 str sl, [r7, #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;
c7d4: e5872008 str r2, [r7, #8]
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
c7d8: e2833001 add r3, r3, #1
group++,
c7dc: e2877014 add r7, r7, #20
bd += bdbuf_cache.max_bds_per_group)
c7e0: e08aa001 add sl, sl, r1
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
c7e4: e1530000 cmp r3, r0
c7e8: 1afffff8 bne c7d0 <rtems_bdbuf_init+0x2d8>
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
c7ec: e59f40f4 ldr r4, [pc, #244] ; c8e8 <rtems_bdbuf_init+0x3f0>
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
c7f0: e59f50ec ldr r5, [pc, #236] ; c8e4 <rtems_bdbuf_init+0x3ec>
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
c7f4: e3a06001 mov r6, #1
c7f8: e5c46004 strb r6, [r4, #4]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
c7fc: e3a03000 mov r3, #0
c800: e59f00f8 ldr r0, [pc, #248] ; c900 <rtems_bdbuf_init+0x408>
c804: e5951008 ldr r1, [r5, #8]
c808: e59f20f4 ldr r2, [pc, #244] ; c904 <rtems_bdbuf_init+0x40c>
c80c: e58d4000 str r4, [sp]
c810: ebfffaae bl b2d0 <rtems_bdbuf_create_task.constprop.10>
bdbuf_config.swapout_priority,
RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_swapout_task,
0,
&bdbuf_cache.swapout);
if (sc != RTEMS_SUCCESSFUL)
c814: e2503000 subs r3, r0, #0
c818: 1a00000e bne c858 <rtems_bdbuf_init+0x360>
goto error;
if (bdbuf_config.max_read_ahead_blocks > 0)
c81c: e5952000 ldr r2, [r5]
c820: e3520000 cmp r2, #0
c824: 0a000008 beq c84c <rtems_bdbuf_init+0x354>
{
bdbuf_cache.read_ahead_enabled = true;
c828: e5c46094 strb r6, [r4, #148] ; 0x94
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'R', 'D', 'A'),
c82c: e59f00d4 ldr r0, [pc, #212] ; c908 <rtems_bdbuf_init+0x410>
c830: e2844084 add r4, r4, #132 ; 0x84
c834: e595102c ldr r1, [r5, #44] ; 0x2c
c838: e59f20cc ldr r2, [pc, #204] ; c90c <rtems_bdbuf_init+0x414>
c83c: e58d4000 str r4, [sp]
c840: ebfffaa2 bl b2d0 <rtems_bdbuf_create_task.constprop.10>
bdbuf_config.read_ahead_priority,
RTEMS_BDBUF_READ_AHEAD_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_read_ahead_task,
0,
&bdbuf_cache.read_ahead_task);
if (sc != RTEMS_SUCCESSFUL)
c844: e3500000 cmp r0, #0
c848: 1a000002 bne c858 <rtems_bdbuf_init+0x360>
goto error;
}
rtems_bdbuf_unlock_cache ();
c84c: ebfff9b8 bl af34 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
c850: e3a00000 mov r0, #0
c854: ea00001f b c8d8 <rtems_bdbuf_init+0x3e0>
error:
if (bdbuf_cache.read_ahead_task != 0)
c858: e59f4088 ldr r4, [pc, #136] ; c8e8 <rtems_bdbuf_init+0x3f0><== NOT EXECUTED
c85c: e5940084 ldr r0, [r4, #132] ; 0x84 <== NOT EXECUTED
c860: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.read_ahead_task);
c864: 1bffeb55 blne 75c0 <rtems_task_delete> <== NOT EXECUTED
if (bdbuf_cache.swapout != 0)
c868: e5940000 ldr r0, [r4] <== NOT EXECUTED
c86c: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.swapout);
c870: 1bffeb52 blne 75c0 <rtems_task_delete> <== NOT EXECUTED
free (bdbuf_cache.buffers);
c874: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED
c878: ebffdaec bl 3430 <free> <== NOT EXECUTED
free (bdbuf_cache.groups);
c87c: e5940080 ldr r0, [r4, #128] ; 0x80 <== NOT EXECUTED
c880: ebffdaea bl 3430 <free> <== NOT EXECUTED
free (bdbuf_cache.bds);
c884: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED
c888: ebffdae8 bl 3430 <free> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);
c88c: e5940078 ldr r0, [r4, #120] ; 0x78 <== NOT EXECUTED
c890: ebffea50 bl 71d8 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);
c894: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED
c898: ebffea4e bl 71d8 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
c89c: e5940070 ldr r0, [r4, #112] ; 0x70 <== NOT EXECUTED
c8a0: ebffea4c bl 71d8 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.sync_lock);
c8a4: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED
c8a8: ebffea4a bl 71d8 <rtems_semaphore_delete> <== NOT EXECUTED
if (bdbuf_cache.lock != 0)
c8ac: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
c8b0: e3530000 cmp r3, #0 <== NOT EXECUTED
c8b4: 0a000003 beq c8c8 <rtems_bdbuf_init+0x3d0> <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
c8b8: ebfff99d bl af34 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.lock);
c8bc: e59f3024 ldr r3, [pc, #36] ; c8e8 <rtems_bdbuf_init+0x3f0> <== NOT EXECUTED
c8c0: e5930028 ldr r0, [r3, #40] ; 0x28 <== NOT EXECUTED
c8c4: ebffea43 bl 71d8 <rtems_semaphore_delete> <== NOT EXECUTED
}
bdbuf_cache.initialised = false;
c8c8: e59f3018 ldr r3, [pc, #24] ; c8e8 <rtems_bdbuf_init+0x3f0> <== NOT EXECUTED
c8cc: e3a02000 mov r2, #0 <== NOT EXECUTED
c8d0: e5c32095 strb r2, [r3, #149] ; 0x95 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
c8d4: e3a0000d mov r0, #13 <== NOT EXECUTED
}
c8d8: e28dd018 add sp, sp, #24
c8dc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000aed0 <rtems_bdbuf_lock_cache>:
* Lock the cache. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_cache (void)
{
rtems_bdbuf_lock (bdbuf_cache.lock, RTEMS_BDBUF_FATAL_CACHE_LOCK);
aed0: e59f3020 ldr r3, [pc, #32] ; aef8 <rtems_bdbuf_lock_cache+0x28>
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_obtain (lock,
aed4: e3a01000 mov r1, #0
/**
* Lock the cache. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_cache (void)
{
aed8: e52de004 push {lr} ; (str lr, [sp, #-4]!)
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_obtain (lock,
aedc: e5930028 ldr r0, [r3, #40] ; 0x28
aee0: e1a02001 mov r2, r1
aee4: ebfff0e2 bl 7274 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
aee8: e3500000 cmp r0, #0
aeec: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_bdbuf_fatal (fatal_error_code);
aef0: e3a00000 mov r0, #0 <== NOT EXECUTED
aef4: ebfffff1 bl aec0 <rtems_bdbuf_fatal> <== NOT EXECUTED
0000aefc <rtems_bdbuf_lock_sync>:
* 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_BDBUF_FATAL_SYNC_LOCK);
aefc: e59f3020 ldr r3, [pc, #32] ; af24 <rtems_bdbuf_lock_sync+0x28>
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_obtain (lock,
af00: e3a01000 mov r1, #0
/**
* Lock the cache's sync. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_sync (void)
{
af04: e52de004 push {lr} ; (str lr, [sp, #-4]!)
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_obtain (lock,
af08: e593002c ldr r0, [r3, #44] ; 0x2c
af0c: e1a02001 mov r2, r1
af10: ebfff0d7 bl 7274 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
af14: e3500000 cmp r0, #0
af18: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_bdbuf_fatal (fatal_error_code);
af1c: e3a00019 mov r0, #25 <== NOT EXECUTED
af20: ebffffe6 bl aec0 <rtems_bdbuf_fatal> <== NOT EXECUTED
0000ce30 <rtems_bdbuf_purge_dev>:
}
}
void
rtems_bdbuf_purge_dev (rtems_disk_device *dd)
{
ce30: e92d41f0 push {r4, r5, r6, r7, r8, lr}
ce34: e24dd08c sub sp, sp, #140 ; 0x8c
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ce38: e28d3080 add r3, sp, #128 ; 0x80
ce3c: e1a06000 mov r6, r0
head->previous = NULL;
ce40: e3a08000 mov r8, #0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ce44: e28d7084 add r7, sp, #132 ; 0x84
head->previous = NULL; tail->previous = head;
ce48: e58d3088 str r3, [sp, #136] ; 0x88
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
ce4c: e58d8084 str r8, [sp, #132] ; 0x84
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ce50: e58d7080 str r7, [sp, #128] ; 0x80
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
ce54: ebfff81d bl aed0 <rtems_bdbuf_lock_cache>
}
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
ce58: e1a00006 mov r0, r6
ce5c: ebfff8d9 bl b1c8 <rtems_bdbuf_read_ahead_cancel>
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
ce60: e3e03000 mvn r3, #0
ce64: e586306c str r3, [r6, #108] ; 0x6c
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
const rtems_disk_device *dd)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
ce68: e59f3184 ldr r3, [pc, #388] ; cff4 <rtems_bdbuf_purge_dev+0x1c4>
*prev = NULL;
ce6c: e28d508c add r5, sp, #140 ; 0x8c
ce70: e525808c str r8, [r5, #-140]! ; 0x8c
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
const rtems_disk_device *dd)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
ce74: e593403c ldr r4, [r3, #60] ; 0x3c
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ce78: e3a08006 mov r8, #6
ce7c: ea00003e b cf7c <rtems_bdbuf_purge_dev+0x14c>
*prev = NULL;
while (cur != NULL)
{
if (cur->dd == dd)
ce80: e5943014 ldr r3, [r4, #20]
ce84: e1530006 cmp r3, r6
ce88: 1a000024 bne cf20 <rtems_bdbuf_purge_dev+0xf0>
{
switch (cur->state)
ce8c: e5943020 ldr r3, [r4, #32]
ce90: e353000a cmp r3, #10
ce94: 979ff103 ldrls pc, [pc, r3, lsl #2]
ce98: ea00001e b cf18 <rtems_bdbuf_purge_dev+0xe8> <== NOT EXECUTED
ce9c: 0000cf20 .word 0x0000cf20 <== NOT EXECUTED
cea0: 0000cf20 .word 0x0000cf20 <== NOT EXECUTED
cea4: 0000cee0 .word 0x0000cee0 <== NOT EXECUTED
cea8: 0000cf10 .word 0x0000cf10 <== NOT EXECUTED
ceac: 0000cf10 .word 0x0000cf10 <== NOT EXECUTED
ceb0: 0000cf10 .word 0x0000cf10 <== NOT EXECUTED
ceb4: 0000cf20 .word 0x0000cf20 <== NOT EXECUTED
ceb8: 0000ced0 .word 0x0000ced0 <== NOT EXECUTED
cebc: 0000cec8 .word 0x0000cec8 <== NOT EXECUTED
cec0: 0000cf04 .word 0x0000cf04 <== NOT EXECUTED
cec4: 0000cf20 .word 0x0000cf20 <== 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);
cec8: e59f0128 ldr r0, [pc, #296] ; cff8 <rtems_bdbuf_purge_dev+0x1c8>
cecc: ebfff8cb bl b200 <rtems_bdbuf_wake>
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
ced0: e5943028 ldr r3, [r4, #40] ; 0x28
ced4: e593200c ldr r2, [r3, #12]
ced8: e2422001 sub r2, r2, #1
cedc: e583200c str r2, [r3, #12]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
cee0: e894000c ldm r4, {r2, r3}
next->previous = previous;
cee4: e5823004 str r3, [r2, #4]
previous->next = next;
cee8: e5832000 str r2, [r3]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
ceec: e59d3088 ldr r3, [sp, #136] ; 0x88
the_node->next = tail;
cef0: e5847000 str r7, [r4]
tail->previous = the_node;
cef4: e58d4088 str r4, [sp, #136] ; 0x88
old_last->next = the_node;
cef8: e5834000 str r4, [r3]
the_node->previous = old_last;
cefc: e5843004 str r3, [r4, #4]
cf00: ea000006 b cf20 <rtems_bdbuf_purge_dev+0xf0>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
cf04: e3a0300a mov r3, #10
cf08: e5843020 str r3, [r4, #32]
cf0c: ea000003 b cf20 <rtems_bdbuf_purge_dev+0xf0>
cf10: e5848020 str r8, [r4, #32]
cf14: ea000001 b cf20 <rtems_bdbuf_purge_dev+0xf0>
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_bdbuf_fatal (RTEMS_BDBUF_FATAL_STATE_11);
cf18: e3a00017 mov r0, #23 <== NOT EXECUTED
cf1c: ebfff7e7 bl aec0 <rtems_bdbuf_fatal> <== NOT EXECUTED
}
}
if (cur->avl.left != NULL)
cf20: e5943008 ldr r3, [r4, #8]
cf24: e3530000 cmp r3, #0
cf28: 1a000003 bne cf3c <rtems_bdbuf_purge_dev+0x10c>
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
cf2c: e594300c ldr r3, [r4, #12]
cf30: e3530000 cmp r3, #0
cf34: 01a01005 moveq r1, r5
cf38: 0a000003 beq cf4c <rtems_bdbuf_purge_dev+0x11c>
{
/* Right */
++prev;
*prev = cur;
cf3c: e5854004 str r4, [r5, #4]
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
cf40: e2855004 add r5, r5, #4
cf44: ea00000b b cf78 <rtems_bdbuf_purge_dev+0x148>
}
}
void
rtems_bdbuf_purge_dev (rtems_disk_device *dd)
{
cf48: e1a04003 mov r4, r3
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL
cf4c: e5913000 ldr r3, [r1]
cf50: e3530000 cmp r3, #0
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
*prev = cur;
cf54: e1a05001 mov r5, r1
cur = cur->avl.right;
}
else
{
while (*prev != NULL
cf58: e2411004 sub r1, r1, #4
cf5c: 0a000005 beq cf78 <rtems_bdbuf_purge_dev+0x148>
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
cf60: e593200c ldr r2, [r3, #12]
cf64: e1540002 cmp r4, r2
cf68: 0afffff6 beq cf48 <rtems_bdbuf_purge_dev+0x118>
cf6c: e3520000 cmp r2, #0
cf70: 0afffff4 beq cf48 <rtems_bdbuf_purge_dev+0x118>
cf74: ea00001c b cfec <rtems_bdbuf_purge_dev+0x1bc>
}
if (cur->avl.left != NULL)
{
/* Left */
++prev;
cf78: e1a04003 mov r4, r3
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
cf7c: e3540000 cmp r4, #0
cf80: 1affffbe bne ce80 <rtems_bdbuf_purge_dev+0x50>
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
cf84: e28d6080 add r6, sp, #128 ; 0x80
cf88: e2868004 add r8, r6, #4
cf8c: e3a07001 mov r7, #1
cf90: ea000003 b cfa4 <rtems_bdbuf_purge_dev+0x174>
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
{
rtems_bdbuf_remove_from_tree (bd);
cf94: e1a00005 mov r0, r5
cf98: ebfff8e5 bl b334 <rtems_bdbuf_remove_from_tree>
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
cf9c: e1a00005 mov r0, r5
cfa0: ebfff765 bl ad3c <rtems_bdbuf_make_free_and_add_to_lru_list>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
cfa4: e59d5080 ldr r5, [sp, #128] ; 0x80
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
cfa8: e1550008 cmp r5, r8
cfac: 0a000008 beq cfd4 <rtems_bdbuf_purge_dev+0x1a4>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
cfb0: e5953000 ldr r3, [r5]
head->next = new_first;
new_first->previous = head;
cfb4: e5836004 str r6, [r3, #4]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
cfb8: e58d3080 str r3, [sp, #128] ; 0x80
while ((node = rtems_chain_get_unprotected (purge_list)) != NULL)
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
cfbc: e5953024 ldr r3, [r5, #36] ; 0x24
wake_buffer_waiters = true;
cfc0: e3530000 cmp r3, #0
cfc4: 03a04001 moveq r4, #1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
cfc8: e5857020 str r7, [r5, #32]
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
cfcc: 1afffff4 bne cfa4 <rtems_bdbuf_purge_dev+0x174>
cfd0: eaffffef b cf94 <rtems_bdbuf_purge_dev+0x164>
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
cfd4: e3540000 cmp r4, #0
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
cfd8: 159f001c ldrne r0, [pc, #28] ; cffc <rtems_bdbuf_purge_dev+0x1cc>
cfdc: 1bfff887 blne b200 <rtems_bdbuf_wake>
rtems_chain_initialize_empty (&purge_list); rtems_bdbuf_lock_cache (); rtems_bdbuf_read_ahead_reset (dd); rtems_bdbuf_gather_for_purge (&purge_list, dd); rtems_bdbuf_purge_list (&purge_list); rtems_bdbuf_unlock_cache ();
cfe0: ebfff7d3 bl af34 <rtems_bdbuf_unlock_cache>
}
cfe4: e28dd08c add sp, sp, #140 ; 0x8c
cfe8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
cur = *prev;
--prev;
}
if (*prev != NULL)
/* Right */
cur = (*prev)->avl.right;
cfec: e1a03002 mov r3, r2
cff0: eaffffe0 b cf78 <rtems_bdbuf_purge_dev+0x148>
0000c9d4 <rtems_bdbuf_read>:
rtems_status_code
rtems_bdbuf_read (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
c9d4: e92d41f0 push {r4, r5, r6, r7, r8, lr}
c9d8: e1a04000 mov r4, r0
c9dc: e1a05001 mov r5, r1
c9e0: e1a06002 mov r6, r2
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block;
rtems_bdbuf_lock_cache ();
c9e4: ebfff939 bl aed0 <rtems_bdbuf_lock_cache>
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
c9e8: e5943028 ldr r3, [r4, #40] ; 0x28
c9ec: e1550003 cmp r5, r3
rtems_bdbuf_read (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
c9f0: 23a07000 movcs r7, #0
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
}
else
{
sc = RTEMS_INVALID_ID;
c9f4: 23a08004 movcs r8, #4
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
c9f8: 2a000064 bcs cb90 <rtems_bdbuf_read+0x1bc>
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
c9fc: e5943030 ldr r3, [r4, #48] ; 0x30
ca00: e3530000 cmp r3, #0
return block << dd->block_to_media_block_shift;
ca04: a1a03315 lslge r3, r5, r3
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
ca08: aa000007 bge ca2c <rtems_bdbuf_read+0x58>
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
ca0c: e5940024 ldr r0, [r4, #36] ; 0x24 <== NOT EXECUTED
ca10: e0832095 umull r2, r3, r5, r0 <== NOT EXECUTED
ca14: e1a00002 mov r0, r2 <== NOT EXECUTED
ca18: e1a01003 mov r1, r3 <== NOT EXECUTED
ca1c: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
ca20: e3a03000 mov r3, #0 <== NOT EXECUTED
ca24: eb003c05 bl 1ba40 <__udivdi3> <== NOT EXECUTED
ca28: e1a03000 mov r3, r0 <== NOT EXECUTED
/*
* Compute the media block number. Drivers work with media block number not
* the block number a BD may have as this depends on the block size set by
* the user.
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
ca2c: e5941018 ldr r1, [r4, #24]
{
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dd->dev);
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
ca30: e1a00004 mov r0, r4
ca34: e0831001 add r1, r3, r1
ca38: ebfffc08 bl ba60 <rtems_bdbuf_get_buffer_for_access>
ca3c: e1a07000 mov r7, r0
switch (bd->state)
ca40: e5900020 ldr r0, [r0, #32]
ca44: e3500002 cmp r0, #2
ca48: 0a000004 beq ca60 <rtems_bdbuf_read+0x8c>
ca4c: e3500007 cmp r0, #7
ca50: 0a000007 beq ca74 <rtems_bdbuf_read+0xa0>
ca54: e3500001 cmp r0, #1
ca58: 1a000029 bne cb04 <rtems_bdbuf_read+0x130>
ca5c: ea00000b b ca90 <rtems_bdbuf_read+0xbc>
{
case RTEMS_BDBUF_STATE_CACHED:
++dd->stats.read_hits;
ca60: e5943044 ldr r3, [r4, #68] ; 0x44
ca64: e2833001 add r3, r3, #1
ca68: e5843044 str r3, [r4, #68] ; 0x44
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ca6c: e3a03003 mov r3, #3
ca70: ea000003 b ca84 <rtems_bdbuf_read+0xb0>
case RTEMS_BDBUF_STATE_CACHED:
++dd->stats.read_hits;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_CACHED);
break;
case RTEMS_BDBUF_STATE_MODIFIED:
++dd->stats.read_hits;
ca74: e5943044 ldr r3, [r4, #68] ; 0x44
ca78: e2833001 add r3, r3, #1
ca7c: e5843044 str r3, [r4, #68] ; 0x44
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ca80: e3a03004 mov r3, #4
ca84: e5873020 str r3, [r7, #32]
ca88: e3a08000 mov r8, #0
ca8c: ea00001e b cb0c <rtems_bdbuf_read+0x138>
case RTEMS_BDBUF_STATE_MODIFIED:
++dd->stats.read_hits;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
case RTEMS_BDBUF_STATE_EMPTY:
++dd->stats.read_misses;
ca90: e5943048 ldr r3, [r4, #72] ; 0x48
ca94: e2833001 add r3, r3, #1
ca98: e5843048 str r3, [r4, #72] ; 0x48
static void
rtems_bdbuf_set_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (dd->read_ahead.trigger != block)
ca9c: e594306c ldr r3, [r4, #108] ; 0x6c
caa0: e1530005 cmp r3, r5
caa4: 0a000005 beq cac0 <rtems_bdbuf_read+0xec>
{
rtems_bdbuf_read_ahead_cancel (dd);
caa8: e1a00004 mov r0, r4
caac: ebfff9c5 bl b1c8 <rtems_bdbuf_read_ahead_cancel>
dd->read_ahead.trigger = block + 1;
cab0: e2853001 add r3, r5, #1
cab4: e584306c str r3, [r4, #108] ; 0x6c
dd->read_ahead.next = block + 2;
cab8: e2853002 add r3, r5, #2
cabc: e5843070 str r3, [r4, #112] ; 0x70
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
case RTEMS_BDBUF_STATE_EMPTY:
++dd->stats.read_misses;
rtems_bdbuf_set_read_ahead_trigger (dd, block);
sc = rtems_bdbuf_execute_read_request (dd, bd, 1);
cac0: e1a01007 mov r1, r7
cac4: e1a00004 mov r0, r4
cac8: e3a02001 mov r2, #1
cacc: ebfffe05 bl c2e8 <rtems_bdbuf_execute_read_request>
if (sc == RTEMS_SUCCESSFUL)
cad0: e2508000 subs r8, r0, #0
rtems_chain_extract_unprotected (&bd->link);
rtems_bdbuf_group_obtain (bd);
}
else
{
bd = NULL;
cad4: 13a07000 movne r7, #0
break;
case RTEMS_BDBUF_STATE_EMPTY:
++dd->stats.read_misses;
rtems_bdbuf_set_read_ahead_trigger (dd, block);
sc = rtems_bdbuf_execute_read_request (dd, bd, 1);
if (sc == RTEMS_SUCCESSFUL)
cad8: 1a00000b bne cb0c <rtems_bdbuf_read+0x138>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
cadc: e3a03003 mov r3, #3
cae0: e5873020 str r3, [r7, #32]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
cae4: e897000c ldm r7, {r2, r3}
next->previous = previous;
cae8: e5823004 str r3, [r2, #4]
previous->next = next;
caec: e5832000 str r2, [r3]
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
caf0: e5973028 ldr r3, [r7, #40] ; 0x28
caf4: e593200c ldr r2, [r3, #12]
caf8: e2822001 add r2, r2, #1
cafc: e583200c str r2, [r3, #12]
cb00: ea000001 b cb0c <rtems_bdbuf_read+0x138>
{
bd = NULL;
}
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_4);
cb04: e3a01010 mov r1, #16 <== NOT EXECUTED
cb08: ebfff906 bl af28 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
static void
rtems_bdbuf_check_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (bdbuf_cache.read_ahead_task != 0
cb0c: e59f308c ldr r3, [pc, #140] ; cba0 <rtems_bdbuf_read+0x1cc>
cb10: e5930084 ldr r0, [r3, #132] ; 0x84
cb14: e3500000 cmp r0, #0
cb18: 0a00001c beq cb90 <rtems_bdbuf_read+0x1bc>
&& dd->read_ahead.trigger == block
cb1c: e594306c ldr r3, [r4, #108] ; 0x6c
cb20: e1530005 cmp r3, r5
cb24: 1a000019 bne cb90 <rtems_bdbuf_read+0x1bc>
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
cb28: e5943064 ldr r3, [r4, #100] ; 0x64
cb2c: e3530000 cmp r3, #0
cb30: 13a03000 movne r3, #0
cb34: 1a000002 bne cb44 <rtems_bdbuf_read+0x170>
dd->read_ahead.next = block + 2;
}
}
rtems_status_code
rtems_bdbuf_read (rtems_disk_device *dd,
cb38: e5943068 ldr r3, [r4, #104] ; 0x68
cb3c: e2733001 rsbs r3, r3, #1
cb40: 33a03000 movcc r3, #0
rtems_bdbuf_check_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (bdbuf_cache.read_ahead_task != 0
&& dd->read_ahead.trigger == block
&& !rtems_bdbuf_is_read_ahead_active (dd))
cb44: e3530000 cmp r3, #0
cb48: 0a000010 beq cb90 <rtems_bdbuf_read+0x1bc>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
cb4c: e59f504c ldr r5, [pc, #76] ; cba0 <rtems_bdbuf_read+0x1cc>
{
rtems_status_code sc;
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
if (rtems_chain_is_empty (chain))
cb50: e5952088 ldr r2, [r5, #136] ; 0x88
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
cb54: e285308c add r3, r5, #140 ; 0x8c
cb58: e1520003 cmp r2, r3
cb5c: 1a000004 bne cb74 <rtems_bdbuf_read+0x1a0>
{
sc = rtems_event_send (bdbuf_cache.read_ahead_task,
cb60: e3a01002 mov r1, #2
cb64: ebffe8b9 bl 6e50 <rtems_event_send>
RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
if (sc != RTEMS_SUCCESSFUL)
cb68: e3500000 cmp r0, #0
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);
cb6c: 13a00007 movne r0, #7
cb70: 1bfff8d2 blne aec0 <rtems_bdbuf_fatal>
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
cb74: e5953090 ldr r3, [r5, #144] ; 0x90
the_node->next = tail;
cb78: e59f1024 ldr r1, [pc, #36] ; cba4 <rtems_bdbuf_read+0x1d0>
}
rtems_chain_append_unprotected (chain, &dd->read_ahead.node);
cb7c: e2842064 add r2, r4, #100 ; 0x64
cb80: e5841064 str r1, [r4, #100] ; 0x64
tail->previous = the_node;
cb84: e5852090 str r2, [r5, #144] ; 0x90
old_last->next = the_node;
cb88: e5832000 str r2, [r3]
the_node->previous = old_last;
cb8c: e5843068 str r3, [r4, #104] ; 0x68
}
rtems_bdbuf_check_read_ahead_trigger (dd, block);
}
rtems_bdbuf_unlock_cache ();
cb90: ebfff8e7 bl af34 <rtems_bdbuf_unlock_cache>
*bd_ptr = bd;
cb94: e5867000 str r7, [r6]
return sc;
}
cb98: e1a00008 mov r0, r8
cb9c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
0000c3d0 <rtems_bdbuf_read_ahead_task>:
return sc;
}
static rtems_task
rtems_bdbuf_read_ahead_task (rtems_task_argument arg)
{
c3d0: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
while (bdbuf_cache.read_ahead_enabled)
c3d4: e59f6110 ldr r6, [pc, #272] ; c4ec <rtems_bdbuf_read_ahead_task+0x11c>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
c3d8: e286808c add r8, r6, #140 ; 0x8c
c3dc: ea00003d b c4d8 <rtems_bdbuf_read_ahead_task+0x108>
{
rtems_chain_node *node;
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
c3e0: e3a00002 mov r0, #2
c3e4: ebfffb41 bl b0f0 <rtems_bdbuf_wait_for_event>
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
new_first->previous = head;
c3e8: e59f7100 ldr r7, [pc, #256] ; c4f0 <rtems_bdbuf_read_ahead_task+0x120>
rtems_bdbuf_lock_cache ();
c3ec: ebfffab7 bl aed0 <rtems_bdbuf_lock_cache>
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
c3f0: ea00002a b c4a0 <rtems_bdbuf_read_ahead_task+0xd0>
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
c3f4: e5140034 ldr r0, [r4, #-52] ; 0x34
c3f8: e3500000 cmp r0, #0
return block << dd->block_to_media_block_shift;
c3fc: a1a00015 lslge r0, r5, r0
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
c400: aa000006 bge c420 <rtems_bdbuf_read_ahead_task+0x50>
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
c404: e5140040 ldr r0, [r4, #-64] ; 0x40 <== NOT EXECUTED
c408: e0832590 umull r2, r3, r0, r5 <== NOT EXECUTED
c40c: e1a00002 mov r0, r2 <== NOT EXECUTED
c410: e1a01003 mov r1, r3 <== NOT EXECUTED
c414: e5142044 ldr r2, [r4, #-68] ; 0x44 <== NOT EXECUTED
c418: e3a03000 mov r3, #0 <== NOT EXECUTED
c41c: eb003d87 bl 1ba40 <__udivdi3> <== NOT EXECUTED
/*
* Compute the media block number. Drivers work with media block number not
* the block number a BD may have as this depends on the block size set by
* the user.
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
c420: e514104c ldr r1, [r4, #-76] ; 0x4c
c424: e3a03000 mov r3, #0
c428: e0801001 add r1, r0, r1
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
c42c: e3a02000 mov r2, #0
rtems_status_code sc =
rtems_bdbuf_get_media_block (dd, block, &media_block);
rtems_chain_set_off_chain (&dd->read_ahead.node);
if (sc == RTEMS_SUCCESSFUL)
c430: e1530002 cmp r3, r2
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
}
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
c434: 13e03000 mvnne r3, #0
c438: e5842004 str r2, [r4, #4]
c43c: e5842000 str r2, [r4]
c440: 15843008 strne r3, [r4, #8]
rtems_status_code sc =
rtems_bdbuf_get_media_block (dd, block, &media_block);
rtems_chain_set_off_chain (&dd->read_ahead.node);
if (sc == RTEMS_SUCCESSFUL)
c444: 1a000015 bne c4a0 <rtems_bdbuf_read_ahead_task+0xd0>
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
rtems_bdbuf_lock_cache ();
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
{
rtems_disk_device *dd = (rtems_disk_device *)
c448: e244a064 sub sl, r4, #100 ; 0x64
rtems_chain_set_off_chain (&dd->read_ahead.node);
if (sc == RTEMS_SUCCESSFUL)
{
rtems_bdbuf_buffer *bd =
c44c: e1a0000a mov r0, sl
c450: ebfffd6c bl ba08 <rtems_bdbuf_get_buffer_for_read_ahead>
rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
if (bd != NULL)
c454: e2501000 subs r1, r0, #0
c458: 0a000010 beq c4a0 <rtems_bdbuf_read_ahead_task+0xd0>
{
uint32_t transfer_count = dd->block_count - block;
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
c45c: e59f3090 ldr r3, [pc, #144] ; c4f4 <rtems_bdbuf_read_ahead_task+0x124>
rtems_bdbuf_buffer *bd =
rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
if (bd != NULL)
{
uint32_t transfer_count = dd->block_count - block;
c460: e514203c ldr r2, [r4, #-60] ; 0x3c
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
c464: e5933000 ldr r3, [r3]
rtems_bdbuf_buffer *bd =
rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
if (bd != NULL)
{
uint32_t transfer_count = dd->block_count - block;
c468: e0652002 rsb r2, r5, r2
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
if (transfer_count >= max_transfer_count)
c46c: e1520003 cmp r2, r3
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
c470: 208520a3 addcs r2, r5, r3, lsr #1
dd->read_ahead.next = block + transfer_count;
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
c474: 33e03000 mvncc r3, #0
if (transfer_count >= max_transfer_count)
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
dd->read_ahead.next = block + transfer_count;
c478: 20835005 addcs r5, r3, r5
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
if (transfer_count >= max_transfer_count)
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
c47c: 25842008 strcs r2, [r4, #8]
dd->read_ahead.next = block + transfer_count;
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
c480: 35843008 strcc r3, [r4, #8]
if (transfer_count >= max_transfer_count)
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
dd->read_ahead.next = block + transfer_count;
c484: 21a02003 movcs r2, r3
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
++dd->stats.read_ahead_transfers;
c488: e5143018 ldr r3, [r4, #-24]
c48c: e2833001 add r3, r3, #1
if (transfer_count >= max_transfer_count)
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
dd->read_ahead.next = block + transfer_count;
c490: 2584500c strcs r5, [r4, #12]
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
++dd->stats.read_ahead_transfers;
c494: e5043018 str r3, [r4, #-24]
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
c498: e1a0000a mov r0, sl
c49c: ebffff91 bl c2e8 <rtems_bdbuf_execute_read_request>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
c4a0: e5964088 ldr r4, [r6, #136] ; 0x88
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
c4a4: e1540008 cmp r4, r8
c4a8: 0a000009 beq c4d4 <rtems_bdbuf_read_ahead_task+0x104>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
c4ac: e5943000 ldr r3, [r4]
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
{
rtems_disk_device *dd = (rtems_disk_device *)
((char *) node - offsetof (rtems_disk_device, read_ahead.node));
rtems_blkdev_bnum block = dd->read_ahead.next;
c4b0: e594500c ldr r5, [r4, #12]
head->next = new_first;
c4b4: e5863088 str r3, [r6, #136] ; 0x88
new_first->previous = head;
c4b8: e5837004 str r7, [r3, #4]
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
c4bc: e514303c ldr r3, [r4, #-60] ; 0x3c
c4c0: e1550003 cmp r5, r3
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
{
rtems_disk_device *dd = (rtems_disk_device *)
((char *) node - offsetof (rtems_disk_device, read_ahead.node));
rtems_blkdev_bnum block = dd->read_ahead.next;
rtems_blkdev_bnum media_block = 0;
c4c4: 23a01000 movcs r1, #0
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
}
else
{
sc = RTEMS_INVALID_ID;
c4c8: 23a03004 movcs r3, #4
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
c4cc: 2affffd6 bcs c42c <rtems_bdbuf_read_ahead_task+0x5c>
c4d0: eaffffc7 b c3f4 <rtems_bdbuf_read_ahead_task+0x24>
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
}
rtems_bdbuf_unlock_cache ();
c4d4: ebfffa96 bl af34 <rtems_bdbuf_unlock_cache>
static rtems_task
rtems_bdbuf_read_ahead_task (rtems_task_argument arg)
{
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
while (bdbuf_cache.read_ahead_enabled)
c4d8: e5d60094 ldrb r0, [r6, #148] ; 0x94
c4dc: e3500000 cmp r0, #0
c4e0: 1affffbe bne c3e0 <rtems_bdbuf_read_ahead_task+0x10>
rtems_bdbuf_unlock_cache ();
}
rtems_task_delete (RTEMS_SELF);
}
c4e4: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
}
rtems_bdbuf_unlock_cache ();
}
rtems_task_delete (RTEMS_SELF);
c4e8: eaffec34 b 75c0 <rtems_task_delete> <== NOT EXECUTED
0000cba8 <rtems_bdbuf_release>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
cba8: e92d4010 push {r4, lr}
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (bd == NULL)
cbac: e2504000 subs r4, r0, #0
cbb0: 0a000027 beq cc54 <rtems_bdbuf_release+0xac>
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
cbb4: ebfff8c5 bl aed0 <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
cbb8: e5940020 ldr r0, [r4, #32]
cbbc: e2403003 sub r3, r0, #3
cbc0: e3530003 cmp r3, #3
cbc4: 979ff103 ldrls pc, [pc, r3, lsl #2]
cbc8: ea00001c b cc40 <rtems_bdbuf_release+0x98> <== NOT EXECUTED
cbcc: 0000cbdc .word 0x0000cbdc <== NOT EXECUTED
cbd0: 0000cc34 .word 0x0000cc34 <== NOT EXECUTED
cbd4: 0000cc28 .word 0x0000cc28 <== NOT EXECUTED
cbd8: 0000cc28 .word 0x0000cc28 <== NOT EXECUTED
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
cbdc: e5943028 ldr r3, [r4, #40] ; 0x28
cbe0: e593200c ldr r2, [r3, #12]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
cbe4: e59f0070 ldr r0, [pc, #112] ; cc5c <rtems_bdbuf_release+0xb4>
cbe8: e2422001 sub r2, r2, #1
cbec: e583200c str r2, [r3, #12]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
cbf0: e3a03002 mov r3, #2
cbf4: e5843020 str r3, [r4, #32]
cbf8: e5903048 ldr r3, [r0, #72] ; 0x48
the_node->next = tail;
cbfc: e2802044 add r2, r0, #68 ; 0x44
tail->previous = the_node;
cc00: e5804048 str r4, [r0, #72] ; 0x48
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
cc04: e5842000 str r2, [r4]
tail->previous = the_node; old_last->next = the_node; the_node->previous = old_last;
cc08: e5843004 str r3, [r4, #4]
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
old_last->next = the_node;
cc0c: e5834000 str r4, [r3]
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)
cc10: e5943024 ldr r3, [r4, #36] ; 0x24
cc14: e3530000 cmp r3, #0
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
cc18: 12800064 addne r0, r0, #100 ; 0x64
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
cc1c: 02800074 addeq r0, r0, #116 ; 0x74
cc20: ebfff976 bl b200 <rtems_bdbuf_wake>
cc24: ea000007 b cc48 <rtems_bdbuf_release+0xa0>
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);
cc28: e1a00004 mov r0, r4
cc2c: ebfffc01 bl bc38 <rtems_bdbuf_discard_buffer_after_access>
break;
cc30: ea000004 b cc48 <rtems_bdbuf_release+0xa0>
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
cc34: e1a00004 mov r0, r4
cc38: ebfff97a bl b228 <rtems_bdbuf_add_to_modified_list_after_access>
break;
cc3c: ea000001 b cc48 <rtems_bdbuf_release+0xa0>
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_0);
cc40: e3a0100e mov r1, #14 <== NOT EXECUTED
cc44: ebfff8b7 bl af28 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
cc48: ebfff8b9 bl af34 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
cc4c: e3a00000 mov r0, #0
cc50: e8bd8010 pop {r4, pc}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (bd == NULL)
return RTEMS_INVALID_ADDRESS;
cc54: e3a00009 mov r0, #9 <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
cc58: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0000cc60 <rtems_bdbuf_release_modified>:
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
cc60: e92d4010 push {r4, lr}
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (bd == NULL)
cc64: e2504000 subs r4, r0, #0
cc68: 0a000013 beq ccbc <rtems_bdbuf_release_modified+0x5c>
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
cc6c: ebfff897 bl aed0 <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
cc70: e5940020 ldr r0, [r4, #32]
cc74: e3500003 cmp r0, #3
cc78: 3a00000a bcc cca8 <rtems_bdbuf_release_modified+0x48>
cc7c: e3500005 cmp r0, #5
cc80: 9a000002 bls cc90 <rtems_bdbuf_release_modified+0x30>
cc84: e3500006 cmp r0, #6
cc88: 1a000006 bne cca8 <rtems_bdbuf_release_modified+0x48>
cc8c: ea000002 b cc9c <rtems_bdbuf_release_modified+0x3c>
{
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);
cc90: e1a00004 mov r0, r4
cc94: ebfff963 bl b228 <rtems_bdbuf_add_to_modified_list_after_access>
break;
cc98: ea000004 b ccb0 <rtems_bdbuf_release_modified+0x50>
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
cc9c: e1a00004 mov r0, r4
cca0: ebfffbe4 bl bc38 <rtems_bdbuf_discard_buffer_after_access>
break;
cca4: ea000001 b ccb0 <rtems_bdbuf_release_modified+0x50>
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_6);
cca8: e3a01012 mov r1, #18 <== NOT EXECUTED
ccac: ebfff89d bl af28 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
ccb0: ebfff89f bl af34 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
ccb4: e3a00000 mov r0, #0
ccb8: e8bd8010 pop {r4, pc}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (bd == NULL)
return RTEMS_INVALID_ADDRESS;
ccbc: e3a00009 mov r0, #9 <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
ccc0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0000b334 <rtems_bdbuf_remove_from_tree>:
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
b334: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
const rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
b338: e59f332c ldr r3, [pc, #812] ; b66c <rtems_bdbuf_remove_from_tree+0x338>
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
b33c: e24dd080 sub sp, sp, #128 ; 0x80
*/
static int
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer** root,
const rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
b340: e5907014 ldr r7, [r0, #20]
rtems_blkdev_bnum block = node->block;
b344: e5906018 ldr r6, [r0, #24]
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));
b348: e3a01000 mov r1, #0
b34c: e3a02080 mov r2, #128 ; 0x80
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
b350: 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));
b354: e1a0000d mov r0, sp
const rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
b358: e593403c ldr r4, [r3, #60] ; 0x3c
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));
b35c: eb001b35 bl 12038 <memset>
rtems_bdbuf_buffer* r; rtems_bdbuf_buffer* s; rtems_bdbuf_buffer* p1; rtems_bdbuf_buffer* p2; rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT]; rtems_bdbuf_buffer** buf_prev = buf_stack;
b360: e1a0100d mov r1, sp
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
b364: e3a02001 mov r2, #1
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
b368: e3e03000 mvn r3, #0
b36c: ea00000d b b3a8 <rtems_bdbuf_remove_from_tree+0x74>
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
b370: e594c014 ldr ip, [r4, #20]
b374: e15c0007 cmp ip, r7
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
b378: e4814004 str r4, [r1], #4
if (((uintptr_t) p->dd < (uintptr_t) dd)
b37c: 3a000003 bcc b390 <rtems_bdbuf_remove_from_tree+0x5c>
|| ((p->dd == dd) && (p->block < block)))
b380: 1a000006 bne b3a0 <rtems_bdbuf_remove_from_tree+0x6c>
b384: e594c018 ldr ip, [r4, #24]
b388: e15c0006 cmp ip, r6
b38c: 2a000002 bcs b39c <rtems_bdbuf_remove_from_tree+0x68>
{
p->avl.cache = 1;
b390: e5c42010 strb r2, [r4, #16]
p = p->avl.right;
b394: e594400c ldr r4, [r4, #12]
b398: ea000002 b b3a8 <rtems_bdbuf_remove_from_tree+0x74>
}
else if ((p->dd != dd) || (p->block != block))
b39c: 0a000005 beq b3b8 <rtems_bdbuf_remove_from_tree+0x84>
{
p->avl.cache = -1;
b3a0: e5c43010 strb r3, [r4, #16]
p = p->avl.left;
b3a4: e5944008 ldr r4, [r4, #8]
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
b3a8: e3540000 cmp r4, #0
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
p = p->avl.left;
b3ac: e1a00001 mov r0, r1
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
b3b0: 1affffee bne b370 <rtems_bdbuf_remove_from_tree+0x3c>
b3b4: ea0000a7 b b658 <rtems_bdbuf_remove_from_tree+0x324> <== NOT EXECUTED
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
b3b8: e1a0300d mov r3, sp
b3bc: e1500003 cmp r0, r3
{
p = NULL;
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
b3c0: e594300c ldr r3, [r4, #12]
q = p;
buf_prev--;
if (buf_prev > buf_stack)
{
p = *(buf_prev - 1);
b3c4: 8511c008 ldrhi ip, [r1, #-8]
}
else
{
p = NULL;
b3c8: 93a0c000 movls ip, #0
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
b3cc: e3530000 cmp r3, #0
b3d0: 1a000004 bne b3e8 <rtems_bdbuf_remove_from_tree+0xb4>
{
r = q->avl.left;
b3d4: e5943008 ldr r3, [r4, #8]
if (r != NULL)
b3d8: e3530000 cmp r3, #0
{
r->avl.bal = 0;
b3dc: 13a02000 movne r2, #0
b3e0: 15c32011 strbne r2, [r3, #17]
b3e4: ea000021 b b470 <rtems_bdbuf_remove_from_tree+0x13c>
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
b3e8: e5932008 ldr r2, [r3, #8]
b3ec: e3520000 cmp r2, #0
b3f0: 11a02003 movne r2, r3
b3f4: 11a05003 movne r5, r3
b3f8: 11a00001 movne r0, r1
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
b3fc: 13e07000 mvnne r7, #0
b400: 1a00000c bne b438 <rtems_bdbuf_remove_from_tree+0x104>
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
b404: e5942008 ldr r2, [r4, #8]
b408: e5832008 str r2, [r3, #8]
r->avl.bal = q->avl.bal;
b40c: e5d42011 ldrb r2, [r4, #17]
b410: e5c32011 strb r2, [r3, #17]
r->avl.cache = 1;
b414: e3a02001 mov r2, #1
b418: e5c32010 strb r2, [r3, #16]
*buf_prev++ = q = r;
b41c: e5013004 str r3, [r1, #-4]
b420: e1a00001 mov r0, r1
b424: ea000011 b b470 <rtems_bdbuf_remove_from_tree+0x13c>
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
b428: e4802004 str r2, [r0], #4
s = r->avl.left;
r->avl.cache = -1;
b42c: e5c27010 strb r7, [r2, #16]
b430: e1a05002 mov r5, r2
b434: e1a02006 mov r2, r6
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
b438: e5926008 ldr r6, [r2, #8]
b43c: e3560000 cmp r6, #0
b440: 1afffff8 bne b428 <rtems_bdbuf_remove_from_tree+0xf4>
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
b444: e5946008 ldr r6, [r4, #8]
b448: e5826008 str r6, [r2, #8]
r->avl.left = s->avl.right;
b44c: e592600c ldr r6, [r2, #12]
s->avl.right = q->avl.right;
b450: e582300c str r3, [r2, #12]
s->avl.bal = q->avl.bal;
b454: e5d43011 ldrb r3, [r4, #17]
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
b458: e5856008 str r6, [r5, #8]
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
b45c: e5c23011 strb r3, [r2, #17]
s->avl.cache = 1;
*t = q = s;
b460: e5012004 str r2, [r1, #-4]
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
s->avl.cache = 1;
b464: e3a03001 mov r3, #1
b468: e5c23010 strb r3, [r2, #16]
*t = q = s;
b46c: e1a03002 mov r3, r2
}
}
if (p != NULL)
b470: e35c0000 cmp ip, #0
p->avl.right = q;
}
}
else
{
*root = q;
b474: 059f21f0 ldreq r2, [pc, #496] ; b66c <rtems_bdbuf_remove_from_tree+0x338>
b478: 0582303c streq r3, [r2, #60] ; 0x3c
*t = q = s;
}
}
if (p != NULL)
b47c: 0a000003 beq b490 <rtems_bdbuf_remove_from_tree+0x15c>
{
if (p->avl.cache == -1)
b480: e1dc21d0 ldrsb r2, [ip, #16]
b484: e3720001 cmn r2, #1
{
p->avl.left = q;
}
else
{
p->avl.right = q;
b488: 158c300c strne r3, [ip, #12]
if (p != NULL)
{
if (p->avl.cache == -1)
{
p->avl.left = q;
b48c: 058c3008 streq r3, [ip, #8]
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
b490: e1a0600d mov r6, sp
b494: e1500006 cmp r0, r6
b498: 9a000071 bls b664 <rtems_bdbuf_remove_from_tree+0x330>
p->avl.right = q;
}
}
else
{
*root = q;
b49c: e1a04000 mov r4, r0
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
b4a0: e3e07000 mvn r7, #0
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
b4a4: e3a0c000 mov ip, #0
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
b4a8: e3a05001 mov r5, #1
default:
break;
}
}
if (buf_prev > buf_stack)
b4ac: e1a0600d mov r6, sp
while (modified)
{
if (buf_prev > buf_stack)
{
p = *--buf_prev;
b4b0: e5143004 ldr r3, [r4, #-4]
else
{
break;
}
if (p->avl.cache == -1)
b4b4: e1d3a1d0 ldrsb sl, [r3, #16]
b4b8: e37a0001 cmn sl, #1
b4bc: e1d321d1 ldrsb r2, [r3, #17]
b4c0: 1a00002a bne b570 <rtems_bdbuf_remove_from_tree+0x23c>
{
/* rebalance left branch */
switch (p->avl.bal)
b4c4: e3520000 cmp r2, #0
{
case -1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = 1;
b4c8: 05c35011 strbeq r5, [r3, #17]
}
if (p->avl.cache == -1)
{
/* rebalance left branch */
switch (p->avl.bal)
b4cc: 0a000052 beq b61c <rtems_bdbuf_remove_from_tree+0x2e8>
b4d0: e3520001 cmp r2, #1
b4d4: 0a000002 beq b4e4 <rtems_bdbuf_remove_from_tree+0x1b0>
b4d8: e3720001 cmn r2, #1
{
case -1:
p->avl.bal = 0;
b4dc: 05c3c011 strbeq ip, [r3, #17]
b4e0: ea00004c b b618 <rtems_bdbuf_remove_from_tree+0x2e4>
p->avl.bal = 1;
modified = false;
break;
case +1:
p1 = p->avl.right;
b4e4: e593100c ldr r1, [r3, #12]
if (p1->avl.bal >= 0) /* simple RR-turn */
b4e8: e1d101d1 ldrsb r0, [r1, #17]
b4ec: e3500000 cmp r0, #0
b4f0: e5d18011 ldrb r8, [r1, #17]
b4f4: e5910008 ldr r0, [r1, #8]
b4f8: ba000009 blt b524 <rtems_bdbuf_remove_from_tree+0x1f0>
{
p->avl.right = p1->avl.left;
p1->avl.left = p;
if (p1->avl.bal == 0)
b4fc: e3580000 cmp r8, #0
case +1:
p1 = p->avl.right;
if (p1->avl.bal >= 0) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
b500: e583000c str r0, [r3, #12]
p1->avl.left = p;
b504: e5813008 str r3, [r1, #8]
p1->avl.bal = -1;
modified = false;
}
else
{
p->avl.bal = 0;
b508: 15c3c011 strbne ip, [r3, #17]
p->avl.right = p1->avl.left;
p1->avl.left = p;
if (p1->avl.bal == 0)
{
p1->avl.bal = -1;
b50c: 05c1a011 strbeq sl, [r1, #17]
b510: 01a03001 moveq r3, r1
modified = false;
b514: 01a02008 moveq r2, r8
}
else
{
p->avl.bal = 0;
p1->avl.bal = 0;
b518: 15c1c011 strbne ip, [r1, #17]
if (p1->avl.bal >= 0) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
p1->avl.left = p;
if (p1->avl.bal == 0)
b51c: 1a000029 bne b5c8 <rtems_bdbuf_remove_from_tree+0x294>
b520: ea00003d b b61c <rtems_bdbuf_remove_from_tree+0x2e8>
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
b524: e590800c ldr r8, [r0, #12]
b528: e5818008 str r8, [r1, #8]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
b52c: e5908008 ldr r8, [r0, #8]
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
b530: e580100c str r1, [r0, #12]
p->avl.right = p2->avl.left;
b534: e583800c str r8, [r3, #12]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
b538: e1d081d1 ldrsb r8, [r0, #17]
b53c: e3580001 cmp r8, #1
b540: 03a080ff moveq r8, #255 ; 0xff
b544: 13a08000 movne r8, #0
b548: e5c38011 strb r8, [r3, #17]
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
b54c: e5803008 str r3, [r0, #8]
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;
b550: e1d031d1 ldrsb r3, [r0, #17]
b554: e3730001 cmn r3, #1
b558: 13a03000 movne r3, #0
b55c: 03a03001 moveq r3, #1
b560: e5c13011 strb r3, [r1, #17]
p = p2;
p2->avl.bal = 0;
b564: e5c0c011 strb ip, [r0, #17]
b568: e1a03000 mov r3, r0
b56c: ea00002a b b61c <rtems_bdbuf_remove_from_tree+0x2e8>
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
b570: e3520000 cmp r2, #0
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
b574: 05c37011 strbeq r7, [r3, #17]
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
b578: 0a000027 beq b61c <rtems_bdbuf_remove_from_tree+0x2e8>
b57c: e3520001 cmp r2, #1
{
case +1:
p->avl.bal = 0;
b580: 05c3c011 strbeq ip, [r3, #17]
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
b584: 0a000024 beq b61c <rtems_bdbuf_remove_from_tree+0x2e8>
b588: e3720001 cmn r2, #1
b58c: 1a000021 bne b618 <rtems_bdbuf_remove_from_tree+0x2e4>
p->avl.bal = -1;
modified = false;
break;
case -1:
p1 = p->avl.left;
b590: e5931008 ldr r1, [r3, #8]
if (p1->avl.bal <= 0) /* simple LL-turn */
b594: e1d101d1 ldrsb r0, [r1, #17]
b598: e3500000 cmp r0, #0
b59c: e5d12011 ldrb r2, [r1, #17]
b5a0: e591000c ldr r0, [r1, #12]
b5a4: ca000009 bgt b5d0 <rtems_bdbuf_remove_from_tree+0x29c>
{
p->avl.left = p1->avl.right;
p1->avl.right = p;
if (p1->avl.bal == 0)
b5a8: e3520000 cmp r2, #0
p1->avl.bal = 1;
modified = false;
}
else
{
p->avl.bal = 0;
b5ac: 15c3c011 strbne ip, [r3, #17]
case -1:
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
b5b0: e5830008 str r0, [r3, #8]
p1->avl.right = p;
b5b4: e581300c str r3, [r1, #12]
modified = false;
}
else
{
p->avl.bal = 0;
p1->avl.bal = 0;
b5b8: 15c1c011 strbne ip, [r1, #17]
b5bc: 11a03001 movne r3, r1
if (p1->avl.bal <= 0) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
p1->avl.right = p;
if (p1->avl.bal == 0)
b5c0: 1a000014 bne b618 <rtems_bdbuf_remove_from_tree+0x2e4>
{
p1->avl.bal = 1;
b5c4: e5c15011 strb r5, [r1, #17]
b5c8: e1a03001 mov r3, r1
b5cc: ea000012 b b61c <rtems_bdbuf_remove_from_tree+0x2e8>
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
b5d0: e5902008 ldr r2, [r0, #8]
b5d4: e581200c str r2, [r1, #12]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
b5d8: e590200c ldr r2, [r0, #12]
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
b5dc: e5801008 str r1, [r0, #8]
p->avl.left = p2->avl.right;
b5e0: e5832008 str r2, [r3, #8]
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
b5e4: e1d021d1 ldrsb r2, [r0, #17]
b5e8: e3720001 cmn r2, #1
b5ec: 13a02000 movne r2, #0
b5f0: 03a02001 moveq r2, #1
b5f4: e5c32011 strb r2, [r3, #17]
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
b5f8: e580300c str r3, [r0, #12]
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;
b5fc: e1d031d1 ldrsb r3, [r0, #17]
b600: e3530001 cmp r3, #1
b604: 03a030ff moveq r3, #255 ; 0xff
b608: 13a03000 movne r3, #0
b60c: e5c13011 strb r3, [r1, #17]
p = p2;
p2->avl.bal = 0;
b610: e5c0c011 strb ip, [r0, #17]
b614: e1a03000 mov r3, r0
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
b618: e3a02001 mov r2, #1
{
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
b61c: e2440004 sub r0, r4, #4
default:
break;
}
}
if (buf_prev > buf_stack)
b620: e1500006 cmp r0, r6
b624: 9a000008 bls b64c <rtems_bdbuf_remove_from_tree+0x318>
{
q = *(buf_prev - 1);
b628: e5141008 ldr r1, [r4, #-8]
if (q->avl.cache == -1)
b62c: e1d141d0 ldrsb r4, [r1, #16]
b630: e3740001 cmn r4, #1
{
q->avl.left = p;
b634: 05813008 streq r3, [r1, #8]
}
else
{
q->avl.right = p;
b638: 1581300c strne r3, [r1, #12]
*root = q;
}
modified = true;
while (modified)
b63c: e3520000 cmp r2, #0
q->avl.right = p;
}
}
else
{
*root = p;
b640: e1a04000 mov r4, r0
*root = q;
}
modified = true;
while (modified)
b644: 1affff99 bne b4b0 <rtems_bdbuf_remove_from_tree+0x17c>
b648: ea000005 b b664 <rtems_bdbuf_remove_from_tree+0x330>
q->avl.right = p;
}
}
else
{
*root = p;
b64c: e59f2018 ldr r2, [pc, #24] ; b66c <rtems_bdbuf_remove_from_tree+0x338>
b650: e582303c str r3, [r2, #60] ; 0x3c
b654: ea000002 b b664 <rtems_bdbuf_remove_from_tree+0x330>
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_TREE_RM);
b658: e5950020 ldr r0, [r5, #32] <== NOT EXECUTED
b65c: e3a0101b mov r1, #27 <== NOT EXECUTED
b660: ebfffe30 bl af28 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
}
b664: e28dd080 add sp, sp, #128 ; 0x80
b668: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
0000b670 <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)
b670: e5903020 ldr r3, [r0, #32]
b674: e3530000 cmp r3, #0
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_TREE_RM);
}
static void
rtems_bdbuf_remove_from_tree_and_lru_list (rtems_bdbuf_buffer *bd)
{
b678: e92d4010 push {r4, lr}
b67c: e1a04000 mov r4, r0
switch (bd->state)
b680: 0a000006 beq b6a0 <rtems_bdbuf_remove_from_tree_and_lru_list+0x30>
b684: e3530002 cmp r3, #2
b688: 1a000001 bne b694 <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);
b68c: ebffff28 bl b334 <rtems_bdbuf_remove_from_tree>
break;
b690: ea000002 b b6a0 <rtems_bdbuf_remove_from_tree_and_lru_list+0x30>
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_10);
b694: e1a00003 mov r0, r3 <== NOT EXECUTED
b698: e3a01016 mov r1, #22 <== NOT EXECUTED
b69c: ebfffe21 bl af28 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
b6a0: e894000c ldm r4, {r2, r3}
next->previous = previous;
b6a4: e5823004 str r3, [r2, #4]
previous->next = next;
b6a8: e5832000 str r2, [r3]
}
rtems_chain_extract_unprotected (&bd->link);
}
b6ac: e8bd8010 pop {r4, pc}
0000bf80 <rtems_bdbuf_swapout_task>:
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
bf80: 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;
bf84: e59f62b4 ldr r6, [pc, #692] ; c240 <rtems_bdbuf_swapout_task+0x2c0>
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
bf88: e24dd028 sub sp, sp, #40 ; 0x28
rtems_bdbuf_swapout_transfer transfer; uint32_t period_in_ticks; const uint32_t period_in_msecs = bdbuf_config.swapout_period;
bf8c: e596b00c ldr fp, [r6, #12]
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
bf90: ebfffc66 bl b130 <rtems_bdbuf_swapout_writereq_alloc>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
bf94: e28d300c add r3, sp, #12
head->previous = NULL; tail->previous = head;
bf98: e58d3014 str r3, [sp, #20]
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
bf9c: e59f32a0 ldr r3, [pc, #672] ; c244 <rtems_bdbuf_swapout_task+0x2c4>
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 ();
bfa0: e58d0020 str r0, [sp, #32]
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
bfa4: e3a00ffa mov r0, #1000 ; 0x3e8
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
bfa8: e28d2010 add r2, sp, #16
head->previous = NULL;
bfac: e3a04000 mov r4, #0
bfb0: e593100c ldr r1, [r3, #12]
bfb4: e000009b mul r0, fp, r0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
bfb8: e58d200c str r2, [sp, #12]
head->previous = NULL;
bfbc: e58d4010 str r4, [sp, #16]
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.dd = BDBUF_INVALID_DEV;
bfc0: e58d4018 str r4, [sp, #24]
transfer.syncing = false;
bfc4: e5cd401c strb r4, [sp, #28]
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
bfc8: eb003960 bl 1a550 <__aeabi_uidiv>
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
bfcc: e59f5274 ldr r5, [pc, #628] ; c248 <rtems_bdbuf_swapout_task+0x2c8>
bfd0: e58d0008 str r0, [sp, #8]
rtems_bdbuf_swapout_workers_open (void)
{
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
bfd4: ebfffbbd bl aed0 <rtems_bdbuf_lock_cache>
for (w = 0; w < bdbuf_config.swapout_workers; w++)
bfd8: e5968014 ldr r8, [r6, #20]
bfdc: ea000023 b c070 <rtems_bdbuf_swapout_task+0xf0>
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
bfe0: e3a00028 mov r0, #40 ; 0x28 <== NOT EXECUTED
bfe4: ebffde3f bl 38e8 <malloc> <== NOT EXECUTED
if (!worker)
bfe8: e2507000 subs r7, r0, #0 <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);
bfec: 03a0000a moveq r0, #10 <== NOT EXECUTED
bff0: 0a00001c beq c068 <rtems_bdbuf_swapout_task+0xe8> <== NOT EXECUTED
bff4: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
the_node->next = tail;
bff8: e59f224c ldr r2, [pc, #588] ; c24c <rtems_bdbuf_swapout_task+0x2cc><== NOT EXECUTED
tail->previous = the_node; old_last->next = the_node; the_node->previous = old_last;
bffc: e5873004 str r3, [r7, #4] <== NOT EXECUTED
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
c000: e5872000 str r2, [r7] <== NOT EXECUTED
tail->previous = the_node; old_last->next = the_node;
c004: e5837000 str r7, [r3] <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
c008: e3a03001 mov r3, #1 <== NOT EXECUTED
c00c: e5c7300c strb r3, [r7, #12] <== NOT EXECUTED
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
c010: e5857010 str r7, [r5, #16] <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
c014: ebfffc45 bl b130 <rtems_bdbuf_swapout_writereq_alloc> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
c018: e2873014 add r3, r7, #20 <== NOT EXECUTED
c01c: e5870024 str r0, [r7, #36] ; 0x24 <== NOT EXECUTED
head->next = tail;
c020: e5873010 str r3, [r7, #16] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
c024: e2872010 add r2, r7, #16 <== NOT EXECUTED
head->next = tail;
head->previous = NULL;
c028: e3a03000 mov r3, #0 <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
c02c: e59f021c ldr r0, [pc, #540] ; c250 <rtems_bdbuf_swapout_task+0x2d0><== NOT EXECUTED
c030: e5873014 str r3, [r7, #20] <== NOT EXECUTED
tail->previous = head;
c034: e5872018 str r2, [r7, #24] <== NOT EXECUTED
rtems_chain_append_unprotected (&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.dd = BDBUF_INVALID_DEV;
c038: e587301c str r3, [r7, #28] <== NOT EXECUTED
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
c03c: e2872008 add r2, r7, #8 <== NOT EXECUTED
* @param arg A pointer to the global cache data. Use the global variable and * not this. * @return rtems_task Not used. */ static rtems_task rtems_bdbuf_swapout_task (rtems_task_argument arg)
c040: e2843061 add r3, r4, #97 ; 0x61 <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
c044: e58d2000 str r2, [sp] <== NOT EXECUTED
c048: e1830000 orr r0, r3, r0 <== NOT EXECUTED
c04c: e5961018 ldr r1, [r6, #24] <== NOT EXECUTED
c050: e59f21fc ldr r2, [pc, #508] ; c254 <rtems_bdbuf_swapout_task+0x2d4><== NOT EXECUTED
c054: e1a03007 mov r3, r7 <== NOT EXECUTED
c058: ebfffc9c bl b2d0 <rtems_bdbuf_create_task.constprop.10> <== NOT EXECUTED
bdbuf_config.swapout_worker_priority,
RTEMS_BDBUF_SWAPOUT_WORKER_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
c05c: e3500000 cmp r0, #0 <== NOT EXECUTED
c060: 0a000001 beq c06c <rtems_bdbuf_swapout_task+0xec> <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);
c064: e3a0000d mov r0, #13 <== NOT EXECUTED
c068: ebfffb94 bl aec0 <rtems_bdbuf_fatal> <== NOT EXECUTED
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
c06c: e2844001 add r4, r4, #1 <== NOT EXECUTED
c070: e1540008 cmp r4, r8
c074: 3affffd9 bcc bfe0 <rtems_bdbuf_swapout_task+0x60>
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
c078: e59f51c8 ldr r5, [pc, #456] ; c248 <rtems_bdbuf_swapout_task+0x2c8>
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);
}
rtems_bdbuf_unlock_cache ();
c07c: ebfffbac bl af34 <rtems_bdbuf_unlock_cache>
* here. We do not know the worker is the last in a sequence of sync writes * until after we have it running so we do not know to tell it to release the * lock. The simplest solution is to get the main swap out task perform all * sync operations. */ if (bdbuf_cache.sync_active)
c080: e1a0a005 mov sl, r5
c084: ea000056 b c1e4 <rtems_bdbuf_swapout_task+0x264>
}
transfered_buffers = true;
}
if (bdbuf_cache.sync_active && !transfered_buffers)
c088: e3a08000 mov r8, #0
c08c: ea000000 b c094 <rtems_bdbuf_swapout_task+0x114>
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
c090: e3a08001 mov r8, #1
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
c094: ebfffb8d bl aed0 <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)
c098: e5d53030 ldrb r3, [r5, #48] ; 0x30
c09c: e3530000 cmp r3, #0
worker = NULL;
c0a0: 13a07000 movne r7, #0
* 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)
c0a4: 1a00000a bne c0d4 <rtems_bdbuf_swapout_task+0x154>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
c0a8: e5957008 ldr r7, [r5, #8]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
c0ac: e59f1198 ldr r1, [pc, #408] ; c24c <rtems_bdbuf_swapout_task+0x2cc>
c0b0: e1570001 cmp r7, r1
c0b4: 0a000005 beq c0d0 <rtems_bdbuf_swapout_task+0x150>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
c0b8: e1a04007 mov r4, r7 <== NOT EXECUTED
c0bc: e4942010 ldr r2, [r4], #16 <== NOT EXECUTED
head->next = new_first;
new_first->previous = head;
c0c0: e2411004 sub r1, r1, #4 <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
c0c4: e5852008 str r2, [r5, #8] <== NOT EXECUTED
new_first->previous = head;
c0c8: e5821004 str r1, [r2, #4] <== NOT EXECUTED
c0cc: ea000001 b c0d8 <rtems_bdbuf_swapout_task+0x158> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
c0d0: e1a07003 mov r7, r3
/*
* 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,
c0d4: e28d400c add r4, sp, #12
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
c0d8: e2842004 add r2, r4, #4
head->next = tail;
c0dc: e5842000 str r2, [r4]
head->previous = NULL;
c0e0: e3a02000 mov r2, #0
/* * 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)
c0e4: e1530002 cmp r3, r2
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
transfer->syncing = bdbuf_cache.sync_active;
c0e8: e5c43010 strb 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->dd = bdbuf_cache.sync_device;
c0ec: 15953038 ldrne r3, [r5, #56] ; 0x38
/*
* 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->dd,
c0f0: e284600c add r6, r4, #12
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
c0f4: e584200c str r2, [r4, #12]
tail->previous = head;
c0f8: e9840014 stmib r4, {r2, r4}
* 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->dd = bdbuf_cache.sync_device;
c0fc: 1584300c strne r3, [r4, #12]
/*
* 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->dd,
c100: e1a00006 mov r0, r6
c104: e59f114c ldr r1, [pc, #332] ; c258 <rtems_bdbuf_swapout_task+0x2d8>
c108: e1a02004 mov r2, r4
c10c: e3a03001 mov r3, #1
c110: e3a09000 mov r9, #0
c114: e88d0a00 stm sp, {r9, fp}
c118: ebfffb12 bl ad68 <rtems_bdbuf_swapout_modified_processing>
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
c11c: e5d53030 ldrb r3, [r5, #48] ; 0x30
c120: e1a02004 mov r2, r4
c124: e1a00006 mov r0, r6
c128: e59f112c ldr r1, [pc, #300] ; c25c <rtems_bdbuf_swapout_task+0x2dc>
c12c: e88d0900 stm sp, {r8, fp}
c130: ebfffb0c bl ad68 <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 ();
c134: ebfffb7e bl af34 <rtems_bdbuf_unlock_cache>
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
c138: e5942000 ldr r2, [r4]
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
c13c: e2843004 add r3, r4, #4
c140: e1520003 cmp r2, r3
c144: 0a00000b beq c178 <rtems_bdbuf_swapout_task+0x1f8>
{
if (worker)
c148: e1570009 cmp r7, r9
c14c: 0a000006 beq c16c <rtems_bdbuf_swapout_task+0x1ec>
{
rtems_status_code sc = rtems_event_send (worker->id,
c150: e5970008 ldr r0, [r7, #8] <== NOT EXECUTED
c154: e3a01004 mov r1, #4 <== NOT EXECUTED
c158: ebffeb3c bl 6e50 <rtems_event_send> <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
c15c: e1500009 cmp r0, r9 <== NOT EXECUTED
c160: 0a000003 beq c174 <rtems_bdbuf_swapout_task+0x1f4> <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_2);
c164: e3a0000c mov r0, #12 <== NOT EXECUTED
c168: eaffffbe b c068 <rtems_bdbuf_swapout_task+0xe8> <== NOT EXECUTED
}
else
{
rtems_bdbuf_swapout_write (transfer);
c16c: e1a00004 mov r0, r4
c170: ebffff2a bl be20 <rtems_bdbuf_swapout_write>
}
transfered_buffers = true;
c174: e3a09001 mov r9, #1
}
if (bdbuf_cache.sync_active && !transfered_buffers)
c178: e5d58030 ldrb r8, [r5, #48] ; 0x30
c17c: e3580000 cmp r8, #0
c180: 0a00000c beq c1b8 <rtems_bdbuf_swapout_task+0x238>
c184: e3590000 cmp r9, #0
c188: 1affffbe bne c088 <rtems_bdbuf_swapout_task+0x108>
{
rtems_id sync_requester;
rtems_bdbuf_lock_cache ();
c18c: ebfffb4f bl aed0 <rtems_bdbuf_lock_cache>
sync_requester = bdbuf_cache.sync_requester;
c190: e59a4034 ldr r4, [sl, #52] ; 0x34
bdbuf_cache.sync_active = false;
c194: e5ca9030 strb r9, [sl, #48] ; 0x30
bdbuf_cache.sync_requester = 0;
c198: e58a9034 str r9, [sl, #52] ; 0x34
rtems_bdbuf_unlock_cache ();
c19c: ebfffb64 bl af34 <rtems_bdbuf_unlock_cache>
if (sync_requester)
c1a0: e3540000 cmp r4, #0
c1a4: 0a000005 beq c1c0 <rtems_bdbuf_swapout_task+0x240>
c1a8: e1a00004 mov r0, r4
c1ac: e3a01102 mov r1, #-2147483648 ; 0x80000000
c1b0: ebffec9c bl 7428 <rtems_event_system_send>
c1b4: ea000001 b c1c0 <rtems_bdbuf_swapout_task+0x240>
/*
* 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,
c1b8: e3590000 cmp r9, #0
c1bc: 1affffb4 bne c094 <rtems_bdbuf_swapout_task+0x114>
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
c1c0: e3a00004 mov r0, #4
c1c4: e3a01000 mov r1, #0
c1c8: e59d2008 ldr r2, [sp, #8]
c1cc: e28d3024 add r3, sp, #36 ; 0x24
c1d0: ebffeabf bl 6cd4 <rtems_event_receive>
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
c1d4: e3500006 cmp r0, #6
c1d8: 13500000 cmpne r0, #0
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);
c1dc: 13a00018 movne r0, #24
c1e0: 1affffa0 bne c068 <rtems_bdbuf_swapout_task+0xe8>
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
c1e4: e5d57004 ldrb r7, [r5, #4]
c1e8: e3570000 cmp r7, #0
c1ec: e59f6054 ldr r6, [pc, #84] ; c248 <rtems_bdbuf_swapout_task+0x2c8>
c1f0: 1affffa6 bne c090 <rtems_bdbuf_swapout_task+0x110>
static void
rtems_bdbuf_swapout_workers_close (void)
{
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
c1f4: ebfffb35 bl aed0 <rtems_bdbuf_lock_cache> <== 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;
c1f8: e1a05007 mov r5, r7 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
c1fc: e5964008 ldr r4, [r6, #8] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
c200: e286600c add r6, r6, #12 <== NOT EXECUTED
c204: ea000004 b c21c <rtems_bdbuf_swapout_task+0x29c> <== NOT EXECUTED
c208: e5c4500c strb r5, [r4, #12] <== NOT EXECUTED
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
c20c: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
c210: e3a01004 mov r1, #4 <== NOT EXECUTED
c214: ebffeb0d bl 6e50 <rtems_event_send> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
c218: e5944000 ldr r4, [r4] <== NOT EXECUTED
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
c21c: e1540006 cmp r4, r6 <== NOT EXECUTED
c220: 1afffff8 bne c208 <rtems_bdbuf_swapout_task+0x288> <== NOT EXECUTED
worker->enabled = false;
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
node = rtems_chain_next (node);
}
rtems_bdbuf_unlock_cache ();
c224: ebfffb42 bl af34 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);
}
rtems_bdbuf_swapout_workers_close ();
free (transfer.write_req);
c228: e59d0020 ldr r0, [sp, #32] <== NOT EXECUTED
c22c: ebffdc7f bl 3430 <free> <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
c230: e3a00000 mov r0, #0 <== NOT EXECUTED
c234: ebffece1 bl 75c0 <rtems_task_delete> <== NOT EXECUTED
}
c238: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
c23c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0000c260 <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)
{
c260: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
c264: e59f5078 ldr r5, [pc, #120] ; c2e4 <rtems_bdbuf_swapout_worker_task+0x84><== NOT EXECUTED
c268: e1a04000 mov r4, r0 <== NOT EXECUTED
while (worker->enabled)
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
rtems_bdbuf_swapout_write (&worker->transfer);
c26c: e2807010 add r7, r0, #16 <== NOT EXECUTED
the_node->next = tail;
c270: e285800c add r8, r5, #12 <== 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)
c274: ea000010 b c2bc <rtems_bdbuf_swapout_worker_task+0x5c> <== NOT EXECUTED
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
c278: e3a00004 mov r0, #4 <== NOT EXECUTED
c27c: ebfffb9b bl b0f0 <rtems_bdbuf_wait_for_event> <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
c280: e1a00007 mov r0, r7 <== NOT EXECUTED
c284: ebfffee5 bl be20 <rtems_bdbuf_swapout_write> <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
c288: ebfffb10 bl aed0 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
c28c: e2843014 add r3, r4, #20 <== NOT EXECUTED
head->next = tail;
c290: e5843010 str r3, [r4, #16] <== NOT EXECUTED
head->previous = NULL;
c294: e3a03000 mov r3, #0 <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
c298: e584301c str r3, [r4, #28] <== NOT EXECUTED
c29c: e5843014 str r3, [r4, #20] <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
c2a0: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
the_node->next = tail;
c2a4: e5848000 str r8, [r4] <== NOT EXECUTED
tail->previous = the_node;
c2a8: e5854010 str r4, [r5, #16] <== NOT EXECUTED
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
tail->previous = head;
c2ac: e5847018 str r7, [r4, #24] <== NOT EXECUTED
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
old_last->next = the_node;
c2b0: e5834000 str r4, [r3] <== NOT EXECUTED
the_node->previous = old_last;
c2b4: e5843004 str r3, [r4, #4] <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
c2b8: ebfffb1d bl af34 <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)
c2bc: e5d4600c ldrb r6, [r4, #12] <== NOT EXECUTED
c2c0: e3560000 cmp r6, #0 <== NOT EXECUTED
c2c4: 1affffeb bne c278 <rtems_bdbuf_swapout_worker_task+0x18> <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
}
free (worker->transfer.write_req);
c2c8: e5940024 ldr r0, [r4, #36] ; 0x24 <== NOT EXECUTED
c2cc: ebffdc57 bl 3430 <free> <== NOT EXECUTED
free (worker);
c2d0: e1a00004 mov r0, r4 <== NOT EXECUTED
c2d4: ebffdc55 bl 3430 <free> <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
c2d8: e1a00006 mov r0, r6 <== NOT EXECUTED
}
c2dc: e8bd41f0 pop {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
}
free (worker->transfer.write_req);
free (worker);
rtems_task_delete (RTEMS_SELF);
c2e0: eaffecb6 b 75c0 <rtems_task_delete> <== NOT EXECUTED
0000be20 <rtems_bdbuf_swapout_write>:
printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dd->dev);
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
be20: e5903000 ldr r3, [r0]
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
be24: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
be28: e2807004 add r7, r0, #4
printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dd->dev);
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
be2c: e1530007 cmp r3, r7
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
be30: e1a04000 mov r4, r0
printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dd->dev);
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
be34: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* The last block number used when the driver only supports
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
be38: e590500c ldr r5, [r0, #12]
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
be3c: e5953008 ldr r3, [r5, #8]
be40: e593900c ldr r9, [r3, #12]
* 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;
be44: e5903014 ldr r3, [r0, #20]
transfer->write_req->bufnum = 0;
be48: e3a06000 mov r6, #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;
be4c: e3a0200c mov r2, #12
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
be50: e595a02c ldr sl, [r5, #44] ; 0x2c
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
be54: e2099001 and r9, r9, #1
* 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;
be58: e583200c str r2, [r3, #12]
transfer->write_req->bufnum = 0;
be5c: e5836010 str r6, [r3, #16]
while ((node = rtems_chain_get_unprotected(&transfer->bds)) != NULL)
{
rtems_bdbuf_buffer* bd = (rtems_bdbuf_buffer*) node;
bool write = false;
be60: e1a0b006 mov fp, r6
* 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))
be64: e59f8110 ldr r8, [pc, #272] ; bf7c <rtems_bdbuf_swapout_write+0x15c>
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get_unprotected(&transfer->bds)) != NULL)
be68: ea00002e b bf28 <rtems_bdbuf_swapout_write+0x108>
if (rtems_bdbuf_tracer)
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
need_continuous_blocks ? "MULTI" : "SCAT");
if (need_continuous_blocks && transfer->write_req->bufnum &&
be6c: e5941014 ldr r1, [r4, #20]
be70: e5911010 ldr r1, [r1, #16]
be74: e3510000 cmp r1, #0
be78: 0a000009 beq bea4 <rtems_bdbuf_swapout_write+0x84>
be7c: e5930018 ldr r0, [r3, #24]
bd->block != last_block + media_blocks_per_block)
be80: e086100a add r1, r6, sl
if (rtems_bdbuf_tracer)
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
need_continuous_blocks ? "MULTI" : "SCAT");
if (need_continuous_blocks && transfer->write_req->bufnum &&
be84: e1500001 cmp r0, r1
be88: 0a000005 beq bea4 <rtems_bdbuf_swapout_write+0x84>
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
be8c: e5834004 str r4, [r3, #4]
before_node = after_node->next; after_node->next = the_node;
be90: e5843000 str r3, [r4]
the_node->next = before_node; before_node->previous = the_node;
be94: e5823004 str r3, [r2, #4]
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
be98: e5832000 str r2, [r3]
bd->block != last_block + media_blocks_per_block)
{
rtems_chain_prepend_unprotected (&transfer->bds, &bd->link);
write = true;
be9c: e3a03001 mov r3, #1
bea0: ea00000e b bee0 <rtems_bdbuf_swapout_write+0xc0>
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
bea4: e5942014 ldr r2, [r4, #20]
bea8: e592c010 ldr ip, [r2, #16]
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
beac: e5936018 ldr r6, [r3, #24]
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
beb0: e1a0020c lsl r0, ip, #4
beb4: e2800018 add r0, r0, #24
transfer->write_req->bufnum++;
beb8: e28cc001 add ip, ip, #1
bebc: e582c010 str ip, [r2, #16]
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
bec0: e0821000 add r1, r2, r0
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
bec4: e7826000 str r6, [r2, r0]
buf->length = dd->block_size;
bec8: e5952024 ldr r2, [r5, #36] ; 0x24
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
becc: e581300c str r3, [r1, #12]
buf->block = bd->block;
buf->length = dd->block_size;
buf->buffer = bd->buffer;
bed0: e593301c ldr r3, [r3, #28]
rtems_blkdev_sg_buffer* buf;
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;
bed4: e5812004 str r2, [r1, #4]
buf->buffer = bd->buffer;
bed8: e5813008 str r3, [r1, #8]
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get_unprotected(&transfer->bds)) != NULL)
{
rtems_bdbuf_buffer* bd = (rtems_bdbuf_buffer*) node;
bool write = false;
bedc: 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) ||
bee0: e5942000 ldr r2, [r4]
bee4: e1520007 cmp r2, r7
bee8: 0a000006 beq bf08 <rtems_bdbuf_swapout_write+0xe8>
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
beec: e5942014 ldr r2, [r4, #20]
/*
* 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) ||
bef0: e5921010 ldr r1, [r2, #16]
bef4: e5982004 ldr r2, [r8, #4]
bef8: e1510002 cmp r1, r2
befc: 2a000001 bcs bf08 <rtems_bdbuf_swapout_write+0xe8>
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
bf00: e3530000 cmp r3, #0
bf04: 0a000007 beq bf28 <rtems_bdbuf_swapout_write+0x108>
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
bf08: e3a02000 mov r2, #0
bf0c: e1a00005 mov r0, r5
bf10: e5941014 ldr r1, [r4, #20]
bf14: ebffff5d bl bc90 <rtems_bdbuf_execute_transfer_request>
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
bf18: e5943014 ldr r3, [r4, #20]
bf1c: e3a0200c mov r2, #12
bf20: e583200c str r2, [r3, #12]
transfer->write_req->bufnum = 0;
bf24: e583b010 str fp, [r3, #16]
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
bf28: e5943000 ldr r3, [r4]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
bf2c: e1530007 cmp r3, r7
bf30: 0a000005 beq bf4c <rtems_bdbuf_swapout_write+0x12c>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
bf34: e5932000 ldr r2, [r3]
if (rtems_bdbuf_tracer)
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
need_continuous_blocks ? "MULTI" : "SCAT");
if (need_continuous_blocks && transfer->write_req->bufnum &&
bf38: e3590000 cmp r9, #0
head->next = new_first;
bf3c: e5842000 str r2, [r4]
new_first->previous = head;
bf40: e5824004 str r4, [r2, #4]
bf44: 1affffc8 bne be6c <rtems_bdbuf_swapout_write+0x4c>
bf48: eaffffd5 b bea4 <rtems_bdbuf_swapout_write+0x84>
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
bf4c: e5d43010 ldrb r3, [r4, #16]
bf50: e3530000 cmp r3, #0
bf54: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
bf58: e5950008 ldr r0, [r5, #8]
bf5c: e590300c ldr r3, [r0, #12]
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
bf60: e3130002 tst r3, #2
bf64: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
bf68: e3a01002 mov r1, #2 <== NOT EXECUTED
bf6c: e3a02000 mov r2, #0 <== NOT EXECUTED
bf70: e1a0e00f mov lr, pc <== NOT EXECUTED
bf74: e595f038 ldr pc, [r5, #56] ; 0x38 <== NOT EXECUTED
bf78: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0000ccc4 <rtems_bdbuf_sync>:
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
ccc4: e92d4010 push {r4, lr}
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (bd == NULL)
ccc8: e2504000 subs r4, r0, #0
cccc: 0a000041 beq cdd8 <rtems_bdbuf_sync+0x114>
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
ccd0: ebfff87e bl aed0 <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
ccd4: e5940020 ldr r0, [r4, #32]
ccd8: e3500003 cmp r0, #3
ccdc: 3a000038 bcc cdc4 <rtems_bdbuf_sync+0x100>
cce0: e3500005 cmp r0, #5
cce4: 9a000002 bls ccf4 <rtems_bdbuf_sync+0x30>
cce8: e3500006 cmp r0, #6
ccec: 1a000034 bne cdc4 <rtems_bdbuf_sync+0x100>
ccf0: ea000030 b cdb8 <rtems_bdbuf_sync+0xf4>
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
ccf4: e59f00e4 ldr r0, [pc, #228] ; cde0 <rtems_bdbuf_sync+0x11c>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ccf8: e3a03008 mov r3, #8
ccfc: e5843020 str r3, [r4, #32]
cd00: e5903060 ldr r3, [r0, #96] ; 0x60
the_node->next = tail;
cd04: e280205c add r2, r0, #92 ; 0x5c
cd08: e5842000 str r2, [r4]
tail->previous = the_node;
cd0c: e5804060 str r4, [r0, #96] ; 0x60
old_last->next = the_node;
cd10: e5834000 str r4, [r3]
the_node->previous = old_last;
cd14: e5843004 str r3, [r4, #4]
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
cd18: e5943024 ldr r3, [r4, #36] ; 0x24
cd1c: e3530000 cmp r3, #0
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
cd20: 12800064 addne r0, r0, #100 ; 0x64
cd24: 1bfff935 blne b200 <rtems_bdbuf_wake>
rtems_bdbuf_wake_swapper ();
cd28: ebfff893 bl af7c <rtems_bdbuf_wake_swapper>
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
cd2c: e5940020 ldr r0, [r4, #32]
cd30: e2403001 sub r3, r0, #1
cd34: e3530009 cmp r3, #9
cd38: 979ff103 ldrls pc, [pc, r3, lsl #2]
cd3c: ea00000d b cd78 <rtems_bdbuf_sync+0xb4> <== NOT EXECUTED
cd40: 0000cd80 .word 0x0000cd80 <== NOT EXECUTED
cd44: 0000cd80 .word 0x0000cd80 <== NOT EXECUTED
cd48: 0000cd80 .word 0x0000cd80 <== NOT EXECUTED
cd4c: 0000cd80 .word 0x0000cd80 <== NOT EXECUTED
cd50: 0000cd80 .word 0x0000cd80 <== NOT EXECUTED
cd54: 0000cd80 .word 0x0000cd80 <== NOT EXECUTED
cd58: 0000cd80 .word 0x0000cd80 <== NOT EXECUTED
cd5c: 0000cd68 .word 0x0000cd68 <== NOT EXECUTED
cd60: 0000cd68 .word 0x0000cd68 <== NOT EXECUTED
cd64: 0000cd68 .word 0x0000cd68 <== 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);
cd68: e1a00004 mov r0, r4
cd6c: e59f1070 ldr r1, [pc, #112] ; cde4 <rtems_bdbuf_sync+0x120>
cd70: ebfff8c7 bl b094 <rtems_bdbuf_wait>
cd74: eaffffec b cd2c <rtems_bdbuf_sync+0x68>
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_9);
cd78: e3a01015 mov r1, #21 <== NOT EXECUTED
cd7c: ea000011 b cdc8 <rtems_bdbuf_sync+0x104> <== NOT EXECUTED
rtems_bdbuf_wait_for_sync_done (bd);
/*
* We may have created a cached or empty buffer which may be recycled.
*/
if (bd->waiters == 0
cd80: e5942024 ldr r2, [r4, #36] ; 0x24
cd84: e3520000 cmp r2, #0
cd88: 1a00000f bne cdcc <rtems_bdbuf_sync+0x108>
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
cd8c: e3530001 cmp r3, #1
cd90: 8a00000d bhi cdcc <rtems_bdbuf_sync+0x108>
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
cd94: e3500001 cmp r0, #1
cd98: 1a000003 bne cdac <rtems_bdbuf_sync+0xe8>
{
rtems_bdbuf_remove_from_tree (bd);
cd9c: e1a00004 mov r0, r4
cda0: ebfff963 bl b334 <rtems_bdbuf_remove_from_tree>
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
cda4: e1a00004 mov r0, r4
cda8: ebfff7e3 bl ad3c <rtems_bdbuf_make_free_and_add_to_lru_list>
}
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
cdac: e59f0034 ldr r0, [pc, #52] ; cde8 <rtems_bdbuf_sync+0x124>
cdb0: ebfff912 bl b200 <rtems_bdbuf_wake>
cdb4: ea000004 b cdcc <rtems_bdbuf_sync+0x108>
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);
cdb8: e1a00004 mov r0, r4
cdbc: ebfffb9d bl bc38 <rtems_bdbuf_discard_buffer_after_access>
break;
cdc0: ea000001 b cdcc <rtems_bdbuf_sync+0x108>
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_5);
cdc4: e3a01011 mov r1, #17 <== NOT EXECUTED
cdc8: ebfff856 bl af28 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
cdcc: ebfff858 bl af34 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
cdd0: e3a00000 mov r0, #0
cdd4: e8bd8010 pop {r4, pc}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (bd == NULL)
return RTEMS_INVALID_ADDRESS;
cdd8: e3a00009 mov r0, #9 <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
cddc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0000af34 <rtems_bdbuf_unlock_cache>:
* Unlock the cache.
*/
static void
rtems_bdbuf_unlock_cache (void)
{
rtems_bdbuf_unlock (bdbuf_cache.lock, RTEMS_BDBUF_FATAL_CACHE_UNLOCK);
af34: e59f3018 ldr r3, [pc, #24] ; af54 <rtems_bdbuf_unlock_cache+0x20>
/**
* Unlock the cache.
*/
static void
rtems_bdbuf_unlock_cache (void)
{
af38: 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);
af3c: e5930028 ldr r0, [r3, #40] ; 0x28
af40: ebfff112 bl 7390 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
af44: e3500000 cmp r0, #0
af48: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_bdbuf_fatal (fatal_error_code);
af4c: e3a00001 mov r0, #1 <== NOT EXECUTED
af50: ebffffda bl aec0 <rtems_bdbuf_fatal> <== NOT EXECUTED
0000af58 <rtems_bdbuf_unlock_sync>:
* Unlock the cache's sync lock. Any blocked writers are woken.
*/
static void
rtems_bdbuf_unlock_sync (void)
{
rtems_bdbuf_unlock (bdbuf_cache.sync_lock,
af58: e59f3018 ldr r3, [pc, #24] ; af78 <rtems_bdbuf_unlock_sync+0x20>
/**
* Unlock the cache's sync lock. Any blocked writers are woken.
*/
static void
rtems_bdbuf_unlock_sync (void)
{
af5c: 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);
af60: e593002c ldr r0, [r3, #44] ; 0x2c
af64: ebfff109 bl 7390 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
af68: e3500000 cmp r0, #0
af6c: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_bdbuf_fatal (fatal_error_code);
af70: e3a0001a mov r0, #26 <== NOT EXECUTED
af74: ebffffd1 bl aec0 <rtems_bdbuf_fatal> <== NOT EXECUTED
0000b0f0 <rtems_bdbuf_wait_for_event>:
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
b0f0: e92d4011 push {r0, r4, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_event_set out = 0;
b0f4: e3a01000 mov r1, #0
b0f8: e28d3004 add r3, sp, #4
b0fc: e5231004 str r1, [r3, #-4]!
sc = rtems_event_receive (event,
b100: e1a02001 mov r2, r1
b104: e1a0300d mov r3, sp
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
b108: e1a04000 mov r4, r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
sc = rtems_event_receive (event,
b10c: ebffeef0 bl 6cd4 <rtems_event_receive>
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
b110: e3500000 cmp r0, #0
b114: 1a000002 bne b124 <rtems_bdbuf_wait_for_event+0x34>
b118: e59d3000 ldr r3, [sp]
b11c: e1530004 cmp r3, r4
b120: 0a000001 beq b12c <rtems_bdbuf_wait_for_event+0x3c>
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);
b124: e3a0001c mov r0, #28 <== NOT EXECUTED
b128: ebffff64 bl aec0 <rtems_bdbuf_fatal> <== NOT EXECUTED
}
b12c: e8bd8018 pop {r3, r4, pc}
0000b200 <rtems_bdbuf_wake>:
static void
rtems_bdbuf_wake (const rtems_bdbuf_waiters *waiters)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
b200: e5903000 ldr r3, [r0]
b204: 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)
{
b208: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
b20c: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
{
sc = rtems_semaphore_flush (waiters->sema);
b210: e5900004 ldr r0, [r0, #4]
b214: eb000f4f bl ef58 <rtems_semaphore_flush>
if (sc != RTEMS_SUCCESSFUL)
b218: e3500000 cmp r0, #0
b21c: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAKE);
b220: e3a00004 mov r0, #4 <== NOT EXECUTED
b224: ebffff25 bl aec0 <rtems_bdbuf_fatal> <== NOT EXECUTED
0000af7c <rtems_bdbuf_wake_swapper>:
}
static void
rtems_bdbuf_wake_swapper (void)
{
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
af7c: e59f301c ldr r3, [pc, #28] ; afa0 <rtems_bdbuf_wake_swapper+0x24>
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
af80: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
af84: e5930000 ldr r0, [r3]
af88: e3a01004 mov r1, #4
af8c: ebffefaf bl 6e50 <rtems_event_send>
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
af90: e3500000 cmp r0, #0
af94: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_1);
af98: e3a0000b mov r0, #11 <== NOT EXECUTED
af9c: ebffffc7 bl aec0 <rtems_bdbuf_fatal> <== NOT EXECUTED
00001cb4 <rtems_bdpart_create>:
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
1cb4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
1cb8: e2516000 subs r6, r1, #0
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
1cbc: e24dd014 sub sp, sp, #20
1cc0: e58d2004 str r2, [sp, #4]
1cc4: e1a08003 mov r8, r3
1cc8: e59d4038 ldr r4, [sp, #56] ; 0x38
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
1ccc: 01a0a006 moveq sl, r6
1cd0: 0a000003 beq 1ce4 <rtems_bdpart_create+0x30>
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
1cd4: e5963000 ldr r3, [r6]
1cd8: e3530000 cmp r3, #0
&& format->mbr.dos_compatibility;
1cdc: 05d6a008 ldrbeq sl, [r6, #8]
1ce0: 13a0a000 movne sl, #0
rtems_blkdev_bnum disk_end = 0;
1ce4: e3a03000 mov r3, #0
rtems_blkdev_bnum pos = 0; rtems_blkdev_bnum dist_sum = 0; rtems_blkdev_bnum record_space =
1ce8: e21aa0ff ands sl, sl, #255 ; 0xff
1cec: 03a05001 moveq r5, #1
1cf0: 13a0503f movne r5, #63 ; 0x3f
rtems_blkdev_bnum overhead = 0;
rtems_blkdev_bnum free_space = 0;
size_t i = 0;
/* Check if we have something to do */
if (count == 0) {
1cf4: e1540003 cmp r4, r3
{
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;
1cf8: e58d3010 str r3, [sp, #16]
size_t i = 0;
/* Check if we have something to do */
if (count == 0) {
/* Nothing to do */
return RTEMS_SUCCESSFUL;
1cfc: 01a07004 moveq r7, r4
rtems_blkdev_bnum overhead = 0;
rtems_blkdev_bnum free_space = 0;
size_t i = 0;
/* Check if we have something to do */
if (count == 0) {
1d00: 0a000062 beq 1e90 <rtems_bdpart_create+0x1dc>
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL || dist == NULL) {
1d04: e59d2004 ldr r2, [sp, #4]
1d08: e1560003 cmp r6, r3
1d0c: 11520003 cmpne r2, r3
1d10: 13a01000 movne r1, #0
1d14: 03a01001 moveq r1, #1
1d18: 0a000059 beq 1e84 <rtems_bdpart_create+0x1d0>
1d1c: e1580003 cmp r8, r3
1d20: 0a000057 beq 1e84 <rtems_bdpart_create+0x1d0>
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, NULL, NULL, &disk_end);
1d24: e1a02001 mov r2, r1
1d28: e28d3010 add r3, sp, #16
1d2c: eb000107 bl 2150 <rtems_bdpart_get_disk_data>
if (sc != RTEMS_SUCCESSFUL) {
1d30: e2507000 subs r7, r0, #0
1d34: 1a000055 bne 1e90 <rtems_bdpart_create+0x1dc>
1d38: e1a03008 mov r3, r8
1d3c: e1a0c008 mov ip, r8
1d40: e1a00007 mov r0, r7
1d44: e1a01007 mov r1, r7
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
unsigned prev_sum = dist_sum;
dist_sum += dist [i];
1d48: e49c2004 ldr r2, [ip], #4
if (dist_sum < prev_sum) {
1d4c: e0921001 adds r1, r2, r1
1d50: 2a00004d bcs 1e8c <rtems_bdpart_create+0x1d8>
return RTEMS_INVALID_NUMBER;
}
if (dist [i] == 0) {
1d54: e3520000 cmp r2, #0
1d58: 0a00004b beq 1e8c <rtems_bdpart_create+0x1d8>
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
1d5c: e2800001 add r0, r0, #1
1d60: e1500004 cmp r0, r4
1d64: 1afffff7 bne 1d48 <rtems_bdpart_create+0x94>
return RTEMS_INVALID_NUMBER;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
1d68: e5962000 ldr r2, [r6]
1d6c: e3520000 cmp r2, #0
1d70: e58d1008 str r1, [sp, #8]
return RTEMS_NOT_IMPLEMENTED;
1d74: 13a07018 movne r7, #24
return RTEMS_INVALID_NUMBER;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
1d78: 1a000044 bne 1e90 <rtems_bdpart_create+0x1dc>
return RTEMS_NOT_IMPLEMENTED;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
1d7c: e35a0000 cmp sl, #0
1d80: 0a000007 beq 1da4 <rtems_bdpart_create+0xf0>
disk_end -= (disk_end % record_space);
1d84: e59d6010 ldr r6, [sp, #16]
1d88: e1a01005 mov r1, r5
1d8c: e1a00006 mov r0, r6
1d90: e58d3000 str r3, [sp]
1d94: eb007666 bl 1f734 <__umodsi3>
1d98: e0600006 rsb r0, r0, r6
1d9c: e58d0010 str r0, [sp, #16]
1da0: e59d3000 ldr r3, [sp]
/*
* In case we need an extended partition and logical partitions we have to
* account for the space of each EBR.
*/
if (count > 4) {
1da4: e3540004 cmp r4, #4
overhead += (count - 3) * record_space;
1da8: 82442003 subhi r2, r4, #3
1dac: 80225295 mlahi r2, r5, r2, r5
/*
* We need at least space for the MBR and the compatibility space for the
* first primary partition.
*/
overhead += record_space;
1db0: 91a02005 movls r2, r5
/*
* Account space to align every partition on cylinder boundaries if
* necessary.
*/
if (dos_compatibility) {
1db4: e35a0000 cmp sl, #0
overhead += (count - 1) * record_space;
1db8: 12441001 subne r1, r4, #1
1dbc: 10222591 mlane r2, r1, r5, r2
}
/* Check disk space */
if ((overhead + count) > disk_end) {
1dc0: e59d9010 ldr r9, [sp, #16]
1dc4: e0821004 add r1, r2, r4
1dc8: e1510009 cmp r1, r9
return RTEMS_IO_ERROR;
1dcc: 83a0701b movhi r7, #27
if (dos_compatibility) {
overhead += (count - 1) * record_space;
}
/* Check disk space */
if ((overhead + count) > disk_end) {
1dd0: 8a00002e bhi 1e90 <rtems_bdpart_create+0x1dc>
/* Begin of first primary partition */
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
1dd4: e0622009 rsb r2, r2, r9
1dd8: e59da004 ldr sl, [sp, #4]
for (i = 0; i < count; ++i) {
1ddc: e58d900c str r9, [sp, #12]
if ((overhead + count) > disk_end) {
return RTEMS_IO_ERROR;
}
/* Begin of first primary partition */
pos = record_space;
1de0: e1a06005 mov r6, r5
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
1de4: e3a08000 mov r8, #0
1de8: e1a0c007 mov ip, r7
1dec: e1a09002 mov r9, r2
1df0: e1a0b003 mov fp, r3
rtems_bdpart_partition *p = pt + i;
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
1df4: e49b1004 ldr r1, [fp], #4
1df8: e0000199 mul r0, r9, r1
if (s < free_space || s < dist [i]) {
1dfc: e1500009 cmp r0, r9
1e00: 3a000021 bcc 1e8c <rtems_bdpart_create+0x1d8>
1e04: e1500001 cmp r0, r1
1e08: 3a00001f bcc 1e8c <rtems_bdpart_create+0x1d8>
/* TODO: Calculate without overflow */
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
1e0c: e59d1008 ldr r1, [sp, #8]
1e10: e58dc000 str ip, [sp]
1e14: eb007600 bl 1f61c <__aeabi_uidiv>
/* Ensure that the partition is not empty */
if (s == 0) {
s = 1;
1e18: e3500000 cmp r0, #0
1e1c: 11a07000 movne r7, r0
1e20: 03a07001 moveq r7, #1
}
/* Align partition upwards */
s += record_space - (s % record_space);
1e24: e1a00007 mov r0, r7
1e28: e1a01005 mov r1, r5
1e2c: eb007640 bl 1f734 <__umodsi3>
1e30: e0877005 add r7, r7, r5
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
1e34: e3580002 cmp r8, #2
1e38: 83540004 cmphi r4, #4
pos += record_space;
1e3c: 80866005 addhi r6, r6, r5
if (s == 0) {
s = 1;
}
/* Align partition upwards */
s += record_space - (s % record_space);
1e40: e0607007 rsb r7, r0, r7
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
1e44: e2888001 add r8, r8, #1
/* Align partition upwards */
s += record_space - (s % record_space);
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
1e48: e59dc000 ldr ip, [sp]
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
1e4c: e1580004 cmp r8, r4
if (count > 4 && i > 2) {
pos += record_space;
}
/* Partition begin and end */
p->begin = pos;
1e50: e58a6000 str r6, [sl]
pos += s;
1e54: e0866007 add r6, r6, r7
p->end = pos;
1e58: e58a6004 str r6, [sl, #4]
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
1e5c: e28aa030 add sl, sl, #48 ; 0x30
1e60: 1affffe3 bne 1df4 <rtems_bdpart_create+0x140>
pos += s;
p->end = pos;
}
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
1e64: e59d2004 ldr r2, [sp, #4]
1e68: e2488001 sub r8, r8, #1
1e6c: e3a03030 mov r3, #48 ; 0x30
1e70: e0282893 mla r8, r3, r8, r2
1e74: e59d900c ldr r9, [sp, #12]
1e78: e1a0700c mov r7, ip
1e7c: e5889004 str r9, [r8, #4]
return RTEMS_SUCCESSFUL;
1e80: ea000002 b 1e90 <rtems_bdpart_create+0x1dc>
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL || dist == NULL) {
return RTEMS_INVALID_ADDRESS;
1e84: e3a07009 mov r7, #9 <== NOT EXECUTED
1e88: ea000000 b 1e90 <rtems_bdpart_create+0x1dc> <== NOT EXECUTED
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
if (s < free_space || s < dist [i]) {
/* TODO: Calculate without overflow */
return RTEMS_INVALID_NUMBER;
1e8c: e3a0700a mov r7, #10 <== NOT EXECUTED
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
return RTEMS_SUCCESSFUL;
}
1e90: e1a00007 mov r0, r7
1e94: e28dd014 add sp, sp, #20
1e98: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00001e9c <rtems_bdpart_dump>:
{
uuid_unparse_lower( type, str);
}
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
1e9c: e92d40f0 push {r4, r5, r6, r7, lr}
1ea0: e1a04000 mov r4, r0
1ea4: e24dd038 sub sp, sp, #56 ; 0x38
size_t i = 0;
printf(
1ea8: e59f00d4 ldr r0, [pc, #212] ; 1f84 <bsp_section_rodata_size+0xc0>
{
uuid_unparse_lower( type, str);
}
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
1eac: e1a06001 mov r6, r1
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
1eb0: e3a05000 mov r5, #0
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
size_t i = 0;
printf(
1eb4: eb004577 bl 13498 <puts>
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
1eb8: ea00002b b 1f6c <bsp_section_rodata_size+0xa8>
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)) {
1ebc: e2847008 add r7, r4, #8
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;
1ec0: e3a03000 mov r3, #0
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
1ec4: e1a00007 mov r0, r7
1ec8: e28d1037 add r1, sp, #55 ; 0x37
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;
1ecc: e5cd3037 strb r3, [sp, #55] ; 0x37
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
1ed0: eb000094 bl 2128 <rtems_bdpart_to_mbr_partition_type>
1ed4: e3500000 cmp r0, #0
1ed8: 0a000018 beq 1f40 <bsp_section_rodata_size+0x7c>
switch (type_mbr) {
1edc: e5dd3037 ldrb r3, [sp, #55] ; 0x37
1ee0: e353000b cmp r3, #11
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
1ee4: 059f309c ldreq r3, [pc, #156] ; 1f88 <bsp_section_rodata_size+0xc4>
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) {
1ee8: 0a00001a beq 1f58 <bsp_section_rodata_size+0x94>
1eec: 8a000005 bhi 1f08 <bsp_section_rodata_size+0x44> <== NOT EXECUTED
1ef0: e3530001 cmp r3, #1 <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_12:
type = "FAT 12";
1ef4: 059f3090 ldreq r3, [pc, #144] ; 1f8c <bsp_section_rodata_size+0xc8><== 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) {
1ef8: 0a000016 beq 1f58 <bsp_section_rodata_size+0x94> <== NOT EXECUTED
1efc: e3530004 cmp r3, #4 <== NOT EXECUTED
1f00: 1a000009 bne 1f2c <bsp_section_rodata_size+0x68> <== NOT EXECUTED
1f04: ea000012 b 1f54 <bsp_section_rodata_size+0x90> <== NOT EXECUTED
1f08: e353000e cmp r3, #14 <== NOT EXECUTED
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
1f0c: 059f307c ldreq r3, [pc, #124] ; 1f90 <bsp_section_rodata_size+0xcc><== 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) {
1f10: 0a000010 beq 1f58 <bsp_section_rodata_size+0x94> <== NOT EXECUTED
1f14: e35300da cmp r3, #218 ; 0xda <== NOT EXECUTED
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
1f18: 059f3074 ldreq r3, [pc, #116] ; 1f94 <bsp_section_rodata_size+0xd0><== 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) {
1f1c: 0a00000d beq 1f58 <bsp_section_rodata_size+0x94> <== NOT EXECUTED
1f20: e353000c cmp r3, #12 <== NOT EXECUTED
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
1f24: 059f306c ldreq r3, [pc, #108] ; 1f98 <bsp_section_rodata_size+0xd4><== NOT EXECUTED
break;
1f28: 0a00000a beq 1f58 <bsp_section_rodata_size+0x94> <== NOT EXECUTED
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
1f2c: e1a0000d mov r0, sp <== NOT EXECUTED
1f30: e3a01034 mov r1, #52 ; 0x34 <== NOT EXECUTED
1f34: e59f2060 ldr r2, [pc, #96] ; 1f9c <bsp_section_rodata_size+0xd8><== NOT EXECUTED
1f38: eb0045f4 bl 13710 <snprintf> <== NOT EXECUTED
1f3c: ea000002 b 1f4c <bsp_section_rodata_size+0x88> <== NOT EXECUTED
static void rtems_bdpart_type_to_string(
const uuid_t type,
char str [37]
)
{
uuid_unparse_lower( type, str);
1f40: e1a00007 mov r0, r7 <== NOT EXECUTED
1f44: e1a0100d mov r1, sp <== NOT EXECUTED
1f48: eb002866 bl c0e8 <uuid_unparse_lower> <== NOT EXECUTED
type = type_buffer;
break;
}
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
1f4c: e1a0300d mov r3, sp <== NOT EXECUTED
1f50: ea000000 b 1f58 <bsp_section_rodata_size+0x94> <== NOT EXECUTED
switch (type_mbr) {
case RTEMS_BDPART_MBR_FAT_12:
type = "FAT 12";
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
1f54: e59f3044 ldr r3, [pc, #68] ; 1fa0 <bsp_section_rodata_size+0xdc><== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
1f58: e8940006 ldm r4, {r1, r2}
1f5c: e59f0040 ldr r0, [pc, #64] ; 1fa4 <bsp_section_rodata_size+0xe0>
1f60: eb004515 bl 133bc <printf>
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
1f64: e2855001 add r5, r5, #1
1f68: e2844030 add r4, r4, #48 ; 0x30
1f6c: e1550006 cmp r5, r6
1f70: 1affffd1 bne 1ebc <rtems_bdpart_dump+0x20>
p->end,
type
);
}
puts( "------------+------------+-----------------------------------------------------");
1f74: e59f002c ldr r0, [pc, #44] ; 1fa8 <bsp_section_rodata_size+0xe4>
1f78: eb004546 bl 13498 <puts>
}
1f7c: e28dd038 add sp, sp, #56 ; 0x38
1f80: e8bd80f0 pop {r4, r5, r6, r7, pc}
00002150 <rtems_bdpart_get_disk_data>:
const char *disk_name,
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
2150: e92d40f1 push {r0, r4, r5, r6, r7, lr}
2154: e1a05001 mov r5, r1
2158: e1a07003 mov r7, r3
rtems_disk_device *dd = NULL;
rtems_blkdev_bnum disk_begin = 0;
rtems_blkdev_bnum block_size = 0;
/* Open device file */
fd = open( disk_name, O_RDWR);
215c: e3a01002 mov r1, #2
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int rv = 0;
int fd = -1;
rtems_disk_device *dd = NULL;
2160: e3a03000 mov r3, #0
const char *disk_name,
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
2164: e1a04002 mov r4, r2
rtems_status_code sc = RTEMS_SUCCESSFUL; int rv = 0; int fd = -1; rtems_disk_device *dd = NULL;
2168: e58d3000 str r3, [sp]
rtems_blkdev_bnum disk_begin = 0;
rtems_blkdev_bnum block_size = 0;
/* Open device file */
fd = open( disk_name, O_RDWR);
216c: eb000c34 bl 5244 <open>
if (fd < 0) {
2170: e2506000 subs r6, r0, #0
2174: ba000010 blt 21bc <rtems_bdpart_get_disk_data+0x6c>
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
2178: e59f107c ldr r1, [pc, #124] ; 21fc <rtems_bdpart_get_disk_data+0xac>
217c: e1a0200d mov r2, sp
2180: eb00091c bl 45f8 <ioctl>
goto error;
}
/* Get disk handle */
rv = rtems_disk_fd_get_disk_device( fd, &dd);
if (rv != 0) {
2184: e3500000 cmp r0, #0
2188: 1a00000b bne 21bc <rtems_bdpart_get_disk_data+0x6c>
sc = RTEMS_INVALID_NAME;
goto error;
}
/* Get disk begin, end and block size */
disk_begin = dd->start;
218c: e59d3000 ldr r3, [sp]
*disk_end = dd->size;
2190: e593101c ldr r1, [r3, #28]
sc = RTEMS_INVALID_NAME;
goto error;
}
/* Get disk begin, end and block size */
disk_begin = dd->start;
2194: e5932018 ldr r2, [r3, #24]
*disk_end = dd->size;
2198: e5871000 str r1, [r7]
block_size = dd->block_size;
/* Check block size */
if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
219c: e5933024 ldr r3, [r3, #36] ; 0x24
21a0: e3530c02 cmp r3, #512 ; 0x200
sc = RTEMS_IO_ERROR;
21a4: 33a0701b movcc r7, #27
disk_begin = dd->start;
*disk_end = dd->size;
block_size = dd->block_size;
/* Check block size */
if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
21a8: 3a000004 bcc 21c0 <rtems_bdpart_get_disk_data+0x70>
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
21ac: e3520000 cmp r2, #0
21b0: 13a0701b movne r7, #27
21b4: 03a07000 moveq r7, #0
21b8: ea000000 b 21c0 <rtems_bdpart_get_disk_data+0x70>
}
/* Get disk handle */
rv = rtems_disk_fd_get_disk_device( fd, &dd);
if (rv != 0) {
sc = RTEMS_INVALID_NAME;
21bc: e3a07003 mov r7, #3 <== NOT EXECUTED
goto error;
}
error:
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
21c0: e2773001 rsbs r3, r7, #1
21c4: 33a03000 movcc r3, #0
21c8: e3550000 cmp r5, #0
21cc: 03a03000 moveq r3, #0
21d0: e3530000 cmp r3, #0
21d4: 0a000004 beq 21ec <rtems_bdpart_get_disk_data+0x9c>
21d8: e3540000 cmp r4, #0
*fd_ptr = fd;
*dd_ptr = dd;
21dc: 159d3000 ldrne r3, [sp]
}
error:
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
*fd_ptr = fd;
21e0: 15856000 strne r6, [r5]
*dd_ptr = dd;
21e4: 15843000 strne r3, [r4]
goto error;
}
error:
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
21e8: 1a000001 bne 21f4 <rtems_bdpart_get_disk_data+0xa4>
*fd_ptr = fd;
*dd_ptr = dd;
} else {
close( fd);
21ec: e1a00006 mov r0, r6
21f0: eb0007ed bl 41ac <close>
}
return sc;
}
21f4: e1a00007 mov r0, r7
21f8: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
0001dfc8 <rtems_bdpart_mount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
1dfc8: 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, '/');
1dfcc: 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
)
{
1dfd0: e1a0b003 mov fp, r3 <== NOT EXECUTED 1dfd4: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 1dfd8: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL; const char *disk_file_name = strrchr( disk_name, '/');
1dfdc: eb006dcf bl 39720 <strrchr> <== NOT EXECUTED 1dfe0: e1a0a000 mov sl, 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);
1dfe4: e1a00004 mov r0, r4 <== NOT EXECUTED 1dfe8: eb0069ae bl 386a8 <strlen> <== NOT EXECUTED 1dfec: e1a06000 mov r6, r0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
1dff0: e1a0000b mov r0, fp <== NOT EXECUTED 1dff4: eb0069ab bl 386a8 <strlen> <== NOT EXECUTED 1dff8: 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);
1dffc: e2860004 add r0, r6, #4 <== NOT EXECUTED 1e000: ebff93ba bl 2ef0 <malloc> <== NOT EXECUTED
if (logical_disk_name == NULL) {
1e004: e2505000 subs r5, r0, #0 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
1e008: 03a0601a moveq r6, #26 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
size_t i = 0;
/* Create logical disk name base */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
if (logical_disk_name == NULL) {
1e00c: 0a000044 beq 1e124 <rtems_bdpart_mount+0x15c> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
1e010: e1a01004 mov r1, r4 <== NOT EXECUTED 1e014: e1a02006 mov r2, r6 <== NOT EXECUTED 1e018: eb006a44 bl 38930 <strncpy> <== NOT EXECUTED
/* Get disk file name */
if (disk_file_name != NULL) {
1e01c: e35a0000 cmp sl, #0 <== NOT EXECUTED
disk_file_name += 1;
disk_file_name_size = strlen( disk_file_name);
} else {
disk_file_name = disk_name;
disk_file_name_size = disk_name_size;
1e020: 01a08006 moveq r8, r6 <== NOT EXECUTED
/* Get disk file name */
if (disk_file_name != NULL) {
disk_file_name += 1;
disk_file_name_size = strlen( disk_file_name);
} else {
disk_file_name = disk_name;
1e024: 01a0a004 moveq sl, r4 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
/* Get disk file name */
if (disk_file_name != NULL) {
1e028: 0a000003 beq 1e03c <rtems_bdpart_mount+0x74> <== NOT EXECUTED
disk_file_name += 1;
1e02c: e28aa001 add sl, sl, #1 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
1e030: e1a0000a mov r0, sl <== NOT EXECUTED 1e034: eb00699b bl 386a8 <strlen> <== NOT EXECUTED 1e038: 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);
1e03c: e0889007 add r9, r8, r7 <== NOT EXECUTED 1e040: e2890005 add r0, r9, #5 <== NOT EXECUTED 1e044: ebff93a9 bl 2ef0 <malloc> <== NOT EXECUTED
if (mount_point == NULL) {
1e048: e2504000 subs r4, r0, #0 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
1e04c: 03a0601a moveq r6, #26 <== NOT EXECUTED
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);
if (mount_point == NULL) {
1e050: 0a00002f beq 1e114 <rtems_bdpart_mount+0x14c> <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
1e054: e1a02007 mov r2, r7 <== NOT EXECUTED 1e058: e1a0100b mov r1, fp <== NOT EXECUTED 1e05c: eb006a33 bl 38930 <strncpy> <== NOT EXECUTED
mount_point [mount_base_size] = '/';
1e060: e3a0302f mov r3, #47 ; 0x2f <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
1e064: 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] = '/';
1e068: e7c43007 strb r3, [r4, r7] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
1e06c: e0840000 add r0, r4, r0 <== NOT EXECUTED 1e070: e1a0100a mov r1, sl <== NOT EXECUTED 1e074: 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;
1e078: 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);
1e07c: eb006a2b bl 38930 <strncpy> <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
1e080: e0856006 add r6, r5, r6 <== NOT EXECUTED
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
1e084: e0849009 add r9, r4, r9 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
1e088: e3a07000 mov r7, #0 <== NOT EXECUTED 1e08c: ea000018 b 1e0f4 <rtems_bdpart_mount+0x12c> <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
1e090: e2877001 add r7, r7, #1 <== NOT EXECUTED 1e094: e1a00006 mov r0, r6 <== NOT EXECUTED 1e098: e3a01004 mov r1, #4 <== NOT EXECUTED 1e09c: e59f2088 ldr r2, [pc, #136] ; 1e12c <rtems_bdpart_mount+0x164><== NOT EXECUTED 1e0a0: e1a03007 mov r3, r7 <== NOT EXECUTED 1e0a4: eb006574 bl 3767c <snprintf> <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
1e0a8: e3500003 cmp r0, #3 <== NOT EXECUTED 1e0ac: ca000015 bgt 1e108 <rtems_bdpart_mount+0x140> <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
1e0b0: e1a01006 mov r1, r6 <== NOT EXECUTED 1e0b4: e3a02004 mov r2, #4 <== NOT EXECUTED 1e0b8: e1a00009 mov r0, r9 <== NOT EXECUTED 1e0bc: eb006a1b bl 38930 <strncpy> <== NOT EXECUTED
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
1e0c0: e1a00004 mov r0, r4 <== NOT EXECUTED 1e0c4: e59f1064 ldr r1, [pc, #100] ; 1e130 <rtems_bdpart_mount+0x168><== NOT EXECUTED 1e0c8: eb000daf bl 2178c <rtems_mkdir> <== NOT EXECUTED
if (rv != 0) {
1e0cc: e2503000 subs r3, r0, #0 <== NOT EXECUTED 1e0d0: 1a00000e bne 1e110 <rtems_bdpart_mount+0x148> <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
1e0d4: e1a00005 mov r0, r5 <== NOT EXECUTED 1e0d8: e1a01004 mov r1, r4 <== NOT EXECUTED 1e0dc: e59f2050 ldr r2, [pc, #80] ; 1e134 <rtems_bdpart_mount+0x16c><== NOT EXECUTED 1e0e0: e58d3000 str r3, [sp] <== NOT EXECUTED 1e0e4: ebff93fb bl 30d8 <mount> <== NOT EXECUTED
mount_point,
"msdos",
0,
NULL
);
if (rv != 0) {
1e0e8: e3500000 cmp r0, #0 <== NOT EXECUTED
rmdir( mount_point);
1e0ec: 11a00004 movne r0, r4 <== NOT EXECUTED 1e0f0: 1b000d7a blne 216e0 <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) {
1e0f4: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 1e0f8: e1570003 cmp r7, r3 <== NOT EXECUTED 1e0fc: 1affffe3 bne 1e090 <rtems_bdpart_mount+0xc8> <== NOT EXECUTED
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
rtems_status_code esc = RTEMS_SUCCESSFUL;
1e100: e3a06000 mov r6, #0 <== NOT EXECUTED 1e104: ea000002 b 1e114 <rtems_bdpart_mount+0x14c> <== 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) {
esc = RTEMS_INVALID_NAME;
1e108: e3a06003 mov r6, #3 <== NOT EXECUTED 1e10c: ea000000 b 1e114 <rtems_bdpart_mount+0x14c> <== 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) {
esc = RTEMS_IO_ERROR;
1e110: e3a0601b mov r6, #27 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
1e114: e1a00005 mov r0, r5 <== NOT EXECUTED 1e118: ebff92af bl 2bdc <free> <== NOT EXECUTED
free( mount_point);
1e11c: e1a00004 mov r0, r4 <== NOT EXECUTED 1e120: ebff92ad bl 2bdc <free> <== NOT EXECUTED
return esc;
}
1e124: e1a00006 mov r0, r6 <== NOT EXECUTED
1e128: e8bd8ffc pop {r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00002200 <rtems_bdpart_read>:
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
2200: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
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);
2204: e2534000 subs r4, r3, #0
2208: 15943000 ldrne r3, [r4]
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
220c: e1a05002 mov r5, r2
2210: e1a06001 mov r6, r1
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);
2214: 13a08030 movne r8, #48 ; 0x30
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
2218: e24dd018 sub sp, sp, #24
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_status_code esc = RTEMS_SUCCESSFUL; rtems_bdbuf_buffer *block = NULL;
221c: e3a02000 mov r2, #0
rtems_bdpart_partition *p = pt - 1; const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
2220: 10080893 mulne r8, r3, r8
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
rtems_bdpart_partition *p = pt - 1;
2224: e2451030 sub r1, r5, #48 ; 0x30
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; size_t i = 0; const uint8_t *data = NULL; int fd = -1;
2228: e3e03000 mvn r3, #0
{
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);
222c: 01a08004 moveq r8, r4
const uint8_t *data = NULL;
int fd = -1;
rtems_disk_device *dd = NULL;
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
2230: e3560000 cmp r6, #0
2234: 13550000 cmpne r5, #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; size_t i = 0; const uint8_t *data = NULL; int fd = -1;
2238: e58d3010 str r3, [sp, #16]
size_t *count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
223c: e58d2000 str r2, [sp]
rtems_bdpart_partition *p = pt - 1;
2240: e58d1004 str r1, [sp, #4]
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0); rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */
2244: e58d2008 str r2, [sp, #8]
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */ rtems_blkdev_bnum disk_end = 0;
2248: e58d200c str r2, [sp, #12]
size_t i = 0; const uint8_t *data = NULL; int fd = -1; rtems_disk_device *dd = NULL;
224c: e58d2014 str r2, [sp, #20]
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
2250: 13a03000 movne r3, #0
2254: 03a03001 moveq r3, #1
2258: 0a000077 beq 243c <rtems_bdpart_read+0x23c>
225c: e3540000 cmp r4, #0
2260: 0a000075 beq 243c <rtems_bdpart_read+0x23c>
return RTEMS_INVALID_ADDRESS;
}
/* Set count to a save value */
*count = 0;
2264: e5843000 str r3, [r4]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2268: e28d1010 add r1, sp, #16
226c: e28d2014 add r2, sp, #20
2270: e28d300c add r3, sp, #12
2274: ebffffb5 bl 2150 <rtems_bdpart_get_disk_data>
if (sc != RTEMS_SUCCESSFUL) {
2278: e2501000 subs r1, r0, #0
227c: 1a000071 bne 2448 <rtems_bdpart_read+0x248>
return sc;
}
/* Read MBR */
sc = rtems_bdpart_read_record( dd, 0, &block);
2280: e59d0014 ldr r0, [sp, #20]
2284: e1a0200d mov r2, sp
2288: ebffff4f bl 1fcc <rtems_bdpart_read_record>
if (sc != RTEMS_SUCCESSFUL) {
228c: e2503000 subs r3, r0, #0
2290: 1a00005e bne 2410 <rtems_bdpart_read+0x210>
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
2294: e59d3000 ldr r3, [sp]
2298: e593a01c ldr sl, [r3, #28]
229c: e28a7f6f add r7, sl, #444 ; 0x1bc
{
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);
22a0: e0858008 add r8, r5, r8
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
22a4: e2877002 add r7, r7, #2
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
22a8: e28d9004 add r9, sp, #4
22ac: e28db008 add fp, sp, #8
22b0: e1a0300b mov r3, fp
22b4: e1a00007 mov r0, r7
22b8: e1a01009 mov r1, r9
22bc: e1a02008 mov r2, r8
22c0: ebffff68 bl 2068 <rtems_bdpart_read_mbr_partition>
if (sc != RTEMS_SUCCESSFUL) {
22c4: e2503000 subs r3, r0, #0
22c8: 1a000050 bne 2410 <rtems_bdpart_read+0x210>
if (block != NULL) {
rtems_bdbuf_release( block);
}
return esc;
}
22cc: e59d2004 ldr r2, [sp, #4]
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) {
22d0: e5d22008 ldrb r2, [r2, #8]
22d4: e35200ee cmp r2, #238 ; 0xee
esc = RTEMS_NOT_IMPLEMENTED;
22d8: 03a04018 moveq r4, #24
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) {
22dc: 0a00004e beq 241c <rtems_bdpart_read+0x21c>
esc = RTEMS_NOT_IMPLEMENTED;
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
22e0: e5863000 str r3, [r6]
format->mbr.disk_id = rtems_uint32_from_little_endian(
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
22e4: e59d3000 ldr r3, [sp]
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
format->mbr.disk_id = rtems_uint32_from_little_endian(
22e8: e593001c ldr r0, [r3, #28]
22ec: e2800f6e add r0, r0, #440 ; 0x1b8
22f0: ebffff2d bl 1fac <rtems_uint32_from_little_endian>
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
22f4: e28aaf7b add sl, sl, #492 ; 0x1ec
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
format->mbr.disk_id = rtems_uint32_from_little_endian(
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
22f8: e3a03001 mov r3, #1
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
format->mbr.disk_id = rtems_uint32_from_little_endian(
22fc: e5860004 str r0, [r6, #4]
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
2300: e5c63008 strb r3, [r6, #8]
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
2304: e28a6002 add r6, sl, #2
/* 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);
2308: e1a0a009 mov sl, r9
);
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;
230c: e2877010 add r7, r7, #16
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
2310: e1a0300b mov r3, fp
2314: e1a00007 mov r0, r7
2318: e1a0100a mov r1, sl
231c: e1a02008 mov r2, r8
2320: ebffff50 bl 2068 <rtems_bdpart_read_mbr_partition>
if (sc != RTEMS_SUCCESSFUL) {
2324: e2503000 subs r3, r0, #0
2328: 1a000038 bne 2410 <rtems_bdpart_read+0x210>
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) {
232c: e1570006 cmp r7, r6
2330: 1afffff5 bne 230c <rtems_bdpart_read+0x10c>
goto cleanup;
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
2334: e59d6008 ldr r6, [sp, #8]
while (ebr != 0) {
2338: ea000029 b 23e4 <rtems_bdpart_read+0x1e4>
rtems_blkdev_bnum tmp = 0;
/* Read EBR */
sc = rtems_bdpart_read_record( dd, ebr, &block);
233c: e59d0014 ldr r0, [sp, #20]
2340: e1a01006 mov r1, r6
2344: e1a0200d mov r2, sp
2348: ebffff1f bl 1fcc <rtems_bdpart_read_record>
if (sc != RTEMS_SUCCESSFUL) {
234c: e2503000 subs r3, r0, #0
2350: 1a00002e bne 2410 <rtems_bdpart_read+0x210>
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
2354: e59d2000 ldr r2, [sp]
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
2358: e592001c ldr r0, [r2, #28]
235c: e2800f6f add r0, r0, #444 ; 0x1bc
2360: e2800002 add r0, r0, #2
2364: e1a0100a mov r1, sl
2368: e1a02008 mov r2, r8
236c: ebffff3d bl 2068 <rtems_bdpart_read_mbr_partition>
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
&p,
p_end,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
2370: e2503000 subs r3, r0, #0
2374: 1a000025 bne 2410 <rtems_bdpart_read+0x210>
esc = sc;
goto cleanup;
}
/* Adjust partition begin */
tmp = p->begin + ebr;
2378: e59d3004 ldr r3, [sp, #4]
237c: e5931000 ldr r1, [r3]
2380: e0862001 add r2, r6, r1
if (tmp > p->begin) {
2384: e1520001 cmp r2, r1
2388: 9a000022 bls 2418 <rtems_bdpart_read+0x218>
p->begin = tmp;
238c: e5832000 str r2, [r3]
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Adjust partition end */
tmp = p->end + ebr;
2390: e5932004 ldr r2, [r3, #4]
2394: e0866002 add r6, r6, r2
if (tmp > p->end) {
2398: e1560002 cmp r6, r2
239c: 9a00001d bls 2418 <rtems_bdpart_read+0x218>
p->end = tmp;
23a0: e5836004 str r6, [r3, #4]
goto cleanup;
}
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
23a4: e59d3000 ldr r3, [sp]
23a8: e593701c ldr r7, [r3, #28]
}
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);
23ac: e2870f75 add r0, r7, #468 ; 0x1d4
== RTEMS_BDPART_MBR_SIGNATURE_1;
}
static rtems_blkdev_bnum rtems_bdpart_next_ebr( const uint8_t *data)
{
rtems_blkdev_bnum begin =
23b0: e2800002 add r0, r0, #2
23b4: ebfffefc bl 1fac <rtems_uint32_from_little_endian>
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EXTENDED) {
23b8: e5d731d2 ldrb r3, [r7, #466] ; 0x1d2
23bc: e3530005 cmp r3, #5
== RTEMS_BDPART_MBR_SIGNATURE_1;
}
static rtems_blkdev_bnum rtems_bdpart_next_ebr( const uint8_t *data)
{
rtems_blkdev_bnum begin =
23c0: e1a06000 mov r6, r0
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EXTENDED) {
23c4: 1a000008 bne 23ec <rtems_bdpart_read+0x1ec>
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
);
if (ebr != 0) {
23c8: e3500000 cmp r0, #0
23cc: 0a000006 beq 23ec <rtems_bdpart_read+0x1ec>
/* Adjust partition EBR block index */
tmp = ebr + ep_begin;
23d0: e59d3008 ldr r3, [sp, #8]
23d4: e0803003 add r3, r0, r3
if (tmp > ebr) {
23d8: e1530000 cmp r3, r0
23dc: 9a00000d bls 2418 <rtems_bdpart_read+0x218>
23e0: e1a06003 mov r6, r3
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
while (ebr != 0) {
23e4: e3560000 cmp r6, #0
23e8: 1affffd3 bne 233c <rtems_bdpart_read+0x13c>
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
23ec: e59d3004 ldr r3, [sp, #4]
23f0: e0655003 rsb r5, r5, r3
23f4: e59f3058 ldr r3, [pc, #88] ; 2454 <rtems_bdpart_read+0x254>
23f8: e1a05245 asr r5, r5, #4
23fc: e0050593 mul r5, r3, r5
2400: e2855001 add r5, r5, #1
2404: e5845000 str r5, [r4]
rtems_bdpart_partition *pt,
size_t *count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
2408: e3a04000 mov r4, #0
240c: ea000002 b 241c <rtems_bdpart_read+0x21c>
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
2410: e1a04003 mov r4, r3 <== NOT EXECUTED
2414: ea000000 b 241c <rtems_bdpart_read+0x21c> <== NOT EXECUTED
/* Adjust partition EBR block index */
tmp = ebr + ep_begin;
if (tmp > ebr) {
ebr = tmp;
} else {
esc = RTEMS_IO_ERROR;
2418: e3a0401b mov r4, #27 <== NOT EXECUTED
/* Return partition count */
*count = (size_t) (p - pt + 1);
cleanup:
if (fd >= 0) {
241c: e59d0010 ldr r0, [sp, #16]
2420: e3500000 cmp r0, #0
close( fd);
2424: ab000760 blge 41ac <close>
}
if (block != NULL) {
2428: e59d0000 ldr r0, [sp]
242c: e3500000 cmp r0, #0
2430: 0a000003 beq 2444 <rtems_bdpart_read+0x244>
rtems_bdbuf_release( block);
2434: eb002ecf bl df78 <rtems_bdbuf_release>
2438: ea000001 b 2444 <rtems_bdpart_read+0x244>
int fd = -1;
rtems_disk_device *dd = NULL;
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
return RTEMS_INVALID_ADDRESS;
243c: e3a01009 mov r1, #9 <== NOT EXECUTED
2440: ea000000 b 2448 <rtems_bdpart_read+0x248> <== NOT EXECUTED
if (block != NULL) {
rtems_bdbuf_release( block);
}
return esc;
2444: e1a01004 mov r1, r4
}
2448: e1a00001 mov r0, r1
244c: e28dd018 add sp, sp, #24
2450: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00002068 <rtems_bdpart_read_mbr_partition>:
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
2068: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
206c: e1a04000 mov r4, r0
rtems_blkdev_bnum begin =
2070: e2800008 add r0, r0, #8
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
2074: e1a05001 mov r5, r1
2078: e1a0a002 mov sl, r2
207c: e1a09003 mov r9, r3
rtems_blkdev_bnum begin =
2080: ebffffc9 bl 1fac <rtems_uint32_from_little_endian>
2084: e1a07000 mov r7, r0
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_blkdev_bnum size =
2088: e284000c add r0, r4, #12
208c: ebffffc6 bl 1fac <rtems_uint32_from_little_endian>
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];
2090: e5d46004 ldrb r6, [r4, #4]
if (type == RTEMS_BDPART_MBR_EMPTY) {
2094: e3560000 cmp r6, #0
return RTEMS_SUCCESSFUL;
2098: 01a00006 moveq r0, r6
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) {
209c: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc}
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
20a0: e5953000 ldr r3, [r5]
20a4: e153000a cmp r3, sl
return RTEMS_TOO_MANY;
20a8: 03a00005 moveq r0, #5
rtems_blkdev_bnum end = begin + size;
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
20ac: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc}
{
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;
20b0: e0808007 add r8, r0, r7
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
return RTEMS_TOO_MANY;
} else if (begin >= end) {
20b4: e1570008 cmp r7, r8
return RTEMS_IO_ERROR;
20b8: 23a0001b movcs r0, #27
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
return RTEMS_TOO_MANY;
} else if (begin >= end) {
20bc: 28bd87f0 popcs {r4, r5, r6, r7, r8, r9, sl, pc}
return RTEMS_IO_ERROR;
} else if (type == RTEMS_BDPART_MBR_EXTENDED) {
20c0: e3560005 cmp r6, #5
20c4: 1a000004 bne 20dc <rtems_bdpart_read_mbr_partition+0x74>
if (ep_begin != NULL) {
20c8: e3590000 cmp r9, #0
*ep_begin = begin;
20cc: 15897000 strne r7, [r9]
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
}
return RTEMS_SUCCESSFUL;
20d0: 13a00000 movne r0, #0
} 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) {
20d4: 18bd87f0 popne {r4, r5, r6, r7, r8, r9, sl, pc}
20d8: ea000010 b 2120 <rtems_bdpart_read_mbr_partition+0xb8> <== NOT EXECUTED
*ep_begin = begin;
}
} else {
/* Increment partition index */
++(*p);
20dc: e2830030 add r0, r3, #48 ; 0x30
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
20e0: e3a02030 mov r2, #48 ; 0x30
20e4: e3a01000 mov r1, #0
if (ep_begin != NULL) {
*ep_begin = begin;
}
} else {
/* Increment partition index */
++(*p);
20e8: e5850000 str r0, [r5]
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
20ec: eb004469 bl 13298 <memset>
/* Set values */
(*p)->begin = begin;
20f0: e5951000 ldr r1, [r5]
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
20f4: e1a00006 mov r0, r6
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
/* Set values */
(*p)->begin = begin;
(*p)->end = end;
20f8: e8810180 stm r1, {r7, r8}
rtems_bdpart_to_partition_type( type, (*p)->type);
20fc: e2811008 add r1, r1, #8
2100: ebffffd2 bl 2050 <rtems_bdpart_to_partition_type>
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
2104: e5953000 ldr r3, [r5]
2108: e5d41000 ldrb r1, [r4]
210c: e3a02000 mov r2, #0
2110: e5831028 str r1, [r3, #40] ; 0x28
2114: e583202c str r2, [r3, #44] ; 0x2c
}
return RTEMS_SUCCESSFUL;
2118: e1a00002 mov r0, r2
211c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
2120: e1a00009 mov r0, r9 <== NOT EXECUTED
}
2124: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
00001fcc <rtems_bdpart_read_record>:
static rtems_status_code rtems_bdpart_read_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
1fcc: e92d4070 push {r4, r5, r6, lr}
1fd0: e1a05000 mov r5, r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
1fd4: e5920000 ldr r0, [r2]
1fd8: e3500000 cmp r0, #0
static rtems_status_code rtems_bdpart_read_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
1fdc: e1a06001 mov r6, r1
1fe0: e1a04002 mov r4, r2
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
1fe4: 0a000002 beq 1ff4 <bsp_section_bss_size+0x20>
sc = rtems_bdbuf_release( *block);
1fe8: eb002fe2 bl df78 <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL) {
1fec: e3500000 cmp r0, #0
1ff0: 18bd8070 popne {r4, r5, r6, pc}
return sc;
}
}
/* Read the record block */
sc = rtems_bdbuf_read( dd, index, block);
1ff4: e1a00005 mov r0, r5
1ff8: e1a01006 mov r1, r6
1ffc: e1a02004 mov r2, r4
2000: eb002f67 bl dda4 <rtems_bdbuf_read>
if (sc != RTEMS_SUCCESSFUL) {
2004: e3500000 cmp r0, #0
2008: 18bd8070 popne {r4, r5, r6, pc}
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
200c: e5943000 ldr r3, [r4]
2010: e3530000 cmp r3, #0
2014: 0a00000b beq 2048 <bsp_section_bss_size+0x74>
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
2018: e593301c ldr r3, [r3, #28]
static bool rtems_bdpart_is_valid_record( const uint8_t *data)
{
return data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0]
== RTEMS_BDPART_MBR_SIGNATURE_0
&& data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1]
201c: e5d321fe ldrb r2, [r3, #510] ; 0x1fe
2020: e3520055 cmp r2, #85 ; 0x55
2024: 1a000003 bne 2038 <bsp_section_bss_size+0x64>
}
return RTEMS_SUCCESSFUL;
}
static rtems_status_code rtems_bdpart_read_record(
2028: e5d301ff ldrb r0, [r3, #511] ; 0x1ff
202c: e24030aa sub r3, r0, #170 ; 0xaa
2030: e2730000 rsbs r0, r3, #0
2034: e0a00003 adc r0, r0, r3
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
2038: e31000ff tst r0, #255 ; 0xff
203c: 13a00000 movne r0, #0
2040: 03a0001b moveq r0, #27
2044: e8bd8070 pop {r4, r5, r6, pc}
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
return RTEMS_INVALID_ADDRESS;
2048: e3a00009 mov r0, #9 <== NOT EXECUTED
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
204c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00002458 <rtems_bdpart_register>:
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
2458: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
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;
245c: e3a04000 mov r4, #0
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
2460: e24dd01c sub sp, sp, #28
2464: e1a08000 mov r8, r0
2468: e1a0b001 mov fp, r1
246c: e58d200c str r2, [sp, #12]
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;
2470: e58d4010 str r4, [sp, #16]
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);
2474: eb00479f bl 142f8 <strlen>
size_t i = 0; int fd = -1;
2478: e3e03000 mvn r3, #0
247c: e58d3014 str r3, [sp, #20]
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);
2480: e1a05000 mov r5, r0
size_t i = 0;
int fd = -1;
rtems_disk_device *dd = NULL;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2484: e28d1014 add r1, sp, #20
2488: e1a00008 mov r0, r8
248c: e28d2018 add r2, sp, #24
2490: e28d3010 add r3, sp, #16
char *logical_disk_name = NULL; char *logical_disk_marker = NULL; size_t disk_name_size = strlen( disk_name); size_t i = 0; int fd = -1; rtems_disk_device *dd = NULL;
2494: e58d4018 str r4, [sp, #24]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2498: ebffff2c bl 2150 <rtems_bdpart_get_disk_data>
if (sc != RTEMS_SUCCESSFUL) {
249c: e2504000 subs r4, r0, #0
24a0: 1a00002f bne 2564 <rtems_bdpart_register+0x10c>
static inline dev_t rtems_disk_get_device_identifier(
const rtems_disk_device *dd
)
{
return dd->dev;
24a4: e59d3018 ldr r3, [sp, #24]
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
24a8: e59d0014 ldr r0, [sp, #20]
24ac: e8930600 ldm r3, {r9, sl}
24b0: eb00073d bl 41ac <close>
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
/* Create logical disk name */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
24b4: e2850004 add r0, r5, #4
24b8: eb00094d bl 49f4 <malloc>
if (logical_disk_name == NULL) {
24bc: e2506000 subs r6, r0, #0
)
{
union __rtems_dev_t temp;
temp.device = device;
return temp.__overlay.minor;
24c0: e1a0700a mov r7, sl
return RTEMS_NO_MEMORY;
24c4: 03a0401a moveq r4, #26
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
/* Create logical disk name */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
if (logical_disk_name == NULL) {
24c8: 0a000025 beq 2564 <rtems_bdpart_register+0x10c>
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
24cc: e1a01008 mov r1, r8
24d0: e1a02005 mov r2, r5
logical_disk_marker = logical_disk_name + disk_name_size;
24d4: e0868005 add r8, r6, r5
/* Create logical disk name */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
if (logical_disk_name == NULL) {
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
24d8: eb0047ee bl 14498 <strncpy>
logical_disk_marker = logical_disk_name + disk_name_size;
24dc: e1a0500b mov r5, fp
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
24e0: ea000015 b 253c <rtems_bdpart_register+0xe4>
/* 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);
24e4: e2844001 add r4, r4, #1
24e8: e1a00008 mov r0, r8
24ec: e3a01004 mov r1, #4
24f0: e59f2078 ldr r2, [pc, #120] ; 2570 <rtems_bdpart_register+0x118>
24f4: e1a03004 mov r3, r4
24f8: eb004484 bl 13710 <snprintf>
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
24fc: e3500003 cmp r0, #3
for (i = 0; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
int rv = 0;
/* New minor number */
++minor;
2500: e2877001 add r7, r7, #1
/* 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) {
2504: ca000011 bgt 2550 <rtems_bdpart_register+0xf8>
/* Create logical disk */
sc = rtems_disk_create_log(
logical_disk,
disk,
p->begin,
p->end - p->begin,
2508: e5953000 ldr r3, [r5]
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
250c: e58d3000 str r3, [sp]
2510: e5952004 ldr r2, [r5, #4]
2514: e0633002 rsb r3, r3, r2
2518: e98d0048 stmib sp, {r3, r6}
251c: e1a00009 mov r0, r9
2520: e1a01007 mov r1, r7
2524: e1a02009 mov r2, r9
2528: e1a0300a mov r3, sl
252c: eb0002f0 bl 30f4 <rtems_disk_create_log>
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
2530: e3500000 cmp r0, #0
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
2534: e2855030 add r5, r5, #48 ; 0x30
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
2538: 1a000006 bne 2558 <rtems_bdpart_register+0x100>
}
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) {
253c: e59d300c ldr r3, [sp, #12]
2540: e1540003 cmp r4, r3
2544: 1affffe6 bne 24e4 <rtems_bdpart_register+0x8c>
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
2548: e3a04000 mov r4, #0
254c: ea000002 b 255c <rtems_bdpart_register+0x104>
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) {
esc = RTEMS_INVALID_NAME;
2550: e3a04003 mov r4, #3 <== NOT EXECUTED
2554: ea000000 b 255c <rtems_bdpart_register+0x104> <== NOT EXECUTED
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
2558: e1a04000 mov r4, r0 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
255c: e1a00006 mov r0, r6
2560: eb0007b3 bl 4434 <free>
return esc;
}
2564: e1a00004 mov r0, r4
2568: e28dd01c add sp, sp, #28
256c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0001e138 <rtems_bdpart_unmount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
1e138: 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, '/');
1e13c: 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
)
{
1e140: e1a09003 mov r9, r3 <== NOT EXECUTED 1e144: e1a04000 mov r4, r0 <== NOT EXECUTED 1e148: e1a06002 mov r6, r2 <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL; const char *disk_file_name = strrchr( disk_name, '/');
1e14c: eb006d73 bl 39720 <strrchr> <== NOT EXECUTED 1e150: 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);
1e154: e1a00004 mov r0, r4 <== NOT EXECUTED 1e158: eb006952 bl 386a8 <strlen> <== NOT EXECUTED 1e15c: e1a08000 mov r8, r0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
1e160: e1a00009 mov r0, r9 <== NOT EXECUTED 1e164: eb00694f bl 386a8 <strlen> <== NOT EXECUTED
size_t i = 0;
/* Get disk file name */
if (disk_file_name != NULL) {
1e168: 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);
1e16c: e1a05000 mov r5, r0 <== NOT EXECUTED
/* Get disk file name */
if (disk_file_name != NULL) {
disk_file_name += 1;
disk_file_name_size = strlen( disk_file_name);
} else {
disk_file_name = disk_name;
1e170: 01a0a004 moveq sl, r4 <== NOT EXECUTED
size_t disk_name_size = strlen( disk_name);
size_t mount_base_size = strlen( mount_base);
size_t i = 0;
/* Get disk file name */
if (disk_file_name != NULL) {
1e174: 0a000003 beq 1e188 <rtems_bdpart_unmount+0x50> <== NOT EXECUTED
disk_file_name += 1;
1e178: e28aa001 add sl, sl, #1 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
1e17c: e1a0000a mov r0, sl <== NOT EXECUTED 1e180: eb006948 bl 386a8 <strlen> <== NOT EXECUTED 1e184: 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);
1e188: e0887005 add r7, r8, r5 <== NOT EXECUTED 1e18c: e2870005 add r0, r7, #5 <== NOT EXECUTED 1e190: ebff9356 bl 2ef0 <malloc> <== NOT EXECUTED
if (mount_point == NULL) {
1e194: e2504000 subs r4, r0, #0 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
1e198: 03a0501a moveq r5, #26 <== NOT EXECUTED
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);
if (mount_point == NULL) {
1e19c: 0a000024 beq 1e234 <rtems_bdpart_unmount+0xfc> <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
1e1a0: e1a02005 mov r2, r5 <== NOT EXECUTED 1e1a4: e1a01009 mov r1, r9 <== NOT EXECUTED 1e1a8: eb0069e0 bl 38930 <strncpy> <== NOT EXECUTED
mount_point [mount_base_size] = '/';
1e1ac: e3a0302f mov r3, #47 ; 0x2f <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
1e1b0: 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] = '/';
1e1b4: e7c43005 strb r3, [r4, r5] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
1e1b8: e0840000 add r0, r4, r0 <== NOT EXECUTED 1e1bc: e1a0100a mov r1, sl <== NOT EXECUTED 1e1c0: e1a02008 mov r2, r8 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
1e1c4: 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);
1e1c8: eb0069d8 bl 38930 <strncpy> <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
1e1cc: e0847007 add r7, r4, r7 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
1e1d0: e3a05000 mov r5, #0 <== NOT EXECUTED 1e1d4: ea00000f b 1e218 <rtems_bdpart_unmount+0xe0> <== NOT EXECUTED
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
1e1d8: e2855001 add r5, r5, #1 <== NOT EXECUTED 1e1dc: e1a00007 mov r0, r7 <== NOT EXECUTED 1e1e0: e3a01004 mov r1, #4 <== NOT EXECUTED 1e1e4: e59f2058 ldr r2, [pc, #88] ; 1e244 <rtems_bdpart_unmount+0x10c><== NOT EXECUTED 1e1e8: e1a03005 mov r3, r5 <== NOT EXECUTED 1e1ec: eb006522 bl 3767c <snprintf> <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
1e1f0: e3500003 cmp r0, #3 <== NOT EXECUTED 1e1f4: ca00000b bgt 1e228 <rtems_bdpart_unmount+0xf0> <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
1e1f8: e1a00004 mov r0, r4 <== NOT EXECUTED 1e1fc: eb000ed4 bl 21d54 <unmount> <== NOT EXECUTED
if (rv == 0) {
1e200: e3500000 cmp r0, #0 <== NOT EXECUTED 1e204: 1a000003 bne 1e218 <rtems_bdpart_unmount+0xe0> <== NOT EXECUTED
/* Remove mount point */
rv = rmdir( mount_point);
1e208: e1a00004 mov r0, r4 <== NOT EXECUTED 1e20c: eb000d33 bl 216e0 <rmdir> <== NOT EXECUTED
if (rv != 0) {
1e210: e3500000 cmp r0, #0 <== NOT EXECUTED 1e214: 1a000005 bne 1e230 <rtems_bdpart_unmount+0xf8> <== 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) {
1e218: e1550006 cmp r5, r6 <== NOT EXECUTED 1e21c: 1affffed bne 1e1d8 <rtems_bdpart_unmount+0xa0> <== NOT EXECUTED
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
rtems_status_code esc = RTEMS_SUCCESSFUL;
1e220: e3a05000 mov r5, #0 <== NOT EXECUTED 1e224: ea000002 b 1e234 <rtems_bdpart_unmount+0xfc> <== 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) {
esc = RTEMS_INVALID_NAME;
1e228: e3a05003 mov r5, #3 <== NOT EXECUTED 1e22c: ea000000 b 1e234 <rtems_bdpart_unmount+0xfc> <== NOT EXECUTED
rv = unmount( mount_point);
if (rv == 0) {
/* Remove mount point */
rv = rmdir( mount_point);
if (rv != 0) {
esc = RTEMS_IO_ERROR;
1e230: e3a0501b mov r5, #27 <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
1e234: e1a00004 mov r0, r4 <== NOT EXECUTED 1e238: ebff9267 bl 2bdc <free> <== NOT EXECUTED
return esc;
}
1e23c: e1a00005 mov r0, r5 <== NOT EXECUTED
1e240: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
000025b4 <rtems_bdpart_unregister>:
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count
)
{
25b4: e92d41f7 push {r0, r1, r2, r4, r5, r6, r7, r8, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_device_major_number major = 0; rtems_device_minor_number minor = 0; rtems_blkdev_bnum disk_end = 0;
25b8: e3a03000 mov r3, #0
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count
)
{
25bc: e1a04002 mov r4, r2
rtems_device_minor_number minor = 0; rtems_blkdev_bnum disk_end = 0; dev_t disk = 0; dev_t logical_disk = 0; size_t i = 0; int fd = -1;
25c0: e3e02000 mvn r2, #0
rtems_disk_device *dd = NULL;
25c4: e98d000c stmib sp, {r2, r3}
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_blkdev_bnum disk_end = 0;
25c8: e58d3000 str r3, [sp]
size_t i = 0;
int fd = -1;
rtems_disk_device *dd = NULL;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
25cc: e28d1004 add r1, sp, #4
25d0: e28d2008 add r2, sp, #8
25d4: e1a0300d mov r3, sp
25d8: ebfffedc bl 2150 <rtems_bdpart_get_disk_data>
if (sc != RTEMS_SUCCESSFUL) {
25dc: e2505000 subs r5, r0, #0
25e0: 1a000011 bne 262c <rtems_bdpart_unregister+0x78>
25e4: e59d3008 ldr r3, [sp, #8]
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
25e8: e59d0004 ldr r0, [sp, #4]
25ec: e5938000 ldr r8, [r3]
25f0: e5937004 ldr r7, [r3, #4]
/* 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) {
25f4: e1a06005 mov r6, r5
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
25f8: eb0006eb bl 41ac <close>
/* 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) {
25fc: ea000006 b 261c <rtems_bdpart_unregister+0x68>
/* New minor number */
++minor;
2600: e2877001 add r7, r7, #1
/* Get the device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Delete logical disk */
sc = rtems_disk_delete( logical_disk);
2604: e1a00008 mov r0, r8
2608: e1a01007 mov r1, r7
260c: eb000253 bl 2f60 <rtems_disk_delete>
if (sc != RTEMS_SUCCESSFUL) {
2610: e3500000 cmp r0, #0
2614: 1a000003 bne 2628 <rtems_bdpart_unregister+0x74>
/* 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) {
2618: e2866001 add r6, r6, #1
261c: e1560004 cmp r6, r4
2620: 1afffff6 bne 2600 <rtems_bdpart_unregister+0x4c>
2624: ea000000 b 262c <rtems_bdpart_unregister+0x78>
/* Get the device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Delete logical disk */
sc = rtems_disk_delete( logical_disk);
2628: e1a05000 mov r5, r0 <== NOT EXECUTED
return sc;
}
}
return RTEMS_SUCCESSFUL;
}
262c: e1a00005 mov r0, r5
2630: e8bd81fe pop {r1, r2, r3, r4, r5, r6, r7, r8, pc}
00002710 <rtems_bdpart_write>:
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
2710: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
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;
2714: e2514000 subs r4, r1, #0
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
2718: e24dd024 sub sp, sp, #36 ; 0x24
271c: e1a05002 mov r5, r2
2720: e1a0a003 mov sl, r3
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;
2724: 01a08004 moveq r8, r4
2728: 0a000003 beq 273c <rtems_bdpart_write+0x2c>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
272c: e5943000 ldr r3, [r4]
2730: e3530000 cmp r3, #0
&& format->mbr.dos_compatibility;
2734: 05d48008 ldrbeq r8, [r4, #8]
2738: 13a08000 movne r8, #0
rtems_bdbuf_buffer *block = NULL;
273c: e3a03000 mov r3, #0
rtems_blkdev_bnum disk_end = 0; rtems_blkdev_bnum record_space =
2740: e21880ff ands r8, r8, #255 ; 0xff
2744: 03a0b001 moveq fp, #1
2748: 13a0b03f movne fp, #63 ; 0x3f
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
size_t ppc = 0; /* Primary partition count */
size_t i = 0;
uint8_t *data = NULL;
int fd = -1;
274c: e3e02000 mvn r2, #0
rtems_disk_device *dd = NULL;
/* Check if we have something to do */
if (count == 0) {
2750: e15a0003 cmp sl, r3
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;
2754: e58d3010 str r3, [sp, #16]
rtems_blkdev_bnum disk_end = 0;
2758: e58d3014 str r3, [sp, #20]
rtems_blkdev_bnum record_space =
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
size_t ppc = 0; /* Primary partition count */
size_t i = 0;
uint8_t *data = NULL;
int fd = -1;
275c: e58d2018 str r2, [sp, #24]
rtems_disk_device *dd = NULL;
2760: e58d301c str r3, [sp, #28]
/* Check if we have something to do */
if (count == 0) {
/* Nothing to do */
return RTEMS_SUCCESSFUL;
2764: 01a0000a moveq r0, sl
uint8_t *data = NULL;
int fd = -1;
rtems_disk_device *dd = NULL;
/* Check if we have something to do */
if (count == 0) {
2768: 0a0000bf beq 2a6c <rtems_bdpart_write+0x35c>
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
276c: e1540003 cmp r4, r3
2770: 11550003 cmpne r5, r3
return RTEMS_INVALID_ADDRESS;
2774: 03a00009 moveq r0, #9
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
2778: 0a0000bb beq 2a6c <rtems_bdpart_write+0x35c>
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
277c: e28d1018 add r1, sp, #24
2780: e28d201c add r2, sp, #28
2784: e28d3014 add r3, sp, #20
2788: ebfffe70 bl 2150 <rtems_bdpart_get_disk_data>
if (sc != RTEMS_SUCCESSFUL) {
278c: e3500000 cmp r0, #0
2790: 1a0000b5 bne 2a6c <rtems_bdpart_write+0x35c>
return sc;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
2794: e3580000 cmp r8, #0
2798: 0a000005 beq 27b4 <rtems_bdpart_write+0xa4>
disk_end -= (disk_end % record_space);
279c: e59d6014 ldr r6, [sp, #20]
27a0: e1a0100b mov r1, fp
27a4: e1a00006 mov r0, r6
27a8: eb0073e1 bl 1f734 <__umodsi3>
27ac: e0600006 rsb r0, r0, r6
27b0: e58d0014 str r0, [sp, #20]
/* 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) {
27b4: e59d1014 ldr r1, [sp, #20]
27b8: e1a06005 mov r6, r5
27bc: e1a03005 mov r3, r5
if (dos_compatibility) {
disk_end -= (disk_end % record_space);
}
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
27c0: e3a07000 mov r7, #0
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) {
27c4: e5932000 ldr r2, [r3]
27c8: e1520001 cmp r2, r1
27cc: 2a000098 bcs 2a34 <rtems_bdpart_write+0x324>
27d0: e5930004 ldr r0, [r3, #4]
27d4: e1500001 cmp r0, r1
27d8: 8a000095 bhi 2a34 <rtems_bdpart_write+0x324>
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that begin and end are valid */
if (p->begin >= p->end) {
27dc: e1520000 cmp r2, r0
27e0: 2a000093 bcs 2a34 <rtems_bdpart_write+0x324>
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that partitions do not overlap */
if (i > 0 && pt [i - 1].end > p->begin) {
27e4: e3570000 cmp r7, #0
27e8: 0a000002 beq 27f8 <rtems_bdpart_write+0xe8>
27ec: e513002c ldr r0, [r3, #-44] ; 0x2c
27f0: e1500002 cmp r0, r2
27f4: 8a00008e bhi 2a34 <rtems_bdpart_write+0x324>
if (dos_compatibility) {
disk_end -= (disk_end % record_space);
}
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
27f8: e2877001 add r7, r7, #1
27fc: e157000a cmp r7, sl
2800: e2833030 add r3, r3, #48 ; 0x30
2804: 1affffee bne 27c4 <rtems_bdpart_write+0xb4>
goto cleanup;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
2808: e5943000 ldr r3, [r4]
280c: e3530000 cmp r3, #0
esc = RTEMS_NOT_IMPLEMENTED;
2810: 13a04018 movne r4, #24
goto cleanup;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
2814: 1a00008d bne 2a50 <rtems_bdpart_write+0x340>
* 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;
2818: e3570004 cmp r7, #4
281c: 83a07003 movhi r7, #3
/*
* 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) {
2820: e3580000 cmp r8, #0
2824: 1a000007 bne 2848 <rtems_bdpart_write+0x138>
* 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) {
2828: e3a03030 mov r3, #48 ; 0x30
282c: e0000793 mul r0, r3, r7
2830: e0851000 add r1, r5, r0
2834: e58d000c str r0, [sp, #12]
2838: e58d1008 str r1, [sp, #8]
283c: e1a02001 mov r2, r1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2840: e1a03007 mov r3, r7
2844: ea00000b b 2878 <rtems_bdpart_write+0x168>
/*
* 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) {
2848: e5953000 ldr r3, [r5]
284c: e353003f cmp r3, #63 ; 0x3f
2850: 1a000077 bne 2a34 <rtems_bdpart_write+0x324>
2854: eafffff3 b 2828 <rtems_bdpart_write+0x118>
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2858: e1a01002 mov r1, r2
* 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) {
285c: e5910000 ldr r0, [r1]
2860: e511102c ldr r1, [r1, #-44] ; 0x2c
2864: e0611000 rsb r1, r1, r0
2868: e151000b cmp r1, fp
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
286c: e2822030 add r2, r2, #48 ; 0x30
* 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) {
2870: 3a00006f bcc 2a34 <rtems_bdpart_write+0x324>
* 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) {
2874: e2833001 add r3, r3, #1
2878: e153000a cmp r3, sl
287c: 3afffff5 bcc 2858 <rtems_bdpart_write+0x148>
2880: e3a09000 mov r9, #0
2884: e1a08005 mov r8, r5
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
uint8_t type = 0;
2888: e1a0c009 mov ip, r9
const rtems_bdpart_partition *p = pt + i;
/* Check type */
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
288c: e2880008 add r0, r8, #8
2890: e28d1023 add r1, sp, #35 ; 0x23
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
uint8_t type = 0;
2894: e5cdc023 strb ip, [sp, #35] ; 0x23
const rtems_bdpart_partition *p = pt + i;
/* Check type */
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
2898: e58dc004 str ip, [sp, #4]
289c: ebfffe21 bl 2128 <rtems_bdpart_to_mbr_partition_type>
28a0: e3500000 cmp r0, #0
28a4: e59dc004 ldr ip, [sp, #4]
28a8: 0a000063 beq 2a3c <rtems_bdpart_write+0x32c>
28ac: e2888030 add r8, r8, #48 ; 0x30
esc = RTEMS_INVALID_ID;
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
28b0: e918000c ldmdb r8, {r2, r3}
28b4: e3a000ff mov r0, #255 ; 0xff
28b8: e3a01000 mov r1, #0
28bc: e1510003 cmp r1, r3
28c0: 01500002 cmpeq r0, r2
28c4: 3a00005c bcc 2a3c <rtems_bdpart_write+0x32c>
goto cleanup;
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
28c8: e2899001 add r9, r9, #1
28cc: e159000a cmp r9, sl
28d0: 1affffed bne 288c <rtems_bdpart_write+0x17c>
/* Check ID */
/* TODO */
}
/* New MBR */
sc = rtems_bdpart_new_record( dd, 0, &block);
28d4: e59d001c ldr r0, [sp, #28]
28d8: e3a01000 mov r1, #0
28dc: e28d2010 add r2, sp, #16
28e0: ebffff68 bl 2688 <rtems_bdpart_new_record>
if (sc != RTEMS_SUCCESSFUL) {
28e4: e3500000 cmp r0, #0
28e8: 1a000057 bne 2a4c <rtems_bdpart_write+0x33c>
}
/* Write disk ID */
rtems_uint32_to_little_endian(
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
28ec: e59d3010 ldr r3, [sp, #16]
esc = sc;
goto cleanup;
}
/* Write disk ID */
rtems_uint32_to_little_endian(
28f0: e593301c ldr r3, [r3, #28]
28f4: e5942004 ldr r2, [r4, #4]
28f8: e1a04000 mov r4, r0
28fc: e2844001 add r4, r4, #1
2900: e3540004 cmp r4, #4
data [i] = (uint8_t) value;
2904: e5c321b8 strb r2, [r3, #440] ; 0x1b8
value >>= 8;
2908: e1a02422 lsr r2, r2, #8
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
290c: e2833001 add r3, r3, #1
2910: 1afffff9 bne 28fc <rtems_bdpart_write+0x1ec>
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;
2914: e59d3010 ldr r3, [sp, #16]
2918: e593901c ldr r9, [r3, #28]
291c: e2899f6f add r9, r9, #444 ; 0x1bc
2920: e2899002 add r9, r9, #2
2924: e1a04009 mov r4, r9
for (i = 0; i < ppc; ++i) {
2928: e3a08000 mov r8, #0
292c: ea000009 b 2958 <rtems_bdpart_write+0x248>
const rtems_bdpart_partition *p = pt + i;
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
2930: e8960006 ldm r6, {r1, r2}
2934: e5d60028 ldrb r0, [r6, #40] ; 0x28
2938: e5d63008 ldrb r3, [r6, #8]
293c: e0612002 rsb r2, r1, r2
2940: e58d0000 str r0, [sp]
2944: e1a00004 mov r0, r4
2948: ebffff39 bl 2634 <rtems_bdpart_write_mbr_partition>
p->end - p->begin,
rtems_bdpart_mbr_partition_type( p->type),
(uint8_t) p->flags
);
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
294c: e2844010 add r4, r4, #16
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) {
2950: e2888001 add r8, r8, #1
2954: e2866030 add r6, r6, #48 ; 0x30
2958: e1580007 cmp r8, r7
295c: 1afffff3 bne 2930 <rtems_bdpart_write+0x220>
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
}
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
2960: e157000a cmp r7, sl
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) {
2964: e0890207 add r0, r9, r7, lsl #4
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
}
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
2968: 0a000035 beq 2a44 <rtems_bdpart_write+0x334>
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
/* Begin of extended partition */
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
296c: e59d100c ldr r1, [sp, #12]
2970: e7956001 ldr r6, [r5, r1]
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
2974: e59d2014 ldr r2, [sp, #20]
/* 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;
2978: e06b6006 rsb r6, fp, r6
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
297c: e3a08000 mov r8, #0
2980: e1a01006 mov r1, r6
2984: e0662002 rsb r2, r6, r2
2988: e3a03005 mov r3, #5
298c: e58d8000 str r8, [sp]
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
2990: e1a05007 mov r5, r7
/* Begin of extended partition */
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
2994: ebffff26 bl 2634 <rtems_bdpart_write_mbr_partition>
2998: e59d4008 ldr r4, [sp, #8]
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
299c: ea000021 b 2a28 <rtems_bdpart_write+0x318>
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
29a0: e1550007 cmp r5, r7
29a4: 9a00000b bls 29d8 <rtems_bdpart_write+0x2c8>
rtems_blkdev_bnum begin = p->begin - record_space;
rtems_bdpart_write_mbr_partition(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,
29a8: e59d2010 ldr r2, [sp, #16]
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;
29ac: e5943000 ldr r3, [r4]
rtems_bdpart_write_mbr_partition(
29b0: e592001c ldr r0, [r2, #28]
29b4: e59d2014 ldr r2, [sp, #20]
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;
29b8: e06b3003 rsb r3, fp, r3
rtems_bdpart_write_mbr_partition(
29bc: e2800f73 add r0, r0, #460 ; 0x1cc
29c0: e0661003 rsb r1, r6, r3
29c4: e0632002 rsb r2, r3, r2
29c8: e2800002 add r0, r0, #2
29cc: e3a03005 mov r3, #5
29d0: e58d8000 str r8, [sp]
29d4: ebffff16 bl 2634 <rtems_bdpart_write_mbr_partition>
0
);
}
/* New EBR */
ebr = p->begin - record_space;
29d8: e5941000 ldr r1, [r4]
sc = rtems_bdpart_new_record( dd, ebr, &block);
29dc: e59d001c ldr r0, [sp, #28]
29e0: e06b1001 rsb r1, fp, r1
29e4: e28d2010 add r2, sp, #16
29e8: ebffff26 bl 2688 <rtems_bdpart_new_record>
if (sc != RTEMS_SUCCESSFUL) {
29ec: e3500000 cmp r0, #0
29f0: 1a000015 bne 2a4c <rtems_bdpart_write+0x33c>
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
29f4: e59d3010 ldr r3, [sp, #16]
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
29f8: e593001c ldr r0, [r3, #28]
29fc: e5d41028 ldrb r1, [r4, #40] ; 0x28
2a00: e2800f6f add r0, r0, #444 ; 0x1bc
2a04: e894000c ldm r4, {r2, r3}
2a08: e0432002 sub r2, r3, r2
2a0c: e2800002 add r0, r0, #2
2a10: e5d43008 ldrb r3, [r4, #8]
2a14: e58d1000 str r1, [sp]
2a18: e1a0100b mov r1, fp
2a1c: ebffff04 bl 2634 <rtems_bdpart_write_mbr_partition>
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
2a20: e2855001 add r5, r5, #1
2a24: e2844030 add r4, r4, #48 ; 0x30
2a28: e155000a cmp r5, sl
2a2c: 3affffdb bcc 29a0 <rtems_bdpart_write+0x290>
2a30: ea000003 b 2a44 <rtems_bdpart_write+0x334>
* 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) {
esc = RTEMS_INVALID_NUMBER;
2a34: e3a0400a mov r4, #10 <== NOT EXECUTED
2a38: ea000004 b 2a50 <rtems_bdpart_write+0x340> <== NOT EXECUTED
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
esc = RTEMS_INVALID_ID;
2a3c: e3a04004 mov r4, #4 <== NOT EXECUTED
2a40: ea000002 b 2a50 <rtems_bdpart_write+0x340> <== NOT EXECUTED
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
2a44: e3a04000 mov r4, #0
2a48: ea000000 b 2a50 <rtems_bdpart_write+0x340>
);
}
/* New EBR */
ebr = p->begin - record_space;
sc = rtems_bdpart_new_record( dd, ebr, &block);
2a4c: e1a04000 mov r4, r0 <== NOT EXECUTED
}
}
cleanup:
if (fd >= 0) {
2a50: e59d0018 ldr r0, [sp, #24]
2a54: e3500000 cmp r0, #0
close( fd);
2a58: ab0005d3 blge 41ac <close>
}
if (block != NULL) {
2a5c: e59d0010 ldr r0, [sp, #16]
2a60: e3500000 cmp r0, #0
rtems_bdbuf_sync( block);
2a64: 1b002d8a blne e094 <rtems_bdbuf_sync>
}
return esc;
2a68: e1a00004 mov r0, r4
}
2a6c: e28dd024 add sp, sp, #36 ; 0x24
2a70: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000d33c <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;
d33c: e5923000 ldr r3, [r2]
rtems_device_driver
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
d340: e92d4ff7 push {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}
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;
d344: e593902c ldr r9, [r3, #44] ; 0x2c
rtems_device_driver
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
d348: e1a04002 mov r4, r2
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;
d34c: e5997024 ldr r7, [r9, #36] ; 0x24
char *buf = args->buffer;
d350: e592b00c ldr fp, [r2, #12]
uint32_t count = args->count;
d354: e5925010 ldr r5, [r2, #16]
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
d358: e992000c ldmib r2, {r2, r3}
d35c: e3a08000 mov r8, #0
d360: e88d000c stm sp, {r2, r3}
d364: e1a00002 mov r0, r2
d368: e1a01003 mov r1, r3
d36c: e1a02007 mov r2, r7
d370: e1a03008 mov r3, r8
d374: eb003768 bl 1b11c <__divdi3>
uint32_t blkofs = (uint32_t) (args->offset % block_size);
d378: e1a02007 mov r2, r7
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);
d37c: e1a06000 mov r6, r0
uint32_t blkofs = (uint32_t) (args->offset % block_size);
d380: e1a03008 mov r3, r8
d384: e89d0003 ldm sp, {r0, r1}
d388: eb00389e bl 1b608 <__moddi3>
args->bytes_moved = 0;
d38c: e5848018 str r8, [r4, #24]
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);
d390: e1a0a000 mov sl, r0
args->bytes_moved = 0;
while (count > 0)
d394: ea00001e b d414 <rtems_blkdev_generic_write+0xd8>
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
d398: e1550007 cmp r5, r7
d39c: 235a0000 cmpcs sl, #0
rc = rtems_bdbuf_get(dd, block, &diskbuf);
d3a0: e1a00009 mov r0, r9
d3a4: e1a01006 mov r1, r6
d3a8: e28d2008 add r2, sp, #8
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
d3ac: 1a000001 bne d3b8 <rtems_blkdev_generic_write+0x7c>
rc = rtems_bdbuf_get(dd, block, &diskbuf);
d3b0: ebfffd56 bl c910 <rtems_bdbuf_get>
d3b4: ea000000 b d3bc <rtems_blkdev_generic_write+0x80>
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
d3b8: ebfffd85 bl c9d4 <rtems_bdbuf_read> <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
d3bc: e3500000 cmp r0, #0
d3c0: 1a000016 bne d420 <rtems_blkdev_generic_write+0xe4>
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
d3c4: e59d3008 ldr r3, [sp, #8]
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
d3c8: e06a8007 rsb r8, sl, r7
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
d3cc: e593001c ldr r0, [r3, #28]
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
d3d0: e1580005 cmp r8, r5
d3d4: 21a08005 movcs r8, r5
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
d3d8: e1a0100b mov r1, fp
d3dc: e1a02008 mov r2, r8
d3e0: e080000a add r0, r0, sl
d3e4: eb0012dd bl 11f60 <memcpy>
args->bytes_moved += copy;
d3e8: e5943018 ldr r3, [r4, #24]
d3ec: e0833008 add r3, r3, r8
d3f0: e5843018 str r3, [r4, #24]
rc = rtems_bdbuf_release_modified(diskbuf);
d3f4: e59d0008 ldr r0, [sp, #8]
d3f8: ebfffe18 bl cc60 <rtems_bdbuf_release_modified>
if (rc != RTEMS_SUCCESSFUL)
d3fc: e3500000 cmp r0, #0
d400: 1a000006 bne d420 <rtems_blkdev_generic_write+0xe4>
break;
count -= copy;
d404: e0685005 rsb r5, r8, r5
buf += copy;
d408: e08bb008 add fp, fp, r8
blkofs = 0;
block++;
d40c: e2866001 add r6, r6, #1
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
blkofs = 0;
d410: e1a0a000 mov sl, r0
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
args->bytes_moved = 0;
while (count > 0)
d414: e3550000 cmp r5, #0
d418: 1affffde bne d398 <rtems_blkdev_generic_write+0x5c>
d41c: e1a00005 mov r0, r5
blkofs = 0;
block++;
}
return rc;
}
d420: e8bd8ffe pop {r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000260c <rtems_blkdev_imfs_fsync_or_fdatasync>:
}
static int rtems_blkdev_imfs_fsync_or_fdatasync(
rtems_libio_t *iop
)
{
260c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
static inline void *IMFS_generic_get_context_by_node(
const IMFS_jnode_t *node
)
{
return node->info.generic.context;
2610: e5903018 ldr r3, [r0, #24]
int rv = 0; rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop); rtems_disk_device *dd = &ctx->dd; rtems_status_code sc = rtems_bdbuf_syncdev(dd);
2614: e5930050 ldr r0, [r3, #80] ; 0x50
2618: eb002ca0 bl d8a0 <rtems_bdbuf_syncdev>
if (sc != RTEMS_SUCCESSFUL) {
261c: e3500000 cmp r0, #0
2620: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
errno = EIO;
2624: eb003d86 bl 11c44 <__errno> <== NOT EXECUTED
2628: e3a03005 mov r3, #5 <== NOT EXECUTED
262c: e5803000 str r3, [r0] <== NOT EXECUTED
2630: e3e00000 mvn r0, #0 <== NOT EXECUTED
rv = -1;
}
return rv;
}
2634: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00002638 <rtems_blkdev_imfs_ioctl>:
void *buffer
)
{
int rv = 0;
if (request != RTEMS_BLKIO_REQUEST) {
2638: e59f3034 ldr r3, [pc, #52] ; 2674 <rtems_blkdev_imfs_ioctl+0x3c>
263c: e1510003 cmp r1, r3
static int rtems_blkdev_imfs_ioctl(
rtems_libio_t *iop,
uint32_t request,
void *buffer
)
{
2640: e52de004 push {lr} ; (str lr, [sp, #-4]!)
int rv = 0;
if (request != RTEMS_BLKIO_REQUEST) {
2644: 0a000005 beq 2660 <rtems_blkdev_imfs_ioctl+0x28>
2648: e5903018 ldr r3, [r0, #24]
264c: e5933050 ldr r3, [r3, #80] ; 0x50
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
rv = (*dd->ioctl)(dd, request, buffer);
2650: e1a00003 mov r0, r3
2654: e1a0e00f mov lr, pc
2658: e593f038 ldr pc, [r3, #56] ; 0x38
265c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
} else {
/*
* It is not allowed to directly access the driver circumventing the cache.
*/
errno = EINVAL;
2660: eb003d77 bl 11c44 <__errno> <== NOT EXECUTED
2664: e3a03016 mov r3, #22 <== NOT EXECUTED
2668: e5803000 str r3, [r0] <== NOT EXECUTED
266c: e3e00000 mvn r0, #0 <== NOT EXECUTED
rv = -1;
}
return rv;
}
2670: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00002490 <rtems_blkdev_imfs_read>:
static ssize_t rtems_blkdev_imfs_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
2490: e92d4fff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, lr}
2494: e5903018 ldr r3, [r0, #24]
2498: e593b050 ldr fp, [r3, #80] ; 0x50
int rv; rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop); rtems_disk_device *dd = &ctx->dd; ssize_t remaining = (ssize_t) count; off_t offset = iop->offset;
249c: e9900018 ldmib r0, {r3, r4}
24a0: e88d0018 stm sp, {r3, r4}
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
24a4: e59b4024 ldr r4, [fp, #36] ; 0x24
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
24a8: e1a05fc4 asr r5, r4, #31
24ac: e1a03005 mov r3, r5
static ssize_t rtems_blkdev_imfs_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
24b0: e1a0a001 mov sl, r1
24b4: e1a09002 mov r9, r2
24b8: e1a06000 mov r6, r0
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop); rtems_disk_device *dd = &ctx->dd; ssize_t remaining = (ssize_t) count; off_t offset = iop->offset; ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd); rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
24bc: e1a02004 mov r2, r4
24c0: e89d0003 ldm sp, {r0, r1}
int rv; rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop); rtems_disk_device *dd = &ctx->dd; ssize_t remaining = (ssize_t) count; off_t offset = iop->offset; ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
24c4: e58d4008 str r4, [sp, #8]
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
24c8: eb0064d4 bl 1b820 <__divdi3>
ssize_t block_offset = (ssize_t) (offset % block_size);
24cc: e1a02004 mov r2, r4
24d0: e1a03005 mov r3, r5
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop); rtems_disk_device *dd = &ctx->dd; ssize_t remaining = (ssize_t) count; off_t offset = iop->offset; ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd); rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
24d4: e1a07000 mov r7, r0
ssize_t block_offset = (ssize_t) (offset % block_size);
24d8: e89d0003 ldm sp, {r0, r1}
24dc: eb00660a bl 1bd0c <__moddi3>
char *dst = buffer;
24e0: e1a0500a mov r5, sl
rtems_disk_device *dd = &ctx->dd; ssize_t remaining = (ssize_t) count; off_t offset = iop->offset; ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd); rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size); ssize_t block_offset = (ssize_t) (offset % block_size);
24e4: e1a08000 mov r8, r0
)
{
int rv;
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
24e8: e1a04009 mov r4, r9
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
ssize_t block_offset = (ssize_t) (offset % block_size);
char *dst = buffer;
while (remaining > 0) {
24ec: ea000019 b 2558 <rtems_blkdev_imfs_read+0xc8>
rtems_bdbuf_buffer *bd;
rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);
24f0: e1a0000b mov r0, fp
24f4: e1a01007 mov r1, r7
24f8: e28d200c add r2, sp, #12
24fc: eb002be1 bl d488 <rtems_bdbuf_read>
if (sc == RTEMS_SUCCESSFUL) {
2500: e3500000 cmp r0, #0
2504: 1a00001c bne 257c <rtems_blkdev_imfs_read+0xec>
ssize_t copy = block_size - block_offset;
2508: e59d3008 ldr r3, [sp, #8]
250c: e068a003 rsb sl, r8, r3
if (copy > remaining) {
copy = remaining;
}
memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
2510: e59d300c ldr r3, [sp, #12]
2514: e593101c ldr r1, [r3, #28]
while (remaining > 0) {
rtems_bdbuf_buffer *bd;
rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);
if (sc == RTEMS_SUCCESSFUL) {
ssize_t copy = block_size - block_offset;
2518: e15a0004 cmp sl, r4
251c: a1a0a004 movge sl, r4
if (copy > remaining) {
copy = remaining;
}
memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
2520: e0811008 add r1, r1, r8
2524: e1a0200a mov r2, sl
2528: e1a00005 mov r0, r5
252c: eb00402b bl 125e0 <memcpy>
sc = rtems_bdbuf_release(bd);
2530: e59d000c ldr r0, [sp, #12]
2534: eb002c48 bl d65c <rtems_bdbuf_release>
if (sc == RTEMS_SUCCESSFUL) {
2538: e2508000 subs r8, r0, #0
block_offset = 0;
remaining -= copy;
253c: 006a4004 rsbeq r4, sl, r4
dst += copy;
2540: 0085500a addeq r5, r5, sl
++block;
2544: 02877001 addeq r7, r7, #1
2548: 0a000002 beq 2558 <rtems_blkdev_imfs_read+0xc8>
} else {
remaining = -1;
254c: e3e04000 mvn r4, #0 <== NOT EXECUTED
2550: e3540000 cmp r4, #0 <== NOT EXECUTED
2554: ea000001 b 2560 <rtems_blkdev_imfs_read+0xd0> <== NOT EXECUTED
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
ssize_t block_offset = (ssize_t) (offset % block_size);
char *dst = buffer;
while (remaining > 0) {
2558: e3540000 cmp r4, #0
255c: caffffe3 bgt 24f0 <rtems_blkdev_imfs_read+0x60>
} else {
remaining = -1;
}
}
if (remaining >= 0) {
2560: 1a000005 bne 257c <rtems_blkdev_imfs_read+0xec>
iop->offset += count;
2564: e996000c ldmib r6, {r2, r3}
2568: e0922009 adds r2, r2, r9
256c: e2a33000 adc r3, r3, #0
2570: e986000c stmib r6, {r2, r3}
rv = (ssize_t) count;
2574: e1a00009 mov r0, r9
2578: ea000003 b 258c <rtems_blkdev_imfs_read+0xfc>
} else {
errno = EIO;
257c: eb003db0 bl 11c44 <__errno> <== NOT EXECUTED
2580: e3a03005 mov r3, #5 <== NOT EXECUTED
2584: e5803000 str r3, [r0] <== NOT EXECUTED
rv = -1;
2588: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return rv;
}
258c: e28dd010 add sp, sp, #16
2590: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000235c <rtems_blkdev_imfs_write>:
static ssize_t rtems_blkdev_imfs_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
235c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
2360: e5903018 ldr r3, [r0, #24]
2364: e593b050 ldr fp, [r3, #80] ; 0x50
int rv; rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop); rtems_disk_device *dd = &ctx->dd; ssize_t remaining = (ssize_t) count; off_t offset = iop->offset;
2368: e9900018 ldmib r0, {r3, r4}
static ssize_t rtems_blkdev_imfs_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
236c: e24dd014 sub sp, sp, #20
int rv; rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop); rtems_disk_device *dd = &ctx->dd; ssize_t remaining = (ssize_t) count; off_t offset = iop->offset;
2370: e58d3008 str r3, [sp, #8]
2374: e58d400c str r4, [sp, #12]
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
2378: e59b4024 ldr r4, [fp, #36] ; 0x24
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
237c: e1a05fc4 asr r5, r4, #31
2380: e1a03005 mov r3, r5
static ssize_t rtems_blkdev_imfs_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
2384: e58d2004 str r2, [sp, #4]
2388: e1a06000 mov r6, r0
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop); rtems_disk_device *dd = &ctx->dd; ssize_t remaining = (ssize_t) count; off_t offset = iop->offset; ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd); rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
238c: e1a02004 mov r2, r4
static ssize_t rtems_blkdev_imfs_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
2390: e1a07001 mov r7, r1
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop); rtems_disk_device *dd = &ctx->dd; ssize_t remaining = (ssize_t) count; off_t offset = iop->offset; ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd); rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
2394: e28d1008 add r1, sp, #8
2398: e8910003 ldm r1, {r0, r1}
int rv; rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop); rtems_disk_device *dd = &ctx->dd; ssize_t remaining = (ssize_t) count; off_t offset = iop->offset; ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
239c: e58d4000 str r4, [sp]
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
23a0: eb00651e bl 1b820 <__divdi3>
ssize_t block_offset = (ssize_t) (offset % block_size);
23a4: e1a02004 mov r2, r4
23a8: e1a03005 mov r3, r5
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop); rtems_disk_device *dd = &ctx->dd; ssize_t remaining = (ssize_t) count; off_t offset = iop->offset; ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd); rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
23ac: e1a09000 mov r9, r0
ssize_t block_offset = (ssize_t) (offset % block_size);
23b0: e28d1008 add r1, sp, #8
23b4: e8910003 ldm r1, {r0, r1}
23b8: eb006653 bl 1bd0c <__moddi3>
)
{
int rv;
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
23bc: e59d4004 ldr r4, [sp, #4]
off_t offset = iop->offset; ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd); rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size); ssize_t block_offset = (ssize_t) (offset % block_size);
23c0: e1a05000 mov r5, r0
const char *src = buffer;
while (remaining > 0) {
23c4: ea000021 b 2450 <bsp_section_bss_size+0x5c>
rtems_status_code sc;
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
23c8: e59d1000 ldr r1, [sp]
23cc: e1540001 cmp r4, r1
23d0: a3550000 cmpge r5, #0
sc = rtems_bdbuf_get(dd, block, &bd);
23d4: e1a0000b mov r0, fp
23d8: e1a01009 mov r1, r9
23dc: e28d2010 add r2, sp, #16
while (remaining > 0) {
rtems_status_code sc;
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
23e0: 1a000001 bne 23ec <rtems_blkdev_imfs_write+0x90>
sc = rtems_bdbuf_get(dd, block, &bd);
23e4: eb002bf6 bl d3c4 <rtems_bdbuf_get>
23e8: ea000000 b 23f0 <rtems_blkdev_imfs_write+0x94>
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
23ec: eb002c25 bl d488 <rtems_bdbuf_read>
}
if (sc == RTEMS_SUCCESSFUL) {
23f0: e3500000 cmp r0, #0
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
sc = rtems_bdbuf_get(dd, block, &bd);
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
23f4: e1a08000 mov r8, r0
}
if (sc == RTEMS_SUCCESSFUL) {
23f8: 1a00001e bne 2478 <bsp_section_bss_size+0x84>
ssize_t copy = block_size - block_offset;
23fc: e59d3000 ldr r3, [sp]
2400: e065a003 rsb sl, r5, r3
if (copy > remaining) {
copy = remaining;
}
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
2404: e59d3010 ldr r3, [sp, #16]
2408: e593001c ldr r0, [r3, #28]
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
}
if (sc == RTEMS_SUCCESSFUL) {
ssize_t copy = block_size - block_offset;
240c: e15a0004 cmp sl, r4
2410: a1a0a004 movge sl, r4
if (copy > remaining) {
copy = remaining;
}
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
2414: e1a01007 mov r1, r7
2418: e1a0200a mov r2, sl
241c: e0800005 add r0, r0, r5
2420: eb00406e bl 125e0 <memcpy>
sc = rtems_bdbuf_release_modified(bd);
2424: e59d0010 ldr r0, [sp, #16]
2428: eb002cb9 bl d714 <rtems_bdbuf_release_modified>
if (sc == RTEMS_SUCCESSFUL) {
242c: e3500000 cmp r0, #0
block_offset = 0;
remaining -= copy;
2430: 006a4004 rsbeq r4, sl, r4
src += copy;
2434: 0087700a addeq r7, r7, sl
++block;
2438: 02899001 addeq r9, r9, #1
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
sc = rtems_bdbuf_release_modified(bd);
if (sc == RTEMS_SUCCESSFUL) {
block_offset = 0;
243c: 01a05008 moveq r5, r8
2440: 0a000002 beq 2450 <bsp_section_bss_size+0x5c>
remaining -= copy;
src += copy;
++block;
} else {
remaining = -1;
2444: e3e04000 mvn r4, #0 <== NOT EXECUTED
2448: e3540000 cmp r4, #0 <== NOT EXECUTED
244c: ea000001 b 2458 <bsp_section_bss_size+0x64> <== NOT EXECUTED
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
ssize_t block_offset = (ssize_t) (offset % block_size);
const char *src = buffer;
while (remaining > 0) {
2450: e3540000 cmp r4, #0
2454: caffffdb bgt 23c8 <rtems_blkdev_imfs_write+0x6c>
} else {
remaining = -1;
}
}
if (remaining >= 0) {
2458: 1a000006 bne 2478 <bsp_section_bss_size+0x84>
iop->offset += count;
245c: e996000c ldmib r6, {r2, r3}
2460: e59d4004 ldr r4, [sp, #4]
2464: e0922004 adds r2, r2, r4
2468: e2a33000 adc r3, r3, #0
246c: e986000c stmib r6, {r2, r3}
rv = (ssize_t) count;
2470: e1a00004 mov r0, r4
2474: ea000003 b 2488 <bsp_section_bss_size+0x94>
} else {
errno = EIO;
2478: eb003df1 bl 11c44 <__errno> <== NOT EXECUTED
247c: e3a03005 mov r3, #5 <== NOT EXECUTED
2480: e5803000 str r3, [r0] <== NOT EXECUTED
rv = -1;
2484: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return rv;
}
2488: e28dd014 add sp, sp, #20
248c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000d138 <rtems_blkdev_ioctl>:
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
d138: e59fc108 ldr ip, [pc, #264] ; d248 <rtems_blkdev_ioctl+0x110>
d13c: e151000c cmp r1, ip
#include <rtems/blkdev.h>
#include <rtems/bdbuf.h>
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
d140: e52de004 push {lr} ; (str lr, [sp, #-4]!)
d144: e1a03000 mov r3, r0
rtems_status_code sc;
int rc = 0;
switch (req)
d148: 0a000020 beq d1d0 <rtems_blkdev_ioctl+0x98>
d14c: 8a00000e bhi d18c <rtems_blkdev_ioctl+0x54>
d150: e59fc0f4 ldr ip, [pc, #244] ; d24c <rtems_blkdev_ioctl+0x114>
d154: e151000c cmp r1, ip
d158: 0a00002d beq d214 <rtems_blkdev_ioctl+0xdc>
d15c: 8a000003 bhi d170 <rtems_blkdev_ioctl+0x38>
d160: e59f30e8 ldr r3, [pc, #232] ; d250 <rtems_blkdev_ioctl+0x118>
d164: e1510003 cmp r1, r3
d168: 1a000031 bne d234 <rtems_blkdev_ioctl+0xfc>
d16c: ea000020 b d1f4 <rtems_blkdev_ioctl+0xbc>
d170: e59fc0dc ldr ip, [pc, #220] ; d254 <rtems_blkdev_ioctl+0x11c>
d174: e151000c cmp r1, ip
d178: 0a00002a beq d228 <rtems_blkdev_ioctl+0xf0>
d17c: e59f00d4 ldr r0, [pc, #212] ; d258 <rtems_blkdev_ioctl+0x120>
d180: e1510000 cmp r1, r0
d184: 1a00002a bne d234 <rtems_blkdev_ioctl+0xfc>
d188: ea00000e b d1c8 <rtems_blkdev_ioctl+0x90>
d18c: e59fc0c8 ldr ip, [pc, #200] ; d25c <rtems_blkdev_ioctl+0x124>
d190: e151000c cmp r1, ip
d194: 0a00000e beq d1d4 <rtems_blkdev_ioctl+0x9c>
d198: 8a000003 bhi d1ac <rtems_blkdev_ioctl+0x74>
d19c: e59f00bc ldr r0, [pc, #188] ; d260 <rtems_blkdev_ioctl+0x128>
d1a0: e1510000 cmp r1, r0
d1a4: 1a000022 bne d234 <rtems_blkdev_ioctl+0xfc>
d1a8: ea00000f b d1ec <rtems_blkdev_ioctl+0xb4>
d1ac: e59f30b0 ldr r3, [pc, #176] ; d264 <rtems_blkdev_ioctl+0x12c>
d1b0: e1510003 cmp r1, r3
d1b4: 0a000018 beq d21c <rtems_blkdev_ioctl+0xe4>
d1b8: e243311f sub r3, r3, #-1073741817 ; 0xc0000007
d1bc: e1510003 cmp r1, r3
d1c0: 1a00001b bne d234 <rtems_blkdev_ioctl+0xfc>
d1c4: ea000004 b d1dc <rtems_blkdev_ioctl+0xa4>
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
d1c8: e5933020 ldr r3, [r3, #32]
d1cc: ea000000 b d1d4 <rtems_blkdev_ioctl+0x9c>
break;
case RTEMS_BLKIO_GETBLKSIZE:
*(uint32_t *) argp = dd->block_size;
d1d0: e5903024 ldr r3, [r0, #36] ; 0x24
d1d4: e5823000 str r3, [r2]
d1d8: ea000013 b d22c <rtems_blkdev_ioctl+0xf4>
break;
case RTEMS_BLKIO_SETBLKSIZE:
sc = rtems_bdbuf_set_block_size(dd, *(uint32_t *) argp, true);
d1dc: e5921000 ldr r1, [r2]
d1e0: e3a02001 mov r2, #1
d1e4: ebffff85 bl d000 <rtems_bdbuf_set_block_size>
d1e8: ea000002 b d1f8 <rtems_blkdev_ioctl+0xc0>
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
d1ec: e593301c ldr r3, [r3, #28]
d1f0: eafffff7 b d1d4 <rtems_blkdev_ioctl+0x9c>
break;
case RTEMS_BLKIO_SYNCDEV:
sc = rtems_bdbuf_syncdev(dd);
d1f4: ebfffefc bl cdec <rtems_bdbuf_syncdev>
if (sc != RTEMS_SUCCESSFUL) {
d1f8: e3500000 cmp r0, #0
d1fc: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
errno = EIO;
d200: eb00111c bl 11678 <__errno> <== NOT EXECUTED
d204: e3a03005 mov r3, #5 <== NOT EXECUTED
d208: e5803000 str r3, [r0] <== NOT EXECUTED
rc = -1;
d20c: e3e00000 mvn r0, #0 <== NOT EXECUTED
d210: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case RTEMS_BLKIO_GETDISKDEV:
*(rtems_disk_device **) argp = dd;
break;
case RTEMS_BLKIO_PURGEDEV:
rtems_bdbuf_purge_dev(dd);
d214: ebffff05 bl ce30 <rtems_bdbuf_purge_dev>
d218: ea000003 b d22c <rtems_blkdev_ioctl+0xf4>
break;
case RTEMS_BLKIO_GETDEVSTATS:
rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
d21c: e1a01002 mov r1, r2
d220: ebffffaf bl d0e4 <rtems_bdbuf_get_device_stats>
d224: ea000000 b d22c <rtems_blkdev_ioctl+0xf4>
break;
case RTEMS_BLKIO_RESETDEVSTATS:
rtems_bdbuf_reset_device_stats(dd);
d228: ebffffb9 bl d114 <rtems_bdbuf_reset_device_stats>
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
d22c: e3a00000 mov r0, #0
rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
break;
case RTEMS_BLKIO_RESETDEVSTATS:
rtems_bdbuf_reset_device_stats(dd);
break;
d230: e49df004 pop {pc} ; (ldr pc, [sp], #4)
default:
errno = EINVAL;
d234: eb00110f bl 11678 <__errno>
d238: e3a03016 mov r3, #22
d23c: e5803000 str r3, [r0]
rc = -1;
d240: e3e00000 mvn r0, #0
break;
}
return rc;
}
d244: e49df004 pop {pc} ; (ldr pc, [sp], #4)
0001ed10 <rtems_blkstats>:
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
void rtems_blkstats(FILE *output, const char *device, bool reset)
{
1ed10: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
1ed14: e1a04000 mov r4, r0 <== NOT EXECUTED
1ed18: e24dd068 sub sp, sp, #104 ; 0x68 <== NOT EXECUTED
int fd = open(device, O_RDONLY);
1ed1c: e1a00001 mov r0, r1 <== NOT EXECUTED 1ed20: e3a01000 mov r1, #0 <== NOT EXECUTED
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
void rtems_blkstats(FILE *output, const char *device, bool reset)
{
1ed24: e20260ff and r6, r2, #255 ; 0xff <== NOT EXECUTED
int fd = open(device, O_RDONLY);
1ed28: ebff9284 bl 3740 <open> <== NOT EXECUTED
if (fd >= 0) {
1ed2c: e2505000 subs r5, r0, #0 <== NOT EXECUTED 1ed30: ba00003c blt 1ee28 <rtems_blkstats+0x118> <== NOT EXECUTED
struct stat st;
int rv;
rv = fstat(fd, &st);
1ed34: e1a0100d mov r1, sp <== NOT EXECUTED 1ed38: eb000628 bl 205e0 <fstat> <== NOT EXECUTED
if (rv == 0) {
1ed3c: e3500000 cmp r0, #0 <== NOT EXECUTED 1ed40: 1a000026 bne 1ede0 <rtems_blkstats+0xd0> <== NOT EXECUTED
if (S_ISBLK(st.st_mode)) {
1ed44: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 1ed48: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED 1ed4c: e3530a06 cmp r3, #24576 ; 0x6000 <== NOT EXECUTED 1ed50: 1a00001e bne 1edd0 <rtems_blkstats+0xc0> <== NOT EXECUTED
if (reset) {
1ed54: e3560000 cmp r6, #0 <== NOT EXECUTED
return ioctl(fd, RTEMS_BLKIO_GETDEVSTATS, stats);
}
static inline int rtems_disk_fd_reset_device_stats(int fd)
{
return ioctl(fd, RTEMS_BLKIO_RESETDEVSTATS);
1ed58: e1a00005 mov r0, r5 <== NOT EXECUTED 1ed5c: 0a00000a beq 1ed8c <rtems_blkstats+0x7c> <== NOT EXECUTED 1ed60: e59f10e4 ldr r1, [pc, #228] ; 1ee4c <rtems_blkstats+0x13c> <== NOT EXECUTED 1ed64: eb0008ab bl 21018 <ioctl> <== NOT EXECUTED
rv = rtems_disk_fd_reset_device_stats(fd);
if (rv != 0) {
1ed68: e3500000 cmp r0, #0 <== NOT EXECUTED 1ed6c: 0a000022 beq 1edfc <rtems_blkstats+0xec> <== NOT EXECUTED
fprintf(output, "error: reset stats: %s\n", strerror(errno));
1ed70: eb004ad5 bl 318cc <__errno> <== NOT EXECUTED 1ed74: e5900000 ldr r0, [r0] <== NOT EXECUTED 1ed78: eb006624 bl 38610 <strerror> <== NOT EXECUTED 1ed7c: e59f10cc ldr r1, [pc, #204] ; 1ee50 <rtems_blkstats+0x140> <== NOT EXECUTED 1ed80: e1a02000 mov r2, r0 <== NOT EXECUTED 1ed84: e1a00004 mov r0, r4 <== NOT EXECUTED 1ed88: ea00001a b 1edf8 <rtems_blkstats+0xe8> <== NOT EXECUTED
static inline int rtems_disk_fd_get_device_stats(
int fd,
rtems_blkdev_stats *stats
)
{
return ioctl(fd, RTEMS_BLKIO_GETDEVSTATS, stats);
1ed8c: e59f10c0 ldr r1, [pc, #192] ; 1ee54 <rtems_blkstats+0x144> <== NOT EXECUTED 1ed90: e28d2048 add r2, sp, #72 ; 0x48 <== NOT EXECUTED 1ed94: eb00089f bl 21018 <ioctl> <== NOT EXECUTED
}
} else {
rtems_blkdev_stats stats;
rv = rtems_disk_fd_get_device_stats(fd, &stats);
if (rv == 0) {
1ed98: e3500000 cmp r0, #0 <== NOT EXECUTED 1ed9c: 1a000004 bne 1edb4 <rtems_blkstats+0xa4> <== NOT EXECUTED
rtems_blkdev_print_stats(
1eda0: e28d0048 add r0, sp, #72 ; 0x48 <== NOT EXECUTED 1eda4: e59f10ac ldr r1, [pc, #172] ; 1ee58 <rtems_blkstats+0x148> <== NOT EXECUTED 1eda8: e1a02004 mov r2, r4 <== NOT EXECUTED 1edac: eb00002f bl 1ee70 <rtems_blkdev_print_stats> <== NOT EXECUTED 1edb0: ea000011 b 1edfc <rtems_blkstats+0xec> <== NOT EXECUTED
&stats,
(rtems_printk_plugin_t) fprintf,
output
);
} else {
fprintf(output, "error: get stats: %s\n", strerror(errno));
1edb4: eb004ac4 bl 318cc <__errno> <== NOT EXECUTED 1edb8: e5900000 ldr r0, [r0] <== NOT EXECUTED 1edbc: eb006613 bl 38610 <strerror> <== NOT EXECUTED 1edc0: e59f1094 ldr r1, [pc, #148] ; 1ee5c <rtems_blkstats+0x14c> <== NOT EXECUTED 1edc4: e1a02000 mov r2, r0 <== NOT EXECUTED 1edc8: e1a00004 mov r0, r4 <== NOT EXECUTED 1edcc: ea000009 b 1edf8 <rtems_blkstats+0xe8> <== NOT EXECUTED
}
}
} else {
fprintf(output, "error: not a block device\n");
1edd0: e1a01004 mov r1, r4 <== NOT EXECUTED 1edd4: e59f0084 ldr r0, [pc, #132] ; 1ee60 <rtems_blkstats+0x150> <== NOT EXECUTED 1edd8: eb004db8 bl 324c0 <fputs> <== NOT EXECUTED 1eddc: ea000006 b 1edfc <rtems_blkstats+0xec> <== NOT EXECUTED
}
} else {
fprintf(output, "error: get file stats: %s\n", strerror(errno));
1ede0: eb004ab9 bl 318cc <__errno> <== NOT EXECUTED 1ede4: e5900000 ldr r0, [r0] <== NOT EXECUTED 1ede8: eb006608 bl 38610 <strerror> <== NOT EXECUTED 1edec: e59f1070 ldr r1, [pc, #112] ; 1ee64 <rtems_blkstats+0x154> <== NOT EXECUTED 1edf0: e1a02000 mov r2, r0 <== NOT EXECUTED 1edf4: e1a00004 mov r0, r4 <== NOT EXECUTED 1edf8: eb004d5b bl 3236c <fprintf> <== NOT EXECUTED
}
rv = close(fd);
1edfc: e1a00005 mov r0, r5 <== NOT EXECUTED 1ee00: eb00057e bl 20400 <close> <== NOT EXECUTED
if (rv != 0) {
1ee04: e3500000 cmp r0, #0 <== NOT EXECUTED 1ee08: 0a00000d beq 1ee44 <rtems_blkstats+0x134> <== NOT EXECUTED
fprintf(output, "error: close device: %s\n", strerror(errno));
1ee0c: eb004aae bl 318cc <__errno> <== NOT EXECUTED 1ee10: e5900000 ldr r0, [r0] <== NOT EXECUTED 1ee14: eb0065fd bl 38610 <strerror> <== NOT EXECUTED 1ee18: e59f1048 ldr r1, [pc, #72] ; 1ee68 <rtems_blkstats+0x158> <== NOT EXECUTED 1ee1c: e1a02000 mov r2, r0 <== NOT EXECUTED 1ee20: e1a00004 mov r0, r4 <== NOT EXECUTED 1ee24: ea000005 b 1ee40 <rtems_blkstats+0x130> <== NOT EXECUTED
}
} else {
fprintf(output, "error: open device: %s\n", strerror(errno));
1ee28: eb004aa7 bl 318cc <__errno> <== NOT EXECUTED 1ee2c: e5900000 ldr r0, [r0] <== NOT EXECUTED 1ee30: eb0065f6 bl 38610 <strerror> <== NOT EXECUTED 1ee34: e59f1030 ldr r1, [pc, #48] ; 1ee6c <rtems_blkstats+0x15c> <== NOT EXECUTED 1ee38: e1a02000 mov r2, r0 <== NOT EXECUTED 1ee3c: e1a00004 mov r0, r4 <== NOT EXECUTED 1ee40: eb004d49 bl 3236c <fprintf> <== NOT EXECUTED
} }
1ee44: e28dd068 add sp, sp, #104 ; 0x68 <== NOT EXECUTED
1ee48: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
000026a4 <rtems_cpu_usage_report_with_plugin>:
*/
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
26a4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
uint32_t seconds, nanoseconds;
#else
uint32_t total_units = 0;
#endif
if ( !print )
26a8: e251a000 subs sl, r1, #0
*/
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
26ac: e24dd048 sub sp, sp, #72 ; 0x48
26b0: e1a0b000 mov fp, r0
uint32_t seconds, nanoseconds;
#else
uint32_t total_units = 0;
#endif
if ( !print )
26b4: 0a000080 beq 28bc <rtems_cpu_usage_report_with_plugin+0x218>
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
26b8: e3a02000 mov r2, #0
26bc: e3a03000 mov r3, #0
26c0: e58d2030 str r2, [sp, #48] ; 0x30
26c4: e58d3034 str r3, [sp, #52] ; 0x34
* 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__
_Timestamp_Set_to_zero( &total );
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
26c8: e59f31f4 ldr r3, [pc, #500] ; 28c4 <rtems_cpu_usage_report_with_plugin+0x220>
26cc: e8930006 ldm r3, {r1, r2}
26d0: e58d1010 str r1, [sp, #16]
26d4: e58d2014 str r2, [sp, #20]
}
}
}
#endif
(*print)(
26d8: e59f11e8 ldr r1, [pc, #488] ; 28c8 <rtems_cpu_usage_report_with_plugin+0x224>
26dc: e1a0e00f mov lr, pc
26e0: e12fff1a bx sl
26e4: e59f81e0 ldr r8, [pc, #480] ; 28cc <rtems_cpu_usage_report_with_plugin+0x228>
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
26e8: e59f91e0 ldr r9, [pc, #480] ; 28d0 <rtems_cpu_usage_report_with_plugin+0x22c>
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
26ec: e5b83004 ldr r3, [r8, #4]!
26f0: e5936004 ldr r6, [r3, #4]
if ( information ) {
26f4: e3560000 cmp r6, #0
26f8: 13a07001 movne r7, #1
26fc: 1a000053 bne 2850 <rtems_cpu_usage_report_with_plugin+0x1ac>
2700: ea000055 b 285c <rtems_cpu_usage_report_with_plugin+0x1b8> <== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
2704: e596301c ldr r3, [r6, #28]
2708: e7934107 ldr r4, [r3, r7, lsl #2]
if ( !the_thread )
270c: e3540000 cmp r4, #0
2710: 0a00004d beq 284c <rtems_cpu_usage_report_with_plugin+0x1a8>
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
2714: e3a0100d mov r1, #13
2718: e28d2018 add r2, sp, #24
271c: e5940008 ldr r0, [r4, #8]
2720: eb00121b bl 6f94 <rtems_object_get_name>
(*print)(
2724: e5942008 ldr r2, [r4, #8]
2728: e28d3018 add r3, sp, #24
272c: e1a0000b mov r0, fp
2730: e59f119c ldr r1, [pc, #412] ; 28d4 <rtems_cpu_usage_report_with_plugin+0x230>
2734: e1a0e00f mov lr, pc
2738: e12fff1a bx sl
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
273c: e2843080 add r3, r4, #128 ; 0x80
2740: e893000c ldm r3, {r2, r3}
2744: e58d2038 str r2, [sp, #56] ; 0x38
2748: e58d303c str r3, [sp, #60] ; 0x3c
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
274c: e5993008 ldr r3, [r9, #8]
2750: e5932008 ldr r2, [r3, #8]
2754: e5943008 ldr r3, [r4, #8]
2758: e1520003 cmp r2, r3
275c: 1a00000f bne 27a0 <rtems_cpu_usage_report_with_plugin+0xfc>
*/
static inline void _TOD_Get_uptime(
Timestamp_Control *time
)
{
_TOD_Get_with_nanoseconds( time, &_TOD.uptime );
2760: e59f1170 ldr r1, [pc, #368] ; 28d8 <rtems_cpu_usage_report_with_plugin+0x234>
2764: e28d0028 add r0, sp, #40 ; 0x28
*time_of_context_switch = _Thread_Time_of_last_context_switch;
2768: e2895014 add r5, r9, #20
276c: e8950030 ldm r5, {r4, r5}
2770: eb0016c3 bl 8284 <_TOD_Get_with_nanoseconds>
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2774: e28d1028 add r1, sp, #40 ; 0x28
2778: e8910003 ldm r1, {r0, r1}
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
277c: e28d3038 add r3, sp, #56 ; 0x38
2780: e893000c ldm r3, {r2, r3}
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2784: e0500004 subs r0, r0, r4
2788: e0c11005 sbc r1, r1, r5
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
278c: e0922000 adds r2, r2, r0
2790: e0a33001 adc r3, r3, r1
2794: e58d2038 str r2, [sp, #56] ; 0x38
2798: e58d303c str r3, [sp, #60] ; 0x3c
279c: ea000002 b 27ac <rtems_cpu_usage_report_with_plugin+0x108>
27a0: e28d0028 add r0, sp, #40 ; 0x28
27a4: e59f112c ldr r1, [pc, #300] ; 28d8 <rtems_cpu_usage_report_with_plugin+0x234>
27a8: eb0016b5 bl 8284 <_TOD_Get_with_nanoseconds>
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
27ac: e28d1010 add r1, sp, #16
27b0: e8910003 ldm r1, {r0, r1}
27b4: e28d3028 add r3, sp, #40 ; 0x28
27b8: e893000c ldm r3, {r2, r3}
27bc: e0522000 subs r2, r2, r0
27c0: e0c33001 sbc r3, r3, r1
27c4: e58d2030 str r2, [sp, #48] ; 0x30
27c8: e58d3034 str r3, [sp, #52] ; 0x34
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
_Timestamp_Divide( &ran, &total, &ival, &fval );
27cc: e28d0038 add r0, sp, #56 ; 0x38
27d0: e28d1030 add r1, sp, #48 ; 0x30
27d4: e28d2040 add r2, sp, #64 ; 0x40
27d8: e28d3044 add r3, sp, #68 ; 0x44
27dc: eb001f82 bl a5ec <_Timestamp64_Divide>
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
27e0: e28d2038 add r2, sp, #56 ; 0x38
27e4: e8920006 ldm r2, {r1, r2}
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
27e8: e3a03000 mov r3, #0
27ec: e58d1008 str r1, [sp, #8]
27f0: e58d200c str r2, [sp, #12]
27f4: e1a00001 mov r0, r1
27f8: e1a01002 mov r1, r2
27fc: e59f20d8 ldr r2, [pc, #216] ; 28dc <rtems_cpu_usage_report_with_plugin+0x238>
2800: eb005a58 bl 19168 <__divdi3>
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
2804: e59f20d0 ldr r2, [pc, #208] ; 28dc <rtems_cpu_usage_report_with_plugin+0x238>
2808: e3a03000 mov r3, #0
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
280c: e1a04000 mov r4, r0
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
2810: e28d1008 add r1, sp, #8
2814: e8910003 ldm r1, {r0, r1}
2818: eb005b8d bl 19654 <__moddi3>
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
281c: e3a01ffa mov r1, #1000 ; 0x3e8
2820: eb00575d bl 1859c <__aeabi_uidiv>
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
2824: e59d2040 ldr r2, [sp, #64] ; 0x40
2828: e58d2000 str r2, [sp]
282c: e59d2044 ldr r2, [sp, #68] ; 0x44
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
2830: e1a03000 mov r3, r0
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
2834: e58d2004 str r2, [sp, #4]
2838: e1a0000b mov r0, fp
283c: e59f109c ldr r1, [pc, #156] ; 28e0 <rtems_cpu_usage_report_with_plugin+0x23c>
2840: e1a02004 mov r2, r4
2844: e1a0e00f mov lr, pc
2848: e12fff1a bx sl
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
284c: e2877001 add r7, r7, #1
2850: e1d631b0 ldrh r3, [r6, #16]
2854: e1570003 cmp r7, r3
2858: 9affffa9 bls 2704 <rtems_cpu_usage_report_with_plugin+0x60>
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
285c: e59f2080 ldr r2, [pc, #128] ; 28e4 <rtems_cpu_usage_report_with_plugin+0x240>
2860: e1580002 cmp r8, r2
2864: 1affffa0 bne 26ec <rtems_cpu_usage_report_with_plugin+0x48>
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
2868: e28d7030 add r7, sp, #48 ; 0x30
286c: e89700c0 ldm r7, {r6, r7}
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
2870: e59f2064 ldr r2, [pc, #100] ; 28dc <rtems_cpu_usage_report_with_plugin+0x238>
2874: e3a03000 mov r3, #0
2878: e1a00006 mov r0, r6
287c: e1a01007 mov r1, r7
2880: eb005a38 bl 19168 <__divdi3>
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
2884: e59f2050 ldr r2, [pc, #80] ; 28dc <rtems_cpu_usage_report_with_plugin+0x238>
2888: e3a03000 mov r3, #0
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
288c: e1a04000 mov r4, r0
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
2890: e1a01007 mov r1, r7
2894: e1a00006 mov r0, r6
2898: eb005b6d bl 19654 <__moddi3>
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
289c: e3a01ffa mov r1, #1000 ; 0x3e8
28a0: eb00573d bl 1859c <__aeabi_uidiv>
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
28a4: e59f103c ldr r1, [pc, #60] ; 28e8 <rtems_cpu_usage_report_with_plugin+0x244>
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
28a8: e1a03000 mov r3, r0
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
28ac: e1a02004 mov r2, r4
28b0: e1a0000b mov r0, fp
28b4: e1a0e00f mov lr, pc
28b8: e12fff1a bx sl
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
28bc: e28dd048 add sp, sp, #72 ; 0x48
28c0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00002518 <rtems_disk_delete>:
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
{
2518: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
251c: e24dd014 sub sp, sp, #20
2520: e1a04000 mov r4, r0
2524: e1a05001 mov r5, r1
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
sc = disk_lock();
2528: ebffff82 bl 2338 <disk_lock>
if (sc != RTEMS_SUCCESSFUL) {
252c: e2508000 subs r8, r0, #0
2530: 1a000059 bne 269c <rtems_disk_delete+0x184>
return sc;
}
dd = get_disk_entry(dev, true);
2534: e1a00004 mov r0, r4
2538: e1a01005 mov r1, r5
253c: e3a02001 mov r2, #1
2540: ebffff48 bl 2268 <get_disk_entry>
if (dd == NULL) {
2544: e2503000 subs r3, r0, #0
2548: 1a000002 bne 2558 <rtems_disk_delete+0x40>
disk_unlock();
254c: ebffff85 bl 2368 <disk_unlock> <== NOT EXECUTED
return RTEMS_INVALID_ID;
2550: e3a08004 mov r8, #4 <== NOT EXECUTED
2554: ea000050 b 269c <rtems_disk_delete+0x184> <== NOT EXECUTED
}
dd->deleted = true;
2558: e3a0b001 mov fp, #1
255c: e5c3b040 strb fp, [r3, #64] ; 0x40
}
static void
rtems_disk_cleanup(rtems_disk_device *disk_to_remove)
{
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
2560: e5934008 ldr r4, [r3, #8]
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
2564: e5d42040 ldrb r2, [r4, #64] ; 0x40
2568: e3520000 cmp r2, #0
256c: 0a00003d beq 2668 <rtems_disk_delete+0x150>
dev_t dev = physical_disk->dev;
2570: e894000c ldm r4, {r2, r3}
unsigned deleted_count = 0;
2574: e1a09008 mov r9, r8
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
2578: e58d200c str r2, [sp, #12]
257c: e58d3010 str r3, [sp, #16]
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
2580: e1a06008 mov r6, r8
2584: e59f711c ldr r7, [pc, #284] ; 26a8 <rtems_disk_delete+0x190>
2588: e1a0a008 mov sl, r8
258c: e1a05004 mov r5, r4
2590: ea000023 b 2624 <rtems_disk_delete+0x10c>
rtems_disk_device_table *dtab = disktab + major;
2594: e5978004 ldr r8, [r7, #4]
for (minor = 0; minor < dtab->size; ++minor) {
2598: e3a04000 mov r4, #0
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
259c: e0888186 add r8, r8, r6, lsl #3
25a0: e58da000 str sl, [sp]
25a4: ea000019 b 2610 <rtems_disk_delete+0xf8>
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
25a8: e5981000 ldr r1, [r8]
25ac: e7910104 ldr r0, [r1, r4, lsl #2]
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
25b0: 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];
25b4: e1a0c104 lsl ip, r4, #2
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
25b8: 0a000013 beq 260c <rtems_disk_delete+0xf4>
25bc: e590e008 ldr lr, [r0, #8]
25c0: e28d300c add r3, sp, #12
25c4: e893000c ldm r3, {r2, r3}
25c8: e89e0c00 ldm lr, {sl, fp}
25cc: e15b0003 cmp fp, r3
25d0: 015a0002 cmpeq sl, r2
25d4: 13a03000 movne r3, #0
25d8: 03a03001 moveq r3, #1
25dc: e1500005 cmp r0, r5
25e0: 03a03000 moveq r3, #0
25e4: 12033001 andne r3, r3, #1
25e8: e3530000 cmp r3, #0
25ec: 0a000006 beq 260c <rtems_disk_delete+0xf4>
if (dd->uses == 0) {
25f0: e5903014 ldr r3, [r0, #20]
25f4: e3530000 cmp r3, #0
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
} else {
dd->deleted = true;
25f8: 13a03001 movne r3, #1
25fc: 15c03040 strbne r3, [r0, #64] ; 0x40
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;
2600: 0781300c streq r3, [r1, ip]
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;
2604: 02899001 addeq r9, r9, #1
dtab->minor [minor] = NULL;
free_disk_device(dd);
2608: 0bffff38 bleq 22f0 <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) {
260c: e2844001 add r4, r4, #1
2610: e5983004 ldr r3, [r8, #4]
2614: e1540003 cmp r4, r3
2618: 3affffe2 bcc 25a8 <rtems_disk_delete+0x90>
261c: e59da000 ldr sl, [sp]
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
2620: e2866001 add r6, r6, #1
2624: e5973000 ldr r3, [r7]
2628: e1560003 cmp r6, r3
262c: 3affffd8 bcc 2594 <rtems_disk_delete+0x7c>
}
}
}
}
physical_disk->uses -= deleted_count;
2630: e5953014 ldr r3, [r5, #20]
2634: e0699003 rsb r9, r9, r3
if (physical_disk->uses == 0) {
2638: e3590000 cmp r9, #0
263c: e1a0800a mov r8, sl
2640: e1a04005 mov r4, r5
}
}
}
}
physical_disk->uses -= deleted_count;
2644: e5859014 str r9, [r5, #20]
if (physical_disk->uses == 0) {
2648: 1a000012 bne 2698 <rtems_disk_delete+0x180>
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
disktab [major].minor [minor] = NULL;
264c: e59f3054 ldr r3, [pc, #84] ; 26a8 <rtems_disk_delete+0x190>
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
2650: e8950006 ldm r5, {r1, r2}
disktab [major].minor [minor] = NULL;
2654: e5933004 ldr r3, [r3, #4]
2658: e7933181 ldr r3, [r3, r1, lsl #3]
free_disk_device(physical_disk);
265c: 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;
2660: e7839102 str r9, [r3, r2, lsl #2]
2664: ea00000a b 2694 <rtems_disk_delete+0x17c>
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
2668: e5932014 ldr r2, [r3, #20]
266c: e3520000 cmp r2, #0
2670: 1a000008 bne 2698 <rtems_disk_delete+0x180>
--physical_disk->uses;
2674: e5942014 ldr r2, [r4, #20]
2678: e2422001 sub r2, r2, #1
267c: e5842014 str r2, [r4, #20]
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
2680: e8930006 ldm r3, {r1, r2}
disktab [major].minor [minor] = NULL;
2684: e59f301c ldr r3, [pc, #28] ; 26a8 <rtems_disk_delete+0x190>
2688: e5933004 ldr r3, [r3, #4]
268c: e7933181 ldr r3, [r3, r1, lsl #3]
2690: e7838102 str r8, [r3, r2, lsl #2]
free_disk_device(disk_to_remove);
2694: ebffff15 bl 22f0 <free_disk_device>
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
2698: ebffff32 bl 2368 <disk_unlock>
return RTEMS_SUCCESSFUL;
}
269c: e1a00008 mov r0, r8
26a0: e28dd014 add sp, sp, #20
26a4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
000029c8 <rtems_disk_io_initialize>:
rtems_status_code
rtems_disk_io_initialize(void)
{
29c8: e92d4031 push {r0, r4, r5, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
29cc: e59f408c ldr r4, [pc, #140] ; 2a60 <rtems_disk_io_initialize+0x98>
29d0: e5945000 ldr r5, [r4]
29d4: e3550000 cmp r5, #0
return RTEMS_SUCCESSFUL;
29d8: 13a00000 movne r0, #0
rtems_disk_io_initialize(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
29dc: 1a00001e bne 2a5c <rtems_disk_io_initialize+0x94>
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
29e0: e3a00008 mov r0, #8
29e4: e1a01000 mov r1, r0
29e8: eb0001dc bl 3160 <calloc>
if (disktab == NULL) {
29ec: e3500000 cmp r0, #0
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
29f0: e5840004 str r0, [r4, #4]
if (disktab == NULL) {
29f4: 0a000017 beq 2a58 <rtems_disk_io_initialize+0x90>
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
sc = rtems_semaphore_create(
29f8: e2843008 add r3, r4, #8
29fc: e58d3000 str r3, [sp]
2a00: e59f005c ldr r0, [pc, #92] ; 2a64 <rtems_disk_io_initialize+0x9c>
2a04: e3a01001 mov r1, #1
2a08: e3a02010 mov r2, #16
2a0c: e1a03005 mov r3, r5
disktab = calloc(size, sizeof(rtems_disk_device_table));
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
2a10: e5c4500c strb r5, [r4, #12]
sc = rtems_semaphore_create(
2a14: eb001187 bl 7038 <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) {
2a18: e3500000 cmp r0, #0
2a1c: 0a000002 beq 2a2c <rtems_disk_io_initialize+0x64>
free(disktab);
2a20: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED
2a24: eb000281 bl 3430 <free> <== NOT EXECUTED
2a28: ea00000a b 2a58 <rtems_disk_io_initialize+0x90> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
sc = rtems_bdbuf_init();
2a2c: eb0026b1 bl c4f8 <rtems_bdbuf_init>
if (sc != RTEMS_SUCCESSFUL) {
2a30: e3500000 cmp r0, #0
free(disktab);
return RTEMS_UNSATISFIED;
}
disktab_size = size;
2a34: 03a03008 moveq r3, #8
2a38: 05843000 streq r3, [r4]
return RTEMS_NO_MEMORY;
}
sc = rtems_bdbuf_init();
if (sc != RTEMS_SUCCESSFUL) {
2a3c: 0a000006 beq 2a5c <rtems_disk_io_initialize+0x94>
rtems_semaphore_delete(diskdevs_mutex);
2a40: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
2a44: eb0011e3 bl 71d8 <rtems_semaphore_delete> <== NOT EXECUTED
free(disktab);
2a48: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED
2a4c: eb000277 bl 3430 <free> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
2a50: e3a0000d mov r0, #13 <== NOT EXECUTED
2a54: ea000000 b 2a5c <rtems_disk_io_initialize+0x94> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
2a58: e3a0001a mov r0, #26 <== NOT EXECUTED
}
disktab_size = size;
return RTEMS_SUCCESSFUL;
}
2a5c: e8bd8038 pop {r3, r4, r5, pc}
000028dc <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) {
28dc: e3e02000 mvn r2, #0
28e0: e3e03000 mvn r3, #0
28e4: e1510003 cmp r1, r3
28e8: 01500002 cmpeq r0, r2
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
28ec: 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) {
28f0: 0a000007 beq 2914 <rtems_disk_next+0x38>
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
28f4: e2914001 adds r4, r1, #1
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
28f8: e1a05000 mov r5, r0
return temp.__overlay.major;
28fc: 31a05000 movcc r5, r0
2900: 3a000005 bcc 291c <rtems_disk_next+0x40>
/* If major wraps around */
if ((major + 1) < major) {
2904: e2955001 adds r5, r5, #1 <== NOT EXECUTED
return NULL;
}
++major;
minor = 0;
2908: 33a04000 movcc r4, #0 <== NOT EXECUTED
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
/* If major wraps around */
if ((major + 1) < major) {
290c: 3a000002 bcc 291c <rtems_disk_next+0x40> <== NOT EXECUTED
2910: ea000027 b 29b4 <rtems_disk_next+0xd8> <== NOT EXECUTED
rtems_disk_next(dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
2914: e3a04000 mov r4, #0
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
2918: e1a05004 mov r5, r4
} else {
++minor;
}
}
sc = disk_lock();
291c: ebfffe85 bl 2338 <disk_lock>
if (sc != RTEMS_SUCCESSFUL) {
2920: e2506000 subs r6, r0, #0
2924: 1a000024 bne 29bc <rtems_disk_next+0xe0>
return NULL;
}
if (major >= disktab_size) {
2928: e59f3094 ldr r3, [pc, #148] ; 29c4 <rtems_disk_next+0xe8>
292c: e5931000 ldr r1, [r3]
2930: e1550001 cmp r5, r1
disk_unlock();
return NULL;
}
dtab = disktab + major;
2934: 35932004 ldrcc r2, [r3, #4]
2938: 30826185 addcc r6, r2, r5, lsl #3
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return NULL;
}
if (major >= disktab_size) {
293c: 3a000002 bcc 294c <rtems_disk_next+0x70>
disk_unlock();
2940: ebfffe88 bl 2368 <disk_unlock> <== NOT EXECUTED
return NULL;
2944: e1a00006 mov r0, r6 <== NOT EXECUTED
2948: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
294c: e5963000 ldr r3, [r6]
2950: e3530000 cmp r3, #0
2954: 0a000002 beq 2964 <rtems_disk_next+0x88>
2958: e5960004 ldr r0, [r6, #4]
295c: e1540000 cmp r4, r0
2960: 3a000007 bcc 2984 <rtems_disk_next+0xa8>
minor = 0;
++major;
2964: e2855001 add r5, r5, #1
if (major >= disktab_size) {
2968: e1550001 cmp r5, r1
296c: 3a000001 bcc 2978 <rtems_disk_next+0x9c>
disk_unlock();
2970: ebfffe7c bl 2368 <disk_unlock>
2974: ea00000e b 29b4 <rtems_disk_next+0xd8>
return NULL;
}
dtab = disktab + major;
2978: e0826185 add r6, r2, r5, lsl #3
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
297c: e3a04000 mov r4, #0
if (major >= disktab_size) {
disk_unlock();
return NULL;
}
dtab = disktab + major;
2980: eafffff1 b 294c <rtems_disk_next+0x70>
} else if (dtab->minor [minor] == NULL) {
2984: e7933104 ldr r3, [r3, r4, lsl #2]
2988: e3530000 cmp r3, #0
298c: e1a07104 lsl r7, r4, #2
++minor;
2990: 02844001 addeq r4, r4, #1
2994: 0affffec beq 294c <rtems_disk_next+0x70>
} else {
++dtab->minor [minor]->uses;
2998: e5932014 ldr r2, [r3, #20]
299c: e2822001 add r2, r2, #1
29a0: e5832014 str r2, [r3, #20]
disk_unlock();
29a4: ebfffe6f bl 2368 <disk_unlock>
return dtab->minor [minor];
29a8: e5963000 ldr r3, [r6]
29ac: e7930007 ldr r0, [r3, r7]
29b0: e8bd80f0 pop {r4, r5, r6, r7, pc}
/* If minor wraps around */
if ((minor + 1) < minor) {
/* If major wraps around */
if ((major + 1) < major) {
return NULL;
29b4: e3a00000 mov r0, #0
29b8: e8bd80f0 pop {r4, r5, r6, r7, pc}
}
}
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return NULL;
29bc: e3a00000 mov r0, #0 <== NOT EXECUTED
disk_unlock();
return dtab->minor [minor];
}
}
}
29c0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
0000282c <rtems_disk_obtain>:
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
282c: e92d40f0 push {r4, r5, r6, r7, lr}
2830: e1a06000 mov r6, r0
2834: e1a07001 mov r7, r1
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
2838: e10f4000 mrs r4, CPSR
283c: e3843080 orr r3, r4, #128 ; 0x80
2840: 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) {
2844: e59f3048 ldr r3, [pc, #72] ; 2894 <rtems_disk_obtain+0x68>
2848: e5d3200c ldrb r2, [r3, #12]
284c: e21220ff ands r2, r2, #255 ; 0xff
2850: 1a000003 bne 2864 <rtems_disk_obtain+0x38>
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
2854: ebfffe83 bl 2268 <get_disk_entry>
2858: e1a05000 mov r5, r0
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
285c: e129f004 msr CPSR_fc, r4
2860: ea000009 b 288c <rtems_disk_obtain+0x60>
2864: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
rtems_interrupt_enable(level);
} else {
rtems_interrupt_enable(level);
sc = disk_lock();
2868: ebfffeb2 bl 2338 <disk_lock> <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL) {
286c: e2502000 subs r2, r0, #0 <== NOT EXECUTED
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
2870: 13a05000 movne r5, #0 <== NOT EXECUTED
rtems_interrupt_enable(level);
} else {
rtems_interrupt_enable(level);
sc = disk_lock();
if (sc == RTEMS_SUCCESSFUL) {
2874: 1a000004 bne 288c <rtems_disk_obtain+0x60> <== NOT EXECUTED
dd = get_disk_entry(dev, false);
2878: e1a00006 mov r0, r6 <== NOT EXECUTED
287c: e1a01007 mov r1, r7 <== NOT EXECUTED
2880: ebfffe78 bl 2268 <get_disk_entry> <== NOT EXECUTED
2884: e1a05000 mov r5, r0 <== NOT EXECUTED
disk_unlock();
2888: ebfffeb6 bl 2368 <disk_unlock> <== NOT EXECUTED
}
}
return dd;
}
288c: e1a00005 mov r0, r5
2890: e8bd80f0 pop {r4, r5, r6, r7, pc}
00000698 <rtems_fdisk_abort>:
* @param format The format string. See printf for details.
* @param ... The arguments for the format text.
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
698: e92d000f push {r0, r1, r2, r3} <== NOT EXECUTED
69c: e92d4011 push {r0, r4, lr} <== NOT EXECUTED
va_list args; va_start (args, format); fprintf (stderr, "fdisk:abort:");
6a0: e59f404c ldr r4, [pc, #76] ; 6f4 <bsp_section_fast_text_load_begin+0x5c><== NOT EXECUTED
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
va_list args;
va_start (args, format);
6a4: e28d3010 add r3, sp, #16 <== NOT EXECUTED
6a8: e58d3000 str r3, [sp] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
6ac: e5943000 ldr r3, [r4] <== NOT EXECUTED
6b0: e59f0040 ldr r0, [pc, #64] ; 6f8 <bsp_section_fast_text_load_begin+0x60><== NOT EXECUTED
6b4: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
6b8: eb007604 bl 1ded0 <fputs> <== NOT EXECUTED
vfprintf (stderr, format, args);
6bc: e5943000 ldr r3, [r4] <== NOT EXECUTED
6c0: e59d2000 ldr r2, [sp] <== NOT EXECUTED
6c4: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
6c8: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED
6cc: eb0098bb bl 269c0 <vfprintf> <== NOT EXECUTED
fprintf (stderr, "\n");
6d0: e5943000 ldr r3, [r4] <== NOT EXECUTED
6d4: e3a0000a mov r0, #10 <== NOT EXECUTED
6d8: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
6dc: eb0075c6 bl 1ddfc <fputc> <== NOT EXECUTED
fflush (stderr);
6e0: e5943000 ldr r3, [r4] <== NOT EXECUTED
6e4: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
6e8: eb0074b6 bl 1d9c8 <fflush> <== NOT EXECUTED
va_end (args); exit (1);
6ec: e3a00001 mov r0, #1 <== NOT EXECUTED
6f0: eb0073bb bl 1d5e4 <exit> <== NOT EXECUTED
000041c4 <rtems_fdisk_compact>:
* used segments that will fit. The used queue is sorted on the least
* number of active pages.
*/
static int
rtems_fdisk_compact (rtems_flashdisk* fd)
{
41c4: e92d47f7 push {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, lr}
static bool
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
41c8: e5903024 ldr r3, [r0, #36] ; 0x24
41cc: e5902028 ldr r2, [r0, #40] ; 0x28
41d0: e1520003 cmp r2, r3
* used segments that will fit. The used queue is sorted on the least
* number of active pages.
*/
static int
rtems_fdisk_compact (rtems_flashdisk* fd)
{
41d4: e1a04000 mov r4, r0
static bool
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
41d8: 2a000009 bcs 4204 <rtems_fdisk_compact+0x40>
fd->starvations++;
41dc: e5903070 ldr r3, [r0, #112] ; 0x70
41e0: e2833001 add r3, r3, #1
41e4: e5803070 str r3, [r0, #112] ; 0x70
uint32_t pages;
if (rtems_fdisk_is_erased_blocks_starvation (fd))
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " resolve starvation");
41e8: e59f11a0 ldr r1, [pc, #416] ; 4390 <rtems_fdisk_compact+0x1cc>
41ec: ebfffd77 bl 37d0 <rtems_fdisk_printf>
#endif
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
41f0: e2840040 add r0, r4, #64 ; 0x40
41f4: ebfffcba bl 34e4 <rtems_fdisk_segment_queue_pop_head>
if (!ssc)
41f8: e2505000 subs r5, r0, #0
41fc: 1a000008 bne 4224 <rtems_fdisk_compact+0x60>
4200: ea000002 b 4210 <rtems_fdisk_compact+0x4c> <== NOT EXECUTED
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
4204: e3a06000 mov r6, #0
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
4208: e284a034 add sl, r4, #52 ; 0x34
420c: ea000057 b 4370 <rtems_fdisk_compact+0x1ac>
rtems_fdisk_printf (fd, " resolve starvation");
#endif
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
if (!ssc)
ssc = rtems_fdisk_segment_queue_pop_head (&fd->available);
4210: e2840034 add r0, r4, #52 ; 0x34 <== NOT EXECUTED
4214: ebfffcb2 bl 34e4 <rtems_fdisk_segment_queue_pop_head> <== NOT EXECUTED
if (ssc)
4218: e2505000 subs r5, r0, #0 <== NOT EXECUTED
return EIO;
}
}
else
{
rtems_fdisk_error ("compacting: nothing to recycle");
421c: 059f0170 ldreq r0, [pc, #368] ; 4394 <rtems_fdisk_compact+0x1d0><== NOT EXECUTED
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
if (!ssc)
ssc = rtems_fdisk_segment_queue_pop_head (&fd->available);
if (ssc)
4220: 0a000014 beq 4278 <rtems_fdisk_compact+0xb4> <== NOT EXECUTED
{
dsc = rtems_fdisk_seg_most_available (&fd->available);
4224: e2840034 add r0, r4, #52 ; 0x34
4228: ebfffd38 bl 3710 <rtems_fdisk_seg_most_available>
if (dsc)
422c: e2502000 subs r2, r0, #0
4230: 0a000006 beq 4250 <rtems_fdisk_compact+0x8c>
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
4234: e1a00004 mov r0, r4
4238: e1a01005 mov r1, r5
423c: e28d3008 add r3, sp, #8
4240: ebfffef2 bl 3e10 <rtems_fdisk_recycle_segment>
if (ret)
4244: e3500000 cmp r0, #0
4248: 0affffed beq 4204 <rtems_fdisk_compact+0x40>
424c: ea00004a b 437c <rtems_fdisk_compact+0x1b8> <== NOT EXECUTED
return ret;
}
else
{
rtems_fdisk_error ("compacting: starvation");
4250: e59f0140 ldr r0, [pc, #320] ; 4398 <rtems_fdisk_compact+0x1d4><== NOT EXECUTED
4254: ea000007 b 4278 <rtems_fdisk_compact+0xb4> <== NOT EXECUTED
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
4258: e59f113c ldr r1, [pc, #316] ; 439c <rtems_fdisk_compact+0x1d8>
425c: e1a00004 mov r0, r4
4260: ebfffd5a bl 37d0 <rtems_fdisk_printf>
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
4264: e1a0000a mov r0, sl
4268: ebfffd28 bl 3710 <rtems_fdisk_seg_most_available>
if (dsc == 0)
426c: e2507000 subs r7, r0, #0
4270: 1a000003 bne 4284 <rtems_fdisk_compact+0xc0>
{
rtems_fdisk_error ("compacting: no available segments to compact too");
4274: e59f0124 ldr r0, [pc, #292] ; 43a0 <rtems_fdisk_compact+0x1dc><== NOT EXECUTED
4278: ebfffe1f bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
return EIO;
427c: e3a00005 mov r0, #5 <== NOT EXECUTED
4280: ea00003d b 437c <rtems_fdisk_compact+0x1b8> <== NOT EXECUTED
}
ssc = fd->used.head;
dst_pages = rtems_fdisk_seg_pages_available (dsc);
4284: ebfffd19 bl 36f0 <rtems_fdisk_seg_pages_available>
segments = 0;
pages = 0;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
4288: e2872008 add r2, r7, #8
428c: e892000c ldm r2, {r2, r3}
rtems_fdisk_error ("compacting: no available segments to compact too");
return EIO;
}
ssc = fd->used.head;
dst_pages = rtems_fdisk_seg_pages_available (dsc);
4290: e1a09000 mov r9, r0
segments = 0;
pages = 0;
4294: e3a08000 mov r8, #0
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
4298: e1a00004 mov r0, r4
429c: e59f1100 ldr r1, [pc, #256] ; 43a4 <rtems_fdisk_compact+0x1e0>
{
rtems_fdisk_error ("compacting: no available segments to compact too");
return EIO;
}
ssc = fd->used.head;
42a0: e5945040 ldr r5, [r4, #64] ; 0x40
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
pages = 0;
42a4: e58d8008 str r8, [sp, #8]
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
42a8: ebfffd48 bl 37d0 <rtems_fdisk_printf>
42ac: e59d3008 ldr r3, [sp, #8]
* we handle during one compaction. A lower number means less aggressive
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
42b0: ea000002 b 42c0 <rtems_fdisk_compact+0xfc>
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
segments++;
ssc = ssc->next;
42b4: e5955000 ldr r5, [r5]
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
segments++;
42b8: e2888001 add r8, r8, #1
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
42bc: e1a03002 mov r3, r2
* we handle during one compaction. A lower number means less aggressive
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
42c0: e3550000 cmp r5, #0
42c4: 058d3008 streq r3, [sp, #8]
42c8: 0a00000b beq 42fc <rtems_fdisk_compact+0x138>
((pages + ssc->pages_active) < dst_pages) &&
42cc: e595201c ldr r2, [r5, #28]
42d0: e0832002 add r2, r3, r2
* we handle during one compaction. A lower number means less aggressive
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
42d4: e1520009 cmp r2, r9
42d8: 2a000028 bcs 4380 <rtems_fdisk_compact+0x1bc>
((pages + ssc->pages_active) < dst_pages) &&
42dc: e594100c ldr r1, [r4, #12]
((compacted_segs + segments) < fd->compact_segs))
42e0: e0880006 add r0, r8, r6
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
42e4: e1500001 cmp r0, r1
42e8: 3afffff1 bcc 42b4 <rtems_fdisk_compact+0xf0>
42ec: ea000023 b 4380 <rtems_fdisk_compact+0x1bc> <== NOT EXECUTED
* We need a source segment and have pages to copy and
* compacting one segment to another is silly. Compaction needs
* to free at least one more segment.
*/
if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))
42f0: e0866008 add r6, r6, r8
42f4: e3560001 cmp r6, #1
42f8: 1a000004 bne 4310 <rtems_fdisk_compact+0x14c>
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " nothing to compact");
42fc: e1a00004 mov r0, r4
4300: e59f10a0 ldr r1, [pc, #160] ; 43a8 <rtems_fdisk_compact+0x1e4>
4304: ebfffd31 bl 37d0 <rtems_fdisk_printf>
}
compacted_segs += segments;
}
return 0;
4308: e3a00000 mov r0, #0
if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " nothing to compact");
#endif
break;
430c: ea00001a b 437c <rtems_fdisk_compact+0x1b8>
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
4310: e88d0108 stm sp, {r3, r8}
4314: e2852008 add r2, r5, #8
4318: e59f108c ldr r1, [pc, #140] ; 43ac <rtems_fdisk_compact+0x1e8>
431c: e892000c ldm r2, {r2, r3}
4320: e1a00004 mov r0, r4
4324: ebfffd29 bl 37d0 <rtems_fdisk_printf>
ssc->device, ssc->segment,
pages, segments);
#endif
rtems_fdisk_segment_queue_remove (&fd->available, dsc);
4328: e1a0000a mov r0, sl
432c: e1a01007 mov r1, r7
4330: ebfffc88 bl 3558 <rtems_fdisk_segment_queue_remove>
* We now copy the pages to the new segment.
*/
while (pages)
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
4334: e2845040 add r5, r4, #64 ; 0x40
/*
* We now copy the pages to the new segment.
*/
while (pages)
4338: ea000009 b 4364 <rtems_fdisk_compact+0x1a0>
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
433c: e1a00005 mov r0, r5
4340: ebfffc67 bl 34e4 <rtems_fdisk_segment_queue_pop_head>
if (ssc)
4344: e2501000 subs r1, r0, #0
4348: 0a000005 beq 4364 <rtems_fdisk_compact+0x1a0>
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
434c: e1a00004 mov r0, r4
4350: e1a02007 mov r2, r7
4354: e28d3008 add r3, sp, #8
4358: ebfffeac bl 3e10 <rtems_fdisk_recycle_segment>
if (ret)
435c: e3500000 cmp r0, #0
4360: 1a000005 bne 437c <rtems_fdisk_compact+0x1b8>
/*
* We now copy the pages to the new segment.
*/
while (pages)
4364: e59d3008 ldr r3, [sp, #8]
4368: e3530000 cmp r3, #0
436c: 1afffff2 bne 433c <rtems_fdisk_compact+0x178>
rtems_fdisk_error ("compacting: nothing to recycle");
return EIO;
}
}
while (fd->used.head)
4370: e5940040 ldr r0, [r4, #64] ; 0x40
4374: e3500000 cmp r0, #0
4378: 1affffb6 bne 4258 <rtems_fdisk_compact+0x94>
compacted_segs += segments;
}
return 0;
}
437c: e8bd87fe pop {r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, pc}
* We need a source segment and have pages to copy and
* compacting one segment to another is silly. Compaction needs
* to free at least one more segment.
*/
if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))
4380: e3530000 cmp r3, #0
rtems_fdisk_error ("compacting: nothing to recycle");
return EIO;
}
}
while (fd->used.head)
4384: e58d3008 str r3, [sp, #8]
* We need a source segment and have pages to copy and
* compacting one segment to another is silly. Compaction needs
* to free at least one more segment.
*/
if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))
4388: 1affffd8 bne 42f0 <rtems_fdisk_compact+0x12c>
438c: eaffffda b 42fc <rtems_fdisk_compact+0x138>
00003b6c <rtems_fdisk_erase_segment>:
/**
* Erase the segment.
*/
static int
rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
3b6c: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr}
3b70: e1a04001 mov r4, r1
uint32_t device; uint32_t segment; const rtems_fdisk_segment_desc* sd; const rtems_fdisk_driver_handlers* ops; device = sc->device; segment = sc->segment;
3b74: e2811008 add r1, r1, #8
3b78: e8910006 ldm r1, {r1, r2}
/**
* Erase the segment.
*/
static int
rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
3b7c: e1a05000 mov r5, r0
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
3b80: e3a0000c mov r0, #12
3b84: e0000091 mul r0, r1, r0
3b88: e595c02c ldr ip, [r5, #44] ; 0x2c
3b8c: e08c3000 add r3, ip, r0
3b90: e79c0000 ldr r0, [ip, r0]
3b94: e3a0c030 mov ip, #48 ; 0x30
3b98: e020029c mla r0, ip, r2, r0
const rtems_fdisk_segment_desc* sd; const rtems_fdisk_driver_handlers* ops; device = sc->device; segment = sc->segment; sd = rtems_fdisk_seg_descriptor (fd, device, segment); ops = fd->devices[device].descriptor->flash_ops;
3b9c: e5933008 ldr r3, [r3, #8]
ret = ops->erase (sd, device, segment);
3ba0: e5900004 ldr r0, [r0, #4]
3ba4: e5933008 ldr r3, [r3, #8]
3ba8: e1a0e00f mov lr, pc
3bac: e593f010 ldr pc, [r3, #16]
if (ret)
3bb0: e2506000 subs r6, r0, #0
3bb4: 0a000012 beq 3c04 <rtems_fdisk_erase_segment+0x98>
{
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
3bb8: e5948008 ldr r8, [r4, #8] <== NOT EXECUTED
3bbc: e594700c ldr r7, [r4, #12] <== NOT EXECUTED
3bc0: eb007047 bl 1fce4 <strerror> <== NOT EXECUTED
3bc4: e1a01008 mov r1, r8 <== NOT EXECUTED
3bc8: e1a03000 mov r3, r0 <== NOT EXECUTED
3bcc: e1a02007 mov r2, r7 <== NOT EXECUTED
3bd0: e59f008c ldr r0, [pc, #140] ; 3c64 <rtems_fdisk_erase_segment+0xf8><== NOT EXECUTED
3bd4: e58d6000 str r6, [sp] <== NOT EXECUTED
3bd8: ebffffc7 bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
"segment erase failed: %s (%d)",
sc->device, sc->segment, strerror (ret), ret);
sc->failed = true;
3bdc: e3a03001 mov r3, #1 <== NOT EXECUTED
3be0: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
3be4: e5953058 ldr r3, [r5, #88] ; 0x58 <== NOT EXECUTED
3be8: ea000002 b 3bf8 <rtems_fdisk_erase_segment+0x8c> <== NOT EXECUTED
while (it)
{
if (it == sc)
3bec: e1530004 cmp r3, r4 <== NOT EXECUTED
3bf0: 0a000017 beq 3c54 <rtems_fdisk_erase_segment+0xe8> <== NOT EXECUTED
return true;
it = it->next;
3bf4: e5933000 ldr r3, [r3] <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
3bf8: e3530000 cmp r3, #0 <== NOT EXECUTED
3bfc: 1afffffa bne 3bec <rtems_fdisk_erase_segment+0x80> <== NOT EXECUTED
3c00: ea000015 b 3c5c <rtems_fdisk_erase_segment+0xf0> <== NOT EXECUTED
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
3c04: e5952028 ldr r2, [r5, #40] ; 0x28
3c08: e5943014 ldr r3, [r4, #20]
3c0c: e0823003 add r3, r2, r3
3c10: e5853028 str r3, [r5, #40] ; 0x28
sc->erased++;
3c14: e594302c ldr r3, [r4, #44] ; 0x2c
3c18: e2833001 add r3, r3, #1
3c1c: e584302c str r3, [r4, #44] ; 0x2c
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
3c20: e5942018 ldr r2, [r4, #24]
3c24: e5953014 ldr r3, [r5, #20]
3c28: e5940010 ldr r0, [r4, #16]
3c2c: e3a010ff mov r1, #255 ; 0xff
3c30: e0020293 mul r2, r3, r2
3c34: eb006b0b bl 1e868 <memset>
sc->pages_active = 0;
3c38: e584601c str r6, [r4, #28]
sc->pages_used = 0;
3c3c: e5846020 str r6, [r4, #32]
sc->pages_bad = 0;
3c40: e5846024 str r6, [r4, #36] ; 0x24
sc->failed = false;
3c44: e5846028 str r6, [r4, #40] ; 0x28
/* * Push to the tail of the available queue. It is a very * simple type of wear reduction. Every other available * segment will now get a go. */ rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
3c48: e2850034 add r0, r5, #52 ; 0x34
3c4c: e1a01004 mov r1, r4
3c50: ebfffe31 bl 351c <rtems_fdisk_segment_queue_push_tail>
return 0;
}
3c54: e1a00006 mov r0, r6
3c58: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc}
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
"segment erase failed: %s (%d)",
sc->device, sc->segment, strerror (ret), ret);
sc->failed = true;
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
3c5c: e2850058 add r0, r5, #88 ; 0x58 <== NOT EXECUTED
3c60: eafffff9 b 3c4c <rtems_fdisk_erase_segment+0xe0> <== NOT EXECUTED
00003afc <rtems_fdisk_error>:
* @param ... The arguments for the format text.
* @return int The number of bytes written to the output.
*/
static int
rtems_fdisk_error (const char *format, ...)
{
3afc: e92d000f push {r0, r1, r2, r3} <== NOT EXECUTED
3b00: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
int ret; va_list args; va_start (args, format); fprintf (stderr, "fdisk:error:");
3b04: e59f4058 ldr r4, [pc, #88] ; 3b64 <rtems_fdisk_error+0x68> <== NOT EXECUTED
static int
rtems_fdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
3b08: e28d3014 add r3, sp, #20 <== NOT EXECUTED
3b0c: e58d3000 str r3, [sp] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
3b10: e5943000 ldr r3, [r4] <== NOT EXECUTED
3b14: e59f004c ldr r0, [pc, #76] ; 3b68 <rtems_fdisk_error+0x6c> <== NOT EXECUTED
3b18: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
3b1c: eb0068eb bl 1ded0 <fputs> <== NOT EXECUTED
ret = vfprintf (stderr, format, args);
3b20: e5943000 ldr r3, [r4] <== NOT EXECUTED
3b24: e59d2000 ldr r2, [sp] <== NOT EXECUTED
3b28: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
3b2c: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
3b30: eb008ba2 bl 269c0 <vfprintf> <== NOT EXECUTED
fprintf (stderr, "\n");
3b34: e5943000 ldr r3, [r4] <== NOT EXECUTED
{
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "fdisk:error:");
ret = vfprintf (stderr, format, args);
3b38: e1a05000 mov r5, r0 <== NOT EXECUTED
fprintf (stderr, "\n");
3b3c: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
3b40: e3a0000a mov r0, #10 <== NOT EXECUTED
3b44: eb0068ac bl 1ddfc <fputc> <== NOT EXECUTED
fflush (stderr);
3b48: e5943000 ldr r3, [r4] <== NOT EXECUTED
3b4c: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
3b50: eb00679c bl 1d9c8 <fflush> <== NOT EXECUTED
va_end (args); return ret; }
3b54: e1a00005 mov r0, r5 <== NOT EXECUTED
3b58: e8bd4038 pop {r3, r4, r5, lr} <== NOT EXECUTED
3b5c: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3b60: e12fff1e bx lr <== NOT EXECUTED
00003750 <rtems_fdisk_info>:
* @param ... The arguments for the format text.
* @return int The number of bytes written to the output.
*/
static int
rtems_fdisk_info (const rtems_flashdisk* fd, const char *format, ...)
{
3750: e92d000e push {r1, r2, r3}
int ret = 0; if (fd->info_level >= 2)
3754: e590306c ldr r3, [r0, #108] ; 0x6c
3758: e3530001 cmp r3, #1
* @param ... The arguments for the format text.
* @return int The number of bytes written to the output.
*/
static int
rtems_fdisk_info (const rtems_flashdisk* fd, const char *format, ...)
{
375c: e92d4031 push {r0, r4, r5, lr}
int ret = 0;
3760: 93a05000 movls r5, #0
if (fd->info_level >= 2)
3764: 9a000013 bls 37b8 <rtems_fdisk_info+0x68>
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:");
3768: e59f4058 ldr r4, [pc, #88] ; 37c8 <rtems_fdisk_info+0x78> <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
376c: e28d3014 add r3, sp, #20 <== NOT EXECUTED
3770: e58d3000 str r3, [sp] <== NOT EXECUTED
fprintf (stdout, "fdisk:");
3774: e5943000 ldr r3, [r4] <== NOT EXECUTED
3778: e59f004c ldr r0, [pc, #76] ; 37cc <rtems_fdisk_info+0x7c> <== NOT EXECUTED
377c: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED
3780: eb0069d2 bl 1ded0 <fputs> <== NOT EXECUTED
ret = vfprintf (stdout, format, args);
3784: e5943000 ldr r3, [r4] <== NOT EXECUTED
3788: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
378c: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
3790: e59d2000 ldr r2, [sp] <== NOT EXECUTED
3794: eb008c89 bl 269c0 <vfprintf> <== NOT EXECUTED
fprintf (stdout, "\n");
3798: e5943000 ldr r3, [r4] <== NOT EXECUTED
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:");
ret = vfprintf (stdout, format, args);
379c: e1a05000 mov r5, r0 <== NOT EXECUTED
fprintf (stdout, "\n");
37a0: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED
37a4: e3a0000a mov r0, #10 <== NOT EXECUTED
37a8: eb006993 bl 1ddfc <fputc> <== NOT EXECUTED
fflush (stdout);
37ac: e5943000 ldr r3, [r4] <== NOT EXECUTED
37b0: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
37b4: eb006883 bl 1d9c8 <fflush> <== NOT EXECUTED
va_end (args);
}
return ret;
}
37b8: e1a00005 mov r0, r5
37bc: e8bd4038 pop {r3, r4, r5, lr}
37c0: e28dd00c add sp, sp, #12
37c4: e12fff1e bx lr
000058c4 <rtems_fdisk_initialize>:
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
rtems_device_minor_number minor,
void* arg __attribute__((unused)))
{
58c4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
58c8: e24dd03c sub sp, sp, #60 ; 0x3c
58cc: e58d001c str r0, [sp, #28]
const rtems_flashdisk_config* c = rtems_flashdisk_configuration;
rtems_flashdisk* fd;
rtems_status_code sc;
sc = rtems_disk_io_initialize ();
58d0: ebfff6b9 bl 33bc <rtems_disk_io_initialize>
if (sc != RTEMS_SUCCESSFUL)
58d4: e2507000 subs r7, r0, #0
58d8: 1a000124 bne 5d70 <rtems_fdisk_initialize+0x4ac>
static rtems_status_code
rtems_fdisk_crc16_gen_factors (uint16_t pattern)
{
uint32_t b;
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
58dc: e3a00c02 mov r0, #512 ; 0x200
58e0: eb00053a bl 6dd0 <malloc>
58e4: e59f34c0 ldr r3, [pc, #1216] ; 5dac <rtems_fdisk_initialize+0x4e8>
if (!rtems_fdisk_crc16_factor)
58e8: e3500000 cmp r0, #0
static rtems_status_code
rtems_fdisk_crc16_gen_factors (uint16_t pattern)
{
uint32_t b;
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
58ec: e5830008 str r0, [r3, #8]
if (!rtems_fdisk_crc16_factor)
58f0: 0a00011d beq 5d6c <rtems_fdisk_initialize+0x4a8>
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
58f4: e59f24b4 ldr r2, [pc, #1204] ; 5db0 <rtems_fdisk_initialize+0x4ec>
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
58f8: e1a03807 lsl r3, r7, #16
58fc: e1a03823 lsr r3, r3, #16
5900: e3a04009 mov r4, #9
5904: ea000004 b 591c <rtems_fdisk_initialize+0x58>
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
5908: e3130001 tst r3, #1
590c: e1a030a3 lsr r3, r3, #1
5910: 10233002 eorne r3, r3, r2
5914: 11a03803 lslne r3, r3, #16
5918: 11a03823 lsrne r3, r3, #16
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
591c: e2544001 subs r4, r4, #1
5920: 1afffff8 bne 5908 <rtems_fdisk_initialize+0x44>
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_fdisk_crc16_factor)
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
5924: e2877001 add r7, r7, #1
5928: e3570c01 cmp r7, #256 ; 0x100
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
rtems_fdisk_crc16_factor[b] = v & 0xffff;
592c: e0c030b2 strh r3, [r0], #2
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_fdisk_crc16_factor)
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
5930: 1afffff0 bne 58f8 <rtems_fdisk_initialize+0x34>
5934: ea000110 b 5d7c <rtems_fdisk_initialize+0x4b8>
if (!rtems_flashdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
5938: e3a0200a mov r2, #10
593c: e28d0030 add r0, sp, #48 ; 0x30
5940: e59f146c ldr r1, [pc, #1132] ; 5db4 <rtems_fdisk_initialize+0x4f0>
5944: eb006344 bl 1e65c <memcpy>
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
5948: e5dd2039 ldrb r2, [sp, #57] ; 0x39
594c: e0862002 add r2, r6, r2
5950: e5cd2039 strb r2, [sp, #57] ; 0x39
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
5954: e5943000 ldr r3, [r4]
5958: e59dc018 ldr ip, [sp, #24]
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
595c: e59d001c ldr r0, [sp, #28]
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
5960: e083400c add r4, r3, ip
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
5964: e783000c str r0, [r3, ip]
fd->minor = minor;
fd->flags = c->flags;
5968: e595300c ldr r3, [r5, #12]
596c: e5843008 str r3, [r4, #8]
fd->compact_segs = c->compact_segs;
5970: e5953014 ldr r3, [r5, #20]
5974: e584300c str r3, [r4, #12]
fd->avail_compact_segs = c->avail_compact_segs;
5978: e5953018 ldr r3, [r5, #24]
597c: e5843010 str r3, [r4, #16]
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
5980: e5953010 ldr r3, [r5, #16]
fd->major = major;
fd->minor = minor;
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
5984: e595b000 ldr fp, [r5]
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
5988: e5952004 ldr r2, [r5, #4]
fd->minor = minor;
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
598c: e5843020 str r3, [r4, #32]
fd->info_level = c->info_level;
5990: e595301c ldr r3, [r5, #28]
for (device = 0; device < c->device_count; device++)
5994: e3a08000 mov r8, #0
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
5998: e584306c str r3, [r4, #108] ; 0x6c
for (device = 0; device < c->device_count; device++)
599c: e58d2020 str r2, [sp, #32]
fd = &rtems_flashdisks[minor];
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
fd->minor = minor;
59a0: e5846004 str r6, [r4, #4]
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
59a4: e584b014 str fp, [r4, #20]
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
59a8: e1a07008 mov r7, r8
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
59ac: e1a09008 mov r9, r8
59b0: e1a02006 mov r2, r6
59b4: e1a03004 mov r3, r4
59b8: ea000026 b 5a58 <rtems_fdisk_initialize+0x194>
blocks += rtems_fdisk_blocks_in_device (&c->devices[device],
59bc: e5951008 ldr r1, [r5, #8]
59c0: e081c008 add ip, r1, r8
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
59c4: e7911008 ldr r1, [r1, r8]
59c8: e3a04000 mov r4, #0
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
blocks += rtems_fdisk_blocks_in_device (&c->devices[device],
59cc: e58dc024 str ip, [sp, #36] ; 0x24
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
59d0: e58d1028 str r1, [sp, #40] ; 0x28
59d4: e1a0a004 mov sl, r4
*/
static uint32_t
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
59d8: e1a06004 mov r6, r4
59dc: ea000017 b 5a40 <rtems_fdisk_initialize+0x17c>
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
{
const rtems_fdisk_segment_desc* sd = &dd->segments[s];
59e0: e59d0024 ldr r0, [sp, #36] ; 0x24
59e4: e590c004 ldr ip, [r0, #4]
59e8: e08c1004 add r1, ip, r4
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
59ec: e5910008 ldr r0, [r1, #8]
59f0: e1a0100b mov r1, fp
59f4: e58d2010 str r2, [sp, #16]
59f8: e58d300c str r3, [sp, #12]
59fc: e58dc014 str ip, [sp, #20]
5a00: ebffefce bl 1940 <__aeabi_uidiv>
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
return ((bytes - 1) / page_size) + 1;
5a04: e2401001 sub r1, r0, #1
static uint32_t
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
5a08: e1a00180 lsl r0, r0, #3
return ((bytes - 1) / page_size) + 1;
5a0c: e58d102c str r1, [sp, #44] ; 0x2c
5a10: e2400001 sub r0, r0, #1
5a14: e1a0100b mov r1, fp
5a18: ebffefc8 bl 1940 <__aeabi_uidiv>
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
{
const rtems_fdisk_segment_desc* sd = &dd->segments[s];
count +=
(rtems_fdisk_pages_in_segment (sd, page_size) -
5a1c: e59d102c ldr r1, [sp, #44] ; 0x2c
rtems_fdisk_page_desc_pages (sd, page_size)) * sd->count;
5a20: e59dc014 ldr ip, [sp, #20]
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
{
const rtems_fdisk_segment_desc* sd = &dd->segments[s];
count +=
(rtems_fdisk_pages_in_segment (sd, page_size) -
5a24: e0600001 rsb r0, r0, r1
rtems_fdisk_page_desc_pages (sd, page_size)) * sd->count;
5a28: e19c10b4 ldrh r1, [ip, r4]
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
{
const rtems_fdisk_segment_desc* sd = &dd->segments[s];
count +=
5a2c: e0266091 mla r6, r1, r0, r6
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
5a30: e59d300c ldr r3, [sp, #12]
5a34: e59d2010 ldr r2, [sp, #16]
5a38: e28aa001 add sl, sl, #1
5a3c: e284400c add r4, r4, #12
5a40: e59dc028 ldr ip, [sp, #40] ; 0x28
5a44: e15a000c cmp sl, ip
5a48: 1affffe4 bne 59e0 <rtems_fdisk_initialize+0x11c>
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
blocks += rtems_fdisk_blocks_in_device (&c->devices[device],
5a4c: e0877006 add r7, r7, r6
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
5a50: e2899001 add r9, r9, #1
5a54: e288800c add r8, r8, #12
5a58: e59dc020 ldr ip, [sp, #32]
5a5c: e159000c cmp r9, ip
5a60: 1affffd5 bne 59bc <rtems_fdisk_initialize+0xf8>
c->block_size);
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
5a64: e1a0000b mov r0, fp
5a68: e1a04003 mov r4, r3
5a6c: e1a06002 mov r6, r2
5a70: eb0004d6 bl 6dd0 <malloc>
if (!fd->copy_buffer)
5a74: e3500000 cmp r0, #0
c->block_size);
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
5a78: e5840068 str r0, [r4, #104] ; 0x68
if (!fd->copy_buffer)
5a7c: 0a0000ba beq 5d6c <rtems_fdisk_initialize+0x4a8>
return RTEMS_NO_MEMORY;
fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));
5a80: e1a00007 mov r0, r7
5a84: e3a01008 mov r1, #8
5a88: eb000282 bl 6498 <calloc>
if (!fd->blocks)
5a8c: e3500000 cmp r0, #0
*/
fd->copy_buffer = malloc (c->block_size);
if (!fd->copy_buffer)
return RTEMS_NO_MEMORY;
fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));
5a90: e5840018 str r0, [r4, #24]
if (!fd->blocks)
5a94: 0a0000b4 beq 5d6c <rtems_fdisk_initialize+0x4a8>
return RTEMS_NO_MEMORY;
fd->block_count = blocks;
5a98: e584701c str r7, [r4, #28]
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
5a9c: e1a00009 mov r0, r9
5aa0: e3a0100c mov r1, #12
5aa4: eb00027b bl 6498 <calloc>
if (!fd->devices)
5aa8: e3500000 cmp r0, #0
if (!fd->blocks)
return RTEMS_NO_MEMORY;
fd->block_count = blocks;
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
5aac: e584002c str r0, [r4, #44] ; 0x2c
if (!fd->devices)
5ab0: 0a0000ad beq 5d6c <rtems_fdisk_initialize+0x4a8>
return RTEMS_NO_MEMORY;
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
5ab4: e2843064 add r3, r4, #100 ; 0x64
5ab8: e58d3000 str r3, [sp]
5abc: e59f02f4 ldr r0, [pc, #756] ; 5db8 <rtems_fdisk_initialize+0x4f4>
5ac0: e3a01001 mov r1, #1
5ac4: e3a02054 mov r2, #84 ; 0x54
5ac8: e3a03000 mov r3, #0
5acc: eb00140d bl ab08 <rtems_semaphore_create>
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &fd->lock);
if (sc != RTEMS_SUCCESSFUL)
5ad0: e2508000 subs r8, r0, #0
5ad4: 0a000009 beq 5b00 <rtems_fdisk_initialize+0x23c>
{
rtems_fdisk_error ("disk lock create failed");
5ad8: e59f02dc ldr r0, [pc, #732] ; 5dbc <rtems_fdisk_initialize+0x4f8><== NOT EXECUTED
5adc: ebfff806 bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
free (fd->copy_buffer);
5ae0: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED
5ae4: eb000349 bl 6810 <free> <== NOT EXECUTED
free (fd->blocks);
5ae8: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED
5aec: eb000347 bl 6810 <free> <== NOT EXECUTED
free (fd->devices);
5af0: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED
5af4: eb000345 bl 6810 <free> <== NOT EXECUTED
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
if (!fd->devices)
return RTEMS_NO_MEMORY;
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
5af8: e1a07008 mov r7, r8 <== NOT EXECUTED
{
rtems_fdisk_error ("disk lock create failed");
free (fd->copy_buffer);
free (fd->blocks);
free (fd->devices);
return sc;
5afc: ea00009b b 5d70 <rtems_fdisk_initialize+0x4ac> <== NOT EXECUTED
}
sc = rtems_disk_create_phys(dev, c->block_size,
5b00: e59f22b8 ldr r2, [pc, #696] ; 5dc0 <rtems_fdisk_initialize+0x4fc>
5b04: e5943020 ldr r3, [r4, #32]
5b08: e88d0104 stm sp, {r2, r8}
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
5b0c: e28d2030 add r2, sp, #48 ; 0x30
free (fd->blocks);
free (fd->devices);
return sc;
}
sc = rtems_disk_create_phys(dev, c->block_size,
5b10: e58d2008 str r2, [sp, #8]
5b14: e0633007 rsb r3, r3, r7
5b18: e59d001c ldr r0, [sp, #28]
5b1c: e1a01006 mov r1, r6
5b20: e5952000 ldr r2, [r5]
5b24: ebfff590 bl 316c <rtems_disk_create_phys>
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
5b28: e2507000 subs r7, r0, #0
5b2c: 0a000052 beq 5c7c <rtems_fdisk_initialize+0x3b8>
{
rtems_semaphore_delete (fd->lock);
5b30: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED
5b34: eb00145b bl aca8 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_disk_delete (dev);
5b38: e1a01006 mov r1, r6 <== NOT EXECUTED
5b3c: e59d001c ldr r0, [sp, #28] <== NOT EXECUTED
5b40: ebfff4f1 bl 2f0c <rtems_disk_delete> <== NOT EXECUTED
free (fd->copy_buffer);
5b44: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED
5b48: eb000330 bl 6810 <free> <== NOT EXECUTED
free (fd->blocks);
5b4c: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED
5b50: eb00032e bl 6810 <free> <== NOT EXECUTED
free (fd->devices);
5b54: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED
5b58: eb00032c bl 6810 <free> <== NOT EXECUTED
rtems_fdisk_error ("disk create phy failed");
5b5c: e59f0260 ldr r0, [pc, #608] ; 5dc4 <rtems_fdisk_initialize+0x500><== NOT EXECUTED
5b60: ebfff7e5 bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
return sc;
5b64: ea000081 b 5d70 <rtems_fdisk_initialize+0x4ac> <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc;
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
5b68: e5953008 ldr r3, [r5, #8]
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
5b6c: e3a02000 mov r2, #0
{
rtems_fdisk_segment_ctl* sc;
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
5b70: e0839007 add r9, r3, r7
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
5b74: e1a01002 mov r1, r2
5b78: e7933007 ldr r3, [r3, r7]
* Count the segments for a device.
*/
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
5b7c: e1a0a002 mov sl, r2
5b80: ea000004 b 5b98 <rtems_fdisk_initialize+0x2d4>
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
count += dd->segments[segment].count;
5b84: e5990004 ldr r0, [r9, #4]
5b88: e19000b2 ldrh r0, [r0, r2]
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
5b8c: e2811001 add r1, r1, #1
count += dd->segments[segment].count;
5b90: e08aa000 add sl, sl, r0
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
5b94: e282200c add r2, r2, #12
5b98: e1510003 cmp r1, r3
5b9c: 1afffff8 bne 5b84 <rtems_fdisk_initialize+0x2c0>
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
5ba0: e594b02c ldr fp, [r4, #44] ; 0x2c
5ba4: e1a0000a mov r0, sl
5ba8: e08b2007 add r2, fp, r7
5bac: e3a01030 mov r1, #48 ; 0x30
5bb0: e58d300c str r3, [sp, #12]
5bb4: e58d2020 str r2, [sp, #32]
5bb8: eb000236 bl 6498 <calloc>
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
5bbc: e3500000 cmp r0, #0
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
5bc0: e78b0007 str r0, [fp, r7]
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
5bc4: e59d300c ldr r3, [sp, #12]
5bc8: 1a000021 bne 5c54 <rtems_fdisk_initialize+0x390>
{
rtems_disk_delete (dev);
5bcc: e1a01006 mov r1, r6 <== NOT EXECUTED
5bd0: e59d001c ldr r0, [sp, #28] <== NOT EXECUTED
5bd4: ebfff4cc bl 2f0c <rtems_disk_delete> <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
5bd8: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED
5bdc: eb001431 bl aca8 <rtems_semaphore_delete> <== NOT EXECUTED
free (fd->copy_buffer);
5be0: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED
5be4: eb000309 bl 6810 <free> <== NOT EXECUTED
free (fd->blocks);
5be8: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED
5bec: eb000307 bl 6810 <free> <== NOT EXECUTED
free (fd->devices);
5bf0: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED
5bf4: eb000305 bl 6810 <free> <== NOT EXECUTED
5bf8: ea00005b b 5d6c <rtems_fdisk_initialize+0x4a8> <== NOT EXECUTED
for (segment = 0; segment < c->devices[device].segment_count; segment++)
{
const rtems_fdisk_segment_desc* sd;
uint32_t seg_segment;
sd = &c->devices[device].segments[segment];
5bfc: e5992004 ldr r2, [r9, #4]
5c00: e082c001 add ip, r2, r1
5c04: e58dc024 str ip, [sp, #36] ; 0x24
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
5c08: e192b0b1 ldrh fp, [r2, r1]
5c0c: e3a0c000 mov ip, #0
5c10: e1a02000 mov r2, r0
5c14: e58d3028 str r3, [sp, #40] ; 0x28
5c18: ea000005 b 5c34 <rtems_fdisk_initialize+0x370>
{
sc->descriptor = sd;
5c1c: e59d3024 ldr r3, [sp, #36] ; 0x24
sc->device = device;
sc->segment = seg_segment;
5c20: e9821108 stmib r2, {r3, r8, ip}
sc->erased = 0;
5c24: e3a03000 mov r3, #0
5c28: e582302c str r3, [r2, #44] ; 0x2c
const rtems_fdisk_segment_desc* sd;
uint32_t seg_segment;
sd = &c->devices[device].segments[segment];
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
5c2c: e28cc001 add ip, ip, #1
5c30: e2822030 add r2, r2, #48 ; 0x30
5c34: e15c000b cmp ip, fp
5c38: 3afffff7 bcc 5c1c <rtems_fdisk_initialize+0x358>
5c3c: e3a0c030 mov ip, #48 ; 0x30
5c40: e59d3028 ldr r3, [sp, #40] ; 0x28
5c44: e0200b9c mla r0, ip, fp, r0
return RTEMS_NO_MEMORY;
}
sc = fd->devices[device].segments;
for (segment = 0; segment < c->devices[device].segment_count; segment++)
5c48: e28ee001 add lr, lr, #1
5c4c: e281100c add r1, r1, #12
5c50: ea000001 b 5c5c <rtems_fdisk_initialize+0x398>
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
5c54: e3a01000 mov r1, #0
5c58: e1a0e001 mov lr, r1
return RTEMS_NO_MEMORY;
}
sc = fd->devices[device].segments;
for (segment = 0; segment < c->devices[device].segment_count; segment++)
5c5c: e15e0003 cmp lr, r3
5c60: 1affffe5 bne 5bfc <rtems_fdisk_initialize+0x338>
sc->segment = seg_segment;
sc->erased = 0;
}
}
fd->devices[device].segment_count = segment_count;
5c64: e59d2020 ldr r2, [sp, #32]
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
5c68: e2888001 add r8, r8, #1
sc->segment = seg_segment;
sc->erased = 0;
}
}
fd->devices[device].segment_count = segment_count;
5c6c: e582a004 str sl, [r2, #4]
fd->devices[device].descriptor = &c->devices[device];
5c70: e5829008 str r9, [r2, #8]
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
5c74: e287700c add r7, r7, #12
5c78: ea000000 b 5c80 <rtems_fdisk_initialize+0x3bc>
}
sc = rtems_disk_create_phys(dev, c->block_size,
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
5c7c: e1a08007 mov r8, r7
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
5c80: e5953004 ldr r3, [r5, #4]
5c84: e1580003 cmp r8, r3
5c88: 3affffb6 bcc 5b68 <rtems_fdisk_initialize+0x2a4>
fd->devices[device].segment_count = segment_count;
fd->devices[device].descriptor = &c->devices[device];
}
fd->device_count = c->device_count;
5c8c: e5843030 str r3, [r4, #48] ; 0x30
ret = rtems_fdisk_recover_block_mappings (fd);
5c90: e1a00004 mov r0, r4
5c94: ebfff9c5 bl 43b0 <rtems_fdisk_recover_block_mappings>
if (ret)
5c98: e2507000 subs r7, r0, #0
5c9c: 0a00000f beq 5ce0 <rtems_fdisk_initialize+0x41c>
{
rtems_disk_delete (dev);
5ca0: e1a01006 mov r1, r6 <== NOT EXECUTED
5ca4: e59d001c ldr r0, [sp, #28] <== NOT EXECUTED
5ca8: ebfff497 bl 2f0c <rtems_disk_delete> <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
5cac: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED
5cb0: eb0013fc bl aca8 <rtems_semaphore_delete> <== NOT EXECUTED
free (fd->copy_buffer);
5cb4: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED
5cb8: eb0002d4 bl 6810 <free> <== NOT EXECUTED
free (fd->blocks);
5cbc: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED
5cc0: eb0002d2 bl 6810 <free> <== NOT EXECUTED
free (fd->devices);
5cc4: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED
5cc8: eb0002d0 bl 6810 <free> <== NOT EXECUTED
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
5ccc: e1a00007 mov r0, r7 <== NOT EXECUTED
5cd0: eb006803 bl 1fce4 <strerror> <== NOT EXECUTED
5cd4: e1a01000 mov r1, r0 <== NOT EXECUTED
5cd8: e59f00e8 ldr r0, [pc, #232] ; 5dc8 <rtems_fdisk_initialize+0x504><== NOT EXECUTED
5cdc: ea000015 b 5d38 <rtems_fdisk_initialize+0x474> <== NOT EXECUTED
strerror (ret), ret);
return ret;
}
ret = rtems_fdisk_compact (fd);
5ce0: e1a00004 mov r0, r4
5ce4: ebfff936 bl 41c4 <rtems_fdisk_compact>
5ce8: e59dc018 ldr ip, [sp, #24]
if (ret)
5cec: e2507000 subs r7, r0, #0
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
strerror (ret), ret);
return ret;
}
ret = rtems_fdisk_compact (fd);
5cf0: e28cc074 add ip, ip, #116 ; 0x74
5cf4: e58dc018 str ip, [sp, #24]
if (ret)
5cf8: 0a000011 beq 5d44 <rtems_fdisk_initialize+0x480>
{
rtems_disk_delete (dev);
5cfc: e1a01006 mov r1, r6 <== NOT EXECUTED
5d00: e59d001c ldr r0, [sp, #28] <== NOT EXECUTED
5d04: ebfff480 bl 2f0c <rtems_disk_delete> <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
5d08: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED
5d0c: eb0013e5 bl aca8 <rtems_semaphore_delete> <== NOT EXECUTED
free (fd->copy_buffer);
5d10: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED
5d14: eb0002bd bl 6810 <free> <== NOT EXECUTED
free (fd->blocks);
5d18: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED
5d1c: eb0002bb bl 6810 <free> <== NOT EXECUTED
free (fd->devices);
5d20: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED
5d24: eb0002b9 bl 6810 <free> <== NOT EXECUTED
rtems_fdisk_error ("compacting of disk failed: %s (%d)",
5d28: e1a00007 mov r0, r7 <== NOT EXECUTED
5d2c: eb0067ec bl 1fce4 <strerror> <== NOT EXECUTED
5d30: e1a01000 mov r1, r0 <== NOT EXECUTED
5d34: e59f0090 ldr r0, [pc, #144] ; 5dcc <rtems_fdisk_initialize+0x508><== NOT EXECUTED
5d38: e1a02007 mov r2, r7 <== NOT EXECUTED
5d3c: ebfff76e bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
strerror (ret), ret);
return ret;
5d40: ea00000a b 5d70 <rtems_fdisk_initialize+0x4ac> <== NOT EXECUTED
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
5d44: e2866001 add r6, r6, #1
5d48: e2855020 add r5, r5, #32
5d4c: e59f307c ldr r3, [pc, #124] ; 5dd0 <rtems_fdisk_initialize+0x50c>
5d50: e5933000 ldr r3, [r3]
5d54: e1560003 cmp r6, r3
5d58: e59f404c ldr r4, [pc, #76] ; 5dac <rtems_fdisk_initialize+0x4e8>
5d5c: 3afffef5 bcc 5938 <rtems_fdisk_initialize+0x74>
strerror (ret), ret);
return ret;
}
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
5d60: e5843004 str r3, [r4, #4]
return RTEMS_SUCCESSFUL;
5d64: e3a07000 mov r7, #0
5d68: ea000000 b 5d70 <rtems_fdisk_initialize+0x4ac>
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
return RTEMS_NO_MEMORY;
5d6c: e3a0701a mov r7, #26 <== NOT EXECUTED
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
return RTEMS_SUCCESSFUL;
}
5d70: e1a00007 mov r0, r7
5d74: e28dd03c add sp, sp, #60 ; 0x3c
5d78: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
sc = rtems_fdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
5d7c: e59f304c ldr r3, [pc, #76] ; 5dd0 <rtems_fdisk_initialize+0x50c>
5d80: e3a01074 mov r1, #116 ; 0x74
5d84: e5930000 ldr r0, [r3]
5d88: eb0001c2 bl 6498 <calloc>
5d8c: e59f3018 ldr r3, [pc, #24] ; 5dac <rtems_fdisk_initialize+0x4e8>
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
5d90: e3500000 cmp r0, #0
sc = rtems_fdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
5d94: e5830000 str r0, [r3]
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
5d98: 0afffff3 beq 5d6c <rtems_fdisk_initialize+0x4a8>
5d9c: e58d4018 str r4, [sp, #24]
5da0: e59f502c ldr r5, [pc, #44] ; 5dd4 <rtems_fdisk_initialize+0x510>
5da4: e1a06004 mov r6, r4
5da8: eaffffe7 b 5d4c <rtems_fdisk_initialize+0x488>
000046cc <rtems_fdisk_ioctl>:
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
{
46cc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
46d0: e24dd064 sub sp, sp, #100 ; 0x64
46d4: e1a07001 mov r7, r1
46d8: e1a04002 mov r4, r2
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
46dc: e5908004 ldr r8, [r0, #4]
46e0: e1a0a000 mov sl, r0
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;
errno = 0;
46e4: eb0063ba bl 1d5d4 <__errno>
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
46e8: e3a03074 mov r3, #116 ; 0x74
46ec: e00c0893 mul ip, r3, r8
46f0: e59f6f90 ldr r6, [pc, #3984] ; 5688 <bsp_section_rodata_size+0x7d4>
46f4: e5963000 ldr r3, [r6]
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;
errno = 0;
46f8: e3a01000 mov r1, #0
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
46fc: e083300c add r3, r3, ip
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;
errno = 0;
4700: e5801000 str r1, [r0]
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
4704: e1a02001 mov r2, r1
4708: e5930064 ldr r0, [r3, #100] ; 0x64
470c: e58dc034 str ip, [sp, #52] ; 0x34
4710: eb00198b bl ad44 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
4714: e2505000 subs r5, r0, #0
4718: 1a00045a bne 5888 <bsp_section_rodata_size+0x9d4>
errno = EIO;
else
{
errno = 0;
471c: eb0063ac bl 1d5d4 <__errno>
switch (req)
4720: e59f3f64 ldr r3, [pc, #3940] ; 568c <bsp_section_rodata_size+0x7d8>
4724: e1570003 cmp r7, r3
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
errno = EIO;
else
{
errno = 0;
4728: e5805000 str r5, [r0]
switch (req)
472c: 0a0002b5 beq 5208 <bsp_section_rodata_size+0x354>
4730: 8a000007 bhi 4754 <rtems_fdisk_ioctl+0x88>
4734: e2433002 sub r3, r3, #2
4738: e1570003 cmp r7, r3
473c: 0a000294 beq 5194 <bsp_section_rodata_size+0x2e0>
4740: 8a00029b bhi 51b4 <bsp_section_rodata_size+0x300>
4744: e2433001 sub r3, r3, #1
4748: e1570003 cmp r7, r3
474c: 1a000441 bne 5858 <bsp_section_rodata_size+0x9a4>
4750: ea000257 b 50b4 <bsp_section_rodata_size+0x200> <== NOT EXECUTED
4754: e59f3f34 ldr r3, [pc, #3892] ; 5690 <bsp_section_rodata_size+0x7dc>
4758: e1570003 cmp r7, r3
475c: 0a000313 beq 53b0 <bsp_section_rodata_size+0x4fc>
4760: 3a00030d bcc 539c <bsp_section_rodata_size+0x4e8>
4764: e59f3f28 ldr r3, [pc, #3880] ; 5694 <bsp_section_rodata_size+0x7e0>
4768: e1570003 cmp r7, r3
476c: 1a000439 bne 5858 <bsp_section_rodata_size+0x9a4>
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
4770: e5963004 ldr r3, [r6, #4]
4774: e1580003 cmp r8, r3
4778: 2a000005 bcs 4794 <rtems_fdisk_ioctl+0xc8>
(rtems_flashdisks[minor].device_count == 0))
477c: e5963000 ldr r3, [r6]
4780: e59dc034 ldr ip, [sp, #52] ; 0x34
4784: e083300c add r3, r3, ip
{
errno = 0;
switch (req)
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
4788: e5933030 ldr r3, [r3, #48] ; 0x30
478c: e3530000 cmp r3, #0
4790: 1a000002 bne 47a0 <rtems_fdisk_ioctl+0xd4>
(rtems_flashdisks[minor].device_count == 0))
{
errno = ENODEV;
4794: eb00638e bl 1d5d4 <__errno> <== NOT EXECUTED
4798: e3a03013 mov r3, #19 <== NOT EXECUTED
479c: ea000242 b 50ac <bsp_section_rodata_size+0x1f8> <== NOT EXECUTED
}
else
{
switch (r->req)
47a0: e5945000 ldr r5, [r4]
47a4: e3550000 cmp r5, #0
47a8: 0a000002 beq 47b8 <rtems_fdisk_ioctl+0xec>
47ac: e3550001 cmp r5, #1
47b0: 1a00023b bne 50a4 <bsp_section_rodata_size+0x1f0>
47b4: ea0000b8 b 4a9c <rtems_fdisk_ioctl+0x3d0>
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
47b8: eb006385 bl 1d5d4 <__errno>
47bc: e5966000 ldr r6, [r6]
47c0: e59dc034 ldr ip, [sp, #52] ; 0x34
47c4: e58d0044 str r0, [sp, #68] ; 0x44
47c8: e086600c add r6, r6, ip
* @retval 0 Always. The request done callback contains the status.
*/
static int
rtems_fdisk_read (rtems_flashdisk* fd, rtems_blkdev_request* req)
{
rtems_blkdev_sg_buffer* sg = req->bufs;
47cc: e2848018 add r8, r4, #24
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
47d0: e58d5038 str r5, [sp, #56] ; 0x38
47d4: e1a09004 mov r9, r4
47d8: ea0000a0 b 4a60 <rtems_fdisk_ioctl+0x394>
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
47dc: e5980004 ldr r0, [r8, #4]
47e0: e5961014 ldr r1, [r6, #20]
47e4: ebfff455 bl 1940 <__aeabi_uidiv>
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
47e8: e3a0c000 mov ip, #0
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
47ec: e58d003c str r0, [sp, #60] ; 0x3c
data = sg->buffer;
47f0: e5987008 ldr r7, [r8, #8]
for (b = 0; b < fb; b++, data += fd->block_size)
47f4: e58dc030 str ip, [sp, #48] ; 0x30
47f8: e58d902c str r9, [sp, #44] ; 0x2c
47fc: ea00008b b 4a30 <rtems_fdisk_ioctl+0x364>
{
ret = rtems_fdisk_read_block (fd, sg->block + b, data);
4800: e5985000 ldr r5, [r8]
4804: e59dc030 ldr ip, [sp, #48] ; 0x30
4808: e08c5005 add r5, ip, r5
rtems_fdisk_block_ctl* bc;
rtems_fdisk_segment_ctl* sc;
rtems_fdisk_page_desc* pd;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block:%d", block);
480c: e1a00006 mov r0, r6
4810: e59f1e80 ldr r1, [pc, #3712] ; 5698 <bsp_section_rodata_size+0x7e4>
4814: e1a02005 mov r2, r5
4818: ebfffbcc bl 3750 <rtems_fdisk_info>
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
481c: e286e01c add lr, r6, #28
4820: e89e4008 ldm lr, {r3, lr}
4824: e043300e sub r3, r3, lr
4828: e1550003 cmp r5, r3
482c: 3a000004 bcc 4844 <rtems_fdisk_ioctl+0x178>
{
rtems_fdisk_error ("read-block: block out of range: %d", block);
4830: e1a01005 mov r1, r5 <== NOT EXECUTED
4834: e59f0e60 ldr r0, [pc, #3680] ; 569c <bsp_section_rodata_size+0x7e8><== NOT EXECUTED
4838: e59d902c ldr r9, [sp, #44] ; 0x2c <== NOT EXECUTED
483c: ebfffcae bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
4840: ea000078 b 4a28 <rtems_fdisk_ioctl+0x35c> <== NOT EXECUTED
return EIO;
}
bc = &fd->blocks[block];
4844: e5963018 ldr r3, [r6, #24]
if (!bc->segment)
4848: e7934185 ldr r4, [r3, r5, lsl #3]
484c: e3540000 cmp r4, #0
{
rtems_fdisk_error ("read-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
4850: e083a185 add sl, r3, r5, lsl #3
if (!bc->segment)
4854: 1a000008 bne 487c <rtems_fdisk_ioctl+0x1b0>
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block: no segment mapping: %d", block);
4858: e1a02005 mov r2, r5
485c: e1a00006 mov r0, r6
4860: e59f1e38 ldr r1, [pc, #3640] ; 56a0 <bsp_section_rodata_size+0x7ec>
4864: ebfffbb9 bl 3750 <rtems_fdisk_info>
#endif
memset (buffer, 0xff, fd->block_size);
4868: e1a00007 mov r0, r7
486c: e3a010ff mov r1, #255 ; 0xff
4870: e5962014 ldr r2, [r6, #20]
4874: eb0067fb bl 1e868 <memset>
4878: ea00040b b 58ac <bsp_section_rodata_size+0x9f8>
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
487c: e5940014 ldr r0, [r4, #20]
4880: e58d0040 str r0, [sp, #64] ; 0x40
4884: e5940024 ldr r0, [r4, #36] ; 0x24
4888: e594e020 ldr lr, [r4, #32]
488c: e594101c ldr r1, [r4, #28]
4890: e58d004c str r0, [sp, #76] ; 0x4c
4894: e5940000 ldr r0, [r4]
4898: e58de048 str lr, [sp, #72] ; 0x48
489c: e59fee00 ldr lr, [pc, #3584] ; 56a4 <bsp_section_rodata_size+0x7f0>
48a0: e3500000 cmp r0, #0
48a4: e58d1054 str r1, [sp, #84] ; 0x54
48a8: e59f1df8 ldr r1, [pc, #3576] ; 56a8 <bsp_section_rodata_size+0x7f4>
48ac: 11a0100e movne r1, lr
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
48b0: e59a2004 ldr r2, [sl, #4]
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
48b4: e58d1050 str r1, [sp, #80] ; 0x50
48b8: e594100c ldr r1, [r4, #12]
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
48bc: e594b010 ldr fp, [r4, #16]
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
48c0: e5943008 ldr r3, [r4, #8]
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
48c4: e1a0c182 lsl ip, r2, #3
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
48c8: e88d0006 stm sp, {r1, r2}
48cc: e59d2040 ldr r2, [sp, #64] ; 0x40
48d0: e59d0048 ldr r0, [sp, #72] ; 0x48
48d4: e58d2008 str r2, [sp, #8]
48d8: e59d104c ldr r1, [sp, #76] ; 0x4c
48dc: e59d2050 ldr r2, [sp, #80] ; 0x50
48e0: e59de054 ldr lr, [sp, #84] ; 0x54
48e4: e58d0010 str r0, [sp, #16]
48e8: e58d1014 str r1, [sp, #20]
48ec: e58de00c str lr, [sp, #12]
48f0: e58d2018 str r2, [sp, #24]
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
48f4: e08b900c add r9, fp, ip
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
48f8: e1d920b2 ldrh r2, [r9, #2]
48fc: e58d201c str r2, [sp, #28]
4900: e19b20bc ldrh r2, [fp, ip]
4904: e58d2020 str r2, [sp, #32]
4908: e5992004 ldr r2, [r9, #4]
490c: e1a00006 mov r0, r6
4910: e58d2024 str r2, [sp, #36] ; 0x24
4914: e59f1d90 ldr r1, [pc, #3472] ; 56ac <bsp_section_rodata_size+0x7f8>
4918: e1a02005 mov r2, r5
491c: e58dc028 str ip, [sp, #40] ; 0x28
4920: ebfffb8a bl 3750 <rtems_fdisk_info>
* only set a flag by changing it from 1 to 0.
*/
static bool
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{
return (pd->flags & flags) == 0 ? true : false;
4924: e1d930b2 ldrh r3, [r9, #2]
sc->pages, sc->pages_active, sc->pages_used, sc->pages_bad,
sc->next ? "set" : "null",
pd->flags, pd->crc, pd->block);
#endif
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
4928: e3130001 tst r3, #1
492c: 1a000035 bne 4a08 <rtems_fdisk_ioctl+0x33c>
{
if (rtems_fdisk_page_desc_flags_clear (pd, RTEMS_FDISK_PAGE_USED))
4930: e3130002 tst r3, #2
4934: e59a2004 ldr r2, [sl, #4]
4938: 0a00002e beq 49f8 <rtems_fdisk_ioctl+0x32c>
/*
* We use the segment page offset not the page number used in the
* driver. This skips the page descriptors.
*/
int ret = rtems_fdisk_seg_read_page (fd, sc,
493c: e5941018 ldr r1, [r4, #24]
rtems_fdisk_segment_ctl* sc,
uint32_t page,
void* buffer)
{
return rtems_fdisk_seg_read (fd, sc,
page * fd->block_size, buffer, fd->block_size);
4940: e5963014 ldr r3, [r6, #20]
/*
* We use the segment page offset not the page number used in the
* driver. This skips the page descriptors.
*/
int ret = rtems_fdisk_seg_read_page (fd, sc,
4944: e0812002 add r2, r1, r2
rtems_fdisk_seg_read_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page,
void* buffer)
{
return rtems_fdisk_seg_read (fd, sc,
4948: e58d3000 str r3, [sp]
494c: e0020293 mul r2, r3, r2
4950: e1a00006 mov r0, r6
4954: e1a03007 mov r3, r7
4958: e1a01004 mov r1, r4
495c: ebfffbbb bl 3850 <rtems_fdisk_seg_read>
* driver. This skips the page descriptors.
*/
int ret = rtems_fdisk_seg_read_page (fd, sc,
bc->page + sc->pages_desc, buffer);
if (ret)
4960: e2503000 subs r3, r0, #0
4964: e59dc028 ldr ip, [sp, #40] ; 0x28
4968: 0a00000d beq 49a4 <rtems_fdisk_ioctl+0x2d8>
496c: e1a0b003 mov fp, r3 <== NOT EXECUTED
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
4970: e5945008 ldr r5, [r4, #8] <== NOT EXECUTED
4974: e59a7004 ldr r7, [sl, #4] <== NOT EXECUTED
4978: e594400c ldr r4, [r4, #12] <== NOT EXECUTED
497c: e59d902c ldr r9, [sp, #44] ; 0x2c <== NOT EXECUTED
4980: eb006cd7 bl 1fce4 <strerror> <== NOT EXECUTED
4984: e59f1d24 ldr r1, [pc, #3364] ; 56b0 <bsp_section_rodata_size+0x7fc><== NOT EXECUTED
4988: e98d0801 stmib sp, {r0, fp} <== NOT EXECUTED
498c: e1a02005 mov r2, r5 <== NOT EXECUTED
4990: e1a00006 mov r0, r6 <== NOT EXECUTED
4994: e1a03004 mov r3, r4 <== NOT EXECUTED
4998: e58d7000 str r7, [sp] <== NOT EXECUTED
499c: ebfffb6b bl 3750 <rtems_fdisk_info> <== NOT EXECUTED
49a0: ea000020 b 4a28 <rtems_fdisk_ioctl+0x35c> <== NOT EXECUTED
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
49a4: e59fecdc ldr lr, [pc, #3292] ; 5688 <bsp_section_rodata_size+0x7d4>
strerror (ret), ret);
#endif
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
49a8: e5960014 ldr r0, [r6, #20]
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
49ac: e59e1008 ldr r1, [lr, #8]
* Calculate the checksum of a page in a segment.
*/
static uint16_t
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
49b0: e59f2cfc ldr r2, [pc, #3324] ; 56b4 <bsp_section_rodata_size+0x800>
49b4: ea000005 b 49d0 <rtems_fdisk_ioctl+0x304>
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
49b8: e7d7e003 ldrb lr, [r7, r3]
49bc: e02e2002 eor r2, lr, r2
49c0: e20220ff and r2, r2, #255 ; 0xff
49c4: e1a02082 lsl r2, r2, #1
49c8: e19120b2 ldrh r2, [r1, r2]
rtems_fdisk_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++)
49cc: e2833001 add r3, r3, #1
49d0: e1530000 cmp r3, r0
49d4: 1afffff7 bne 49b8 <rtems_fdisk_ioctl+0x2ec>
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
if (cs == pd->crc)
49d8: e19b30bc ldrh r3, [fp, ip]
49dc: e1520003 cmp r2, r3
49e0: 0a0003b1 beq 58ac <bsp_section_rodata_size+0x9f8>
return 0;
rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
49e4: e1a01005 mov r1, r5 <== NOT EXECUTED
49e8: e59f0cc8 ldr r0, [pc, #3272] ; 56b8 <bsp_section_rodata_size+0x804><== NOT EXECUTED
49ec: e59d902c ldr r9, [sp, #44] ; 0x2c <== NOT EXECUTED
49f0: ebfffc41 bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
49f4: ea00000b b 4a28 <rtems_fdisk_ioctl+0x35c> <== NOT EXECUTED
49f8: e59d902c ldr r9, [sp, #44] ; 0x2c <== NOT EXECUTED
block, cs, pd->crc);
}
else
{
rtems_fdisk_error ("read-block: block points to used page: %d: %d-%d-%d",
49fc: e58d2000 str r2, [sp] <== NOT EXECUTED
4a00: e59f0cb4 ldr r0, [pc, #3252] ; 56bc <bsp_section_rodata_size+0x808><== NOT EXECUTED
4a04: ea000003 b 4a18 <rtems_fdisk_ioctl+0x34c> <== NOT EXECUTED
block, sc->device, sc->segment, bc->page);
}
}
else
{
rtems_fdisk_error ("read-block: block page not active: %d: %d-%d-%d",
4a08: e59a3004 ldr r3, [sl, #4] <== NOT EXECUTED
4a0c: e59d902c ldr r9, [sp, #44] ; 0x2c <== NOT EXECUTED
4a10: e58d3000 str r3, [sp] <== NOT EXECUTED
4a14: e59f0ca4 ldr r0, [pc, #3236] ; 56c0 <bsp_section_rodata_size+0x80c><== NOT EXECUTED
4a18: e2842008 add r2, r4, #8 <== NOT EXECUTED
4a1c: e1a01005 mov r1, r5 <== NOT EXECUTED
4a20: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
4a24: ebfffc34 bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
4a28: e3a03001 mov r3, #1 <== NOT EXECUTED
4a2c: ea000005 b 4a48 <rtems_fdisk_ioctl+0x37c> <== NOT EXECUTED
4a30: e59dc030 ldr ip, [sp, #48] ; 0x30
4a34: e59de03c ldr lr, [sp, #60] ; 0x3c
4a38: e15c000e cmp ip, lr
4a3c: 1affff6f bne 4800 <rtems_fdisk_ioctl+0x134>
4a40: e59d902c ldr r9, [sp, #44] ; 0x2c
4a44: e3a03000 mov r3, #0
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
4a48: e59dc038 ldr ip, [sp, #56] ; 0x38
4a4c: e3530000 cmp r3, #0
4a50: e28cc001 add ip, ip, #1
4a54: e58dc038 str ip, [sp, #56] ; 0x38
4a58: e2888010 add r8, r8, #16
4a5c: 1a000006 bne 4a7c <rtems_fdisk_ioctl+0x3b0>
4a60: e5993010 ldr r3, [r9, #16]
4a64: e59dc038 ldr ip, [sp, #56] ; 0x38
4a68: e15c0003 cmp ip, r3
4a6c: 3affff5a bcc 47dc <rtems_fdisk_ioctl+0x110>
4a70: e1a04009 mov r4, r9
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
4a74: e3a01000 mov r1, #0
4a78: ea000001 b 4a84 <rtems_fdisk_ioctl+0x3b8>
4a7c: e1a04009 mov r4, r9 <== NOT EXECUTED
4a80: e3a0101b mov r1, #27 <== NOT EXECUTED
static inline void rtems_blkdev_request_done(
rtems_blkdev_request *req,
rtems_status_code status
)
{
(*req->done)(req, status);
4a84: e1a00004 mov r0, r4
4a88: e1a0e00f mov lr, pc
4a8c: e594f004 ldr pc, [r4, #4]
else
{
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
4a90: e3a03000 mov r3, #0
4a94: e59dc044 ldr ip, [sp, #68] ; 0x44
4a98: ea00017f b 509c <bsp_section_rodata_size+0x1e8>
break;
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
4a9c: eb0062cc bl 1d5d4 <__errno>
4aa0: e59f3be0 ldr r3, [pc, #3040] ; 5688 <bsp_section_rodata_size+0x7d4>
4aa4: e59dc034 ldr ip, [sp, #52] ; 0x34
4aa8: e5935000 ldr r5, [r3]
4aac: e085500c add r5, r5, ip
* @retval 0 Always. The request done callback contains the status.
*/
static int
rtems_fdisk_write (rtems_flashdisk* fd, rtems_blkdev_request* req)
{
rtems_blkdev_sg_buffer* sg = req->bufs;
4ab0: e284c018 add ip, r4, #24
4ab4: e58dc02c str ip, [sp, #44] ; 0x2c
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
4ab8: e3a0c000 mov ip, #0
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
break;
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
4abc: e58d004c str r0, [sp, #76] ; 0x4c
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
4ac0: e58dc044 str ip, [sp, #68] ; 0x44
4ac4: e1a0b004 mov fp, r4
4ac8: ea000165 b 5064 <bsp_section_rodata_size+0x1b0>
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
4acc: e59dc02c ldr ip, [sp, #44] ; 0x2c
4ad0: e5951014 ldr r1, [r5, #20]
4ad4: e59c0004 ldr r0, [ip, #4]
4ad8: ebfff398 bl 1940 <__aeabi_uidiv>
data = sg->buffer;
4adc: e59dc02c ldr ip, [sp, #44] ; 0x2c
4ae0: e59c9008 ldr r9, [ip, #8]
for (b = 0; b < fb; b++, data += fd->block_size)
4ae4: e3a0c000 mov ip, #0
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
4ae8: e58d0050 str r0, [sp, #80] ; 0x50
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
4aec: e58dc038 str ip, [sp, #56] ; 0x38
4af0: e58db030 str fp, [sp, #48] ; 0x30
4af4: ea00014a b 5024 <bsp_section_rodata_size+0x170>
{
ret = rtems_fdisk_write_block (fd, sg->block + b, data);
4af8: e59dc02c ldr ip, [sp, #44] ; 0x2c
4afc: e59c6000 ldr r6, [ip]
4b00: e59dc038 ldr ip, [sp, #56] ; 0x38
4b04: e08c6006 add r6, ip, r6
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d", block);
4b08: e1a00005 mov r0, r5
4b0c: e59f1bb0 ldr r1, [pc, #2992] ; 56c4 <bsp_section_rodata_size+0x810>
4b10: e1a02006 mov r2, r6
4b14: ebfffb0d bl 3750 <rtems_fdisk_info>
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
4b18: e285e01c add lr, r5, #28
4b1c: e89e4008 ldm lr, {r3, lr}
4b20: e043300e sub r3, r3, lr
4b24: e1560003 cmp r6, r3
4b28: 3a000004 bcc 4b40 <rtems_fdisk_ioctl+0x474>
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
4b2c: e1a01006 mov r1, r6 <== NOT EXECUTED
4b30: e59f0b90 ldr r0, [pc, #2960] ; 56c8 <bsp_section_rodata_size+0x814><== NOT EXECUTED
4b34: e59db030 ldr fp, [sp, #48] ; 0x30 <== NOT EXECUTED
4b38: ebfffbef bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
4b3c: ea00012f b 5000 <bsp_section_rodata_size+0x14c> <== NOT EXECUTED
return EIO;
}
bc = &fd->blocks[block];
4b40: e595c018 ldr ip, [r5, #24]
/*
* Does the page exist in flash ?
*/
if (bc->segment)
4b44: e79c4186 ldr r4, [ip, r6, lsl #3]
4b48: e3540000 cmp r4, #0
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
4b4c: e58dc03c str ip, [sp, #60] ; 0x3c
4b50: e08ca186 add sl, ip, r6, lsl #3
/*
* Does the page exist in flash ?
*/
if (bc->segment)
4b54: 0a000080 beq 4d5c <rtems_fdisk_ioctl+0x690>
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
4b58: e594c010 ldr ip, [r4, #16]
4b5c: e58dc054 str ip, [sp, #84] ; 0x54
4b60: e59ac004 ldr ip, [sl, #4]
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
4b64: e58dc000 str ip, [sp]
4b68: e2842008 add r2, r4, #8
4b6c: e892000c ldm r2, {r2, r3}
4b70: e59f1b54 ldr r1, [pc, #2900] ; 56cc <bsp_section_rodata_size+0x818>
4b74: e1a00005 mov r0, r5
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
4b78: e58dc040 str ip, [sp, #64] ; 0x40
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
4b7c: ebfffaf3 bl 3750 <rtems_fdisk_info>
#endif
/*
* The page exists in flash so see if the page has been changed.
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
4b80: e5942018 ldr r2, [r4, #24]
4b84: e59a3004 ldr r3, [sl, #4]
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
page * fd->block_size, buffer, fd->block_size);
4b88: e5958014 ldr r8, [r5, #20]
#endif
/*
* The page exists in flash so see if the page has been changed.
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
4b8c: e284b008 add fp, r4, #8
4b90: e89b1800 ldm fp, {fp, ip}
4b94: e0823003 add r3, r2, r3
uint32_t device,
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
4b98: e00e0398 mul lr, r8, r3
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
4b9c: e3a0300c mov r3, #12
4ba0: e003039b mul r3, fp, r3
4ba4: e595102c ldr r1, [r5, #44] ; 0x2c
4ba8: e0812003 add r2, r1, r3
4bac: e7913003 ldr r3, [r1, r3]
4bb0: e3a01030 mov r1, #48 ; 0x30
4bb4: e0233c91 mla r3, r1, ip, r3
4bb8: e5933004 ldr r3, [r3, #4]
4bbc: e58d3058 str r3, [sp, #88] ; 0x58
uint32_t size)
{
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
4bc0: e5923008 ldr r3, [r2, #8]
#if RTEMS_FDISK_TRACE rtems_fdisk_printf (fd, " seg-verify: %02d-%03d: o=%08x s=%d",
4bc4: e59f1b04 ldr r1, [pc, #2820] ; 56d0 <bsp_section_rodata_size+0x81c>
uint32_t size)
{
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
4bc8: e5937008 ldr r7, [r3, #8]
#if RTEMS_FDISK_TRACE rtems_fdisk_printf (fd, " seg-verify: %02d-%03d: o=%08x s=%d",
4bcc: e1a0200b mov r2, fp
4bd0: e1a0300c mov r3, ip
4bd4: e1a00005 mov r0, r5
uint32_t device,
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
4bd8: e58de048 str lr, [sp, #72] ; 0x48
const rtems_fdisk_segment_desc* sd; const rtems_fdisk_driver_handlers* ops; sd = rtems_fdisk_seg_descriptor (fd, device, segment); ops = fd->devices[device].descriptor->flash_ops; #if RTEMS_FDISK_TRACE rtems_fdisk_printf (fd, " seg-verify: %02d-%03d: o=%08x s=%d",
4bdc: e58de000 str lr, [sp]
4be0: e58dc028 str ip, [sp, #40] ; 0x28
4be4: e58d8004 str r8, [sp, #4]
4be8: ebfffaf8 bl 37d0 <rtems_fdisk_printf>
device, segment, offset, size);
#endif
return ops->verify (sd, device, segment, offset, buffer, size);
4bec: e59dc028 ldr ip, [sp, #40] ; 0x28
4bf0: e58d9000 str r9, [sp]
4bf4: e58d8004 str r8, [sp, #4]
4bf8: e59d0058 ldr r0, [sp, #88] ; 0x58
4bfc: e1a0100b mov r1, fp
4c00: e1a0200c mov r2, ip
4c04: e59d3048 ldr r3, [sp, #72] ; 0x48
4c08: e1a0e00f mov lr, pc
4c0c: e597f00c ldr pc, [r7, #12]
#endif
/*
* The page exists in flash so see if the page has been changed.
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
4c10: e3500000 cmp r0, #0
4c14: 1a000009 bne 4c40 <rtems_fdisk_ioctl+0x574>
bc->page + sc->pages_desc, buffer) == 0)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d=>%02d-%03d-%03d: page verified",
4c18: e594300c ldr r3, [r4, #12]
4c1c: e58d3000 str r3, [sp]
4c20: e59a3004 ldr r3, [sl, #4]
4c24: e58d3004 str r3, [sp, #4]
4c28: e1a00005 mov r0, r5
4c2c: e59f1aa0 ldr r1, [pc, #2720] ; 56d4 <bsp_section_rodata_size+0x820>
4c30: e1a02006 mov r2, r6
4c34: e5943008 ldr r3, [r4, #8]
4c38: ebfffac4 bl 3750 <rtems_fdisk_info>
4c3c: ea0000f3 b 5010 <bsp_section_rodata_size+0x15c>
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
4c40: e59dc054 ldr ip, [sp, #84] ; 0x54
4c44: e59de040 ldr lr, [sp, #64] ; 0x40
4c48: e08c718e add r7, ip, lr, lsl #3
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
4c4c: e1d730b2 ldrh r3, [r7, #2]
4c50: e3c33002 bic r3, r3, #2
4c54: e1c730b2 strh r3, [r7, #2]
* matches the flash device.
*/
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
ret = rtems_fdisk_seg_write_page_desc_flags (fd, sc, bc->page, pd);
4c58: e59a8004 ldr r8, [sl, #4]
uint32_t page,
const rtems_fdisk_page_desc* page_desc)
{
uint32_t offset = ((page * sizeof (rtems_fdisk_page_desc)) +
((uint8_t*) &page_desc->flags) - ((uint8_t*) page_desc));
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
4c5c: e5953008 ldr r3, [r5, #8]
rtems_fdisk_seg_write_page_desc_flags (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page,
const rtems_fdisk_page_desc* page_desc)
{
uint32_t offset = ((page * sizeof (rtems_fdisk_page_desc)) +
4c60: e1a0b188 lsl fp, r8, #3
((uint8_t*) &page_desc->flags) - ((uint8_t*) page_desc));
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
4c64: e3130008 tst r3, #8
rtems_fdisk_segment_ctl* sc,
uint32_t page,
const rtems_fdisk_page_desc* page_desc)
{
uint32_t offset = ((page * sizeof (rtems_fdisk_page_desc)) +
((uint8_t*) &page_desc->flags) - ((uint8_t*) page_desc));
4c68: e28bb002 add fp, fp, #2
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
4c6c: 0a000014 beq 4cc4 <rtems_fdisk_ioctl+0x5f8>
{
uint16_t flash_flags;
int ret;
ret = rtems_fdisk_seg_read (fd, sc, offset,
4c70: e3a03002 mov r3, #2
4c74: e58d3000 str r3, [sp]
4c78: e1a00005 mov r0, r5
4c7c: e28d3062 add r3, sp, #98 ; 0x62
4c80: e1a01004 mov r1, r4
4c84: e1a0200b mov r2, fp
4c88: ebfffaf0 bl 3850 <rtems_fdisk_seg_read>
&flash_flags, sizeof (flash_flags));
if (ret)
4c8c: e2503000 subs r3, r0, #0
4c90: 1a000014 bne 4ce8 <rtems_fdisk_ioctl+0x61c>
return ret;
if ((flash_flags & page_desc->flags) != page_desc->flags)
4c94: e1d730b2 ldrh r3, [r7, #2]
4c98: e1dd26b2 ldrh r2, [sp, #98] ; 0x62
4c9c: e0031002 and r1, r3, r2
4ca0: e1510003 cmp r1, r3
4ca4: 0a000006 beq 4cc4 <rtems_fdisk_ioctl+0x5f8>
{
rtems_fdisk_error (" seg-write-page-flags: %02d-%03d-%03d: "
4ca8: e88d000c stm sp, {r2, r3} <== NOT EXECUTED
4cac: e2841008 add r1, r4, #8 <== NOT EXECUTED
4cb0: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
4cb4: e1a03008 mov r3, r8 <== NOT EXECUTED
4cb8: e59f0a18 ldr r0, [pc, #2584] ; 56d8 <bsp_section_rodata_size+0x824><== NOT EXECUTED
4cbc: ebfffb8e bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
4cc0: ea000018 b 4d28 <rtems_fdisk_ioctl+0x65c> <== NOT EXECUTED
sc->device, sc->segment, page,
flash_flags, page_desc->flags);
return ret;
}
}
return rtems_fdisk_seg_write (fd, sc, offset,
4cc4: e3a03002 mov r3, #2
4cc8: e58d3000 str r3, [sp]
4ccc: e1a00005 mov r0, r5
4cd0: e0873003 add r3, r7, r3
4cd4: e1a01004 mov r1, r4
4cd8: e1a0200b mov r2, fp
4cdc: ebfffb17 bl 3940 <rtems_fdisk_seg_write>
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
ret = rtems_fdisk_seg_write_page_desc_flags (fd, sc, bc->page, pd);
if (ret)
4ce0: e2503000 subs r3, r0, #0
4ce4: 0a00000f beq 4d28 <rtems_fdisk_ioctl+0x65c>
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: " \
4ce8: e1a00003 mov r0, r3 <== NOT EXECUTED
4cec: e5948008 ldr r8, [r4, #8] <== NOT EXECUTED
4cf0: e594700c ldr r7, [r4, #12] <== NOT EXECUTED
4cf4: e59ab004 ldr fp, [sl, #4] <== NOT EXECUTED
4cf8: e58d3028 str r3, [sp, #40] ; 0x28 <== NOT EXECUTED
4cfc: eb006bf8 bl 1fce4 <strerror> <== NOT EXECUTED
4d00: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED
4d04: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
4d08: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
4d0c: e1a00005 mov r0, r5 <== NOT EXECUTED
4d10: e59f19c4 ldr r1, [pc, #2500] ; 56dc <bsp_section_rodata_size+0x828><== NOT EXECUTED
4d14: e1a02008 mov r2, r8 <== NOT EXECUTED
4d18: e1a03007 mov r3, r7 <== NOT EXECUTED
4d1c: e58db000 str fp, [sp] <== NOT EXECUTED
4d20: ebfffa8a bl 3750 <rtems_fdisk_info> <== NOT EXECUTED
4d24: ea000005 b 4d40 <rtems_fdisk_ioctl+0x674> <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
4d28: e594301c ldr r3, [r4, #28]
4d2c: e2433001 sub r3, r3, #1
4d30: e584301c str r3, [r4, #28]
sc->pages_used++;
4d34: e5943020 ldr r3, [r4, #32]
4d38: e2833001 add r3, r3, #1
4d3c: e5843020 str r3, [r4, #32]
/*
* If possible reuse this segment. This will mean the segment
* needs to be removed from the available list and placed
* back if space is still available.
*/
rtems_fdisk_queue_segment (fd, sc);
4d40: e1a00005 mov r0, r5
4d44: e1a01004 mov r1, r4
4d48: ebfffbc6 bl 3c68 <rtems_fdisk_queue_segment>
/*
* If no background compacting then compact in the forground.
* If we compact we ignore the error as there is little we
* can do from here. The write may will work.
*/
if ((fd->flags & RTEMS_FDISK_BACKGROUND_COMPACT) == 0)
4d4c: e5953008 ldr r3, [r5, #8]
4d50: e3130002 tst r3, #2
rtems_fdisk_compact (fd);
4d54: 01a00005 moveq r0, r5
4d58: 0bfffd19 bleq 41c4 <rtems_fdisk_compact>
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
4d5c: e5952034 ldr r2, [r5, #52] ; 0x34
uint32_t count = 0;
4d60: e3a03000 mov r3, #0
4d64: ea000001 b 4d70 <rtems_fdisk_ioctl+0x6a4>
while (sc)
{
count++;
sc = sc->next;
4d68: e5922000 ldr r2, [r2]
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
{
count++;
4d6c: e2833001 add r3, r3, #1
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
4d70: e3520000 cmp r2, #0
4d74: 1afffffb bne 4d68 <rtems_fdisk_ioctl+0x69c>
/*
* Is it time to compact the disk ?
*
* We override the background compaction configruation.
*/
if (rtems_fdisk_segment_count_queue (&fd->available) <=
4d78: e5952010 ldr r2, [r5, #16]
4d7c: e1530002 cmp r3, r2
fd->avail_compact_segs)
rtems_fdisk_compact (fd);
4d80: 91a00005 movls r0, r5
4d84: 9bfffd0e blls 41c4 <rtems_fdisk_compact>
/*
* Get the next avaliable segment.
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
4d88: e2857034 add r7, r5, #52 ; 0x34
4d8c: e1a00007 mov r0, r7
4d90: ebfff9d3 bl 34e4 <rtems_fdisk_segment_queue_pop_head>
/*
* Is the flash disk full ?
*/
if (!sc)
4d94: e2504000 subs r4, r0, #0
4d98: 1a00000c bne 4dd0 <rtems_fdisk_ioctl+0x704>
{
/*
* If compacting is configured for the background do it now
* to see if we can get some space back.
*/
if ((fd->flags & RTEMS_FDISK_BACKGROUND_COMPACT))
4d9c: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
4da0: e3130002 tst r3, #2 <== NOT EXECUTED
rtems_fdisk_compact (fd);
4da4: 11a00005 movne r0, r5 <== NOT EXECUTED
4da8: 1bfffd05 blne 41c4 <rtems_fdisk_compact> <== NOT EXECUTED
/*
* Try again for some free space.
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
4dac: e1a00007 mov r0, r7 <== NOT EXECUTED
4db0: ebfff9cb bl 34e4 <rtems_fdisk_segment_queue_pop_head> <== NOT EXECUTED
if (!sc)
4db4: e2504000 subs r4, r0, #0 <== NOT EXECUTED
4db8: 1a000004 bne 4dd0 <rtems_fdisk_ioctl+0x704> <== NOT EXECUTED
{
rtems_fdisk_error ("write-block: no available pages");
4dbc: e59f091c ldr r0, [pc, #2332] ; 56e0 <bsp_section_rodata_size+0x82c><== NOT EXECUTED
4dc0: e59db030 ldr fp, [sp, #48] ; 0x30 <== NOT EXECUTED
return ENOSPC;
4dc4: e3a0601c mov r6, #28 <== NOT EXECUTED
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
if (!sc)
{
rtems_fdisk_error ("write-block: no available pages");
4dc8: ebfffb4b bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
4dcc: ea00009c b 5044 <bsp_section_rodata_size+0x190> <== NOT EXECUTED
return ENOSPC;
}
}
#if RTEMS_FDISK_TRACE
if (fd->info_level >= 3)
4dd0: e595306c ldr r3, [r5, #108] ; 0x6c
4dd4: e3530002 cmp r3, #2
4dd8: 9a00000b bls 4e0c <rtems_fdisk_ioctl+0x740>
{
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
4ddc: e28d705c add r7, sp, #92 ; 0x5c <== NOT EXECUTED
4de0: e1a00005 mov r0, r5 <== NOT EXECUTED
4de4: e1a01004 mov r1, r4 <== NOT EXECUTED
4de8: e1a02007 mov r2, r7 <== NOT EXECUTED
4dec: ebfffa06 bl 360c <rtems_fdisk_queue_status> <== NOT EXECUTED
rtems_fdisk_info (fd, " write:%d=>%02d-%03d: queue check: %s",
4df0: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
4df4: e88d0088 stm sp, {r3, r7} <== NOT EXECUTED
4df8: e1a00005 mov r0, r5 <== NOT EXECUTED
4dfc: e59f18e0 ldr r1, [pc, #2272] ; 56e4 <bsp_section_rodata_size+0x830><== NOT EXECUTED
4e00: e1a02006 mov r2, r6 <== NOT EXECUTED
4e04: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
4e08: ebfffa50 bl 3750 <rtems_fdisk_info> <== NOT EXECUTED
/*
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
4e0c: e5948010 ldr r8, [r4, #16]
for (page = 0; page < sc->pages; page++, pd++)
4e10: e3a07000 mov r7, #0
4e14: ea00006c b 4fcc <bsp_section_rodata_size+0x118>
{
if (rtems_fdisk_page_desc_erased (pd))
4e18: e1a00008 mov r0, r8
4e1c: ebfffa29 bl 36c8 <rtems_fdisk_page_desc_erased>
4e20: e3500000 cmp r0, #0
4e24: 0a000066 beq 4fc4 <bsp_section_rodata_size+0x110>
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
4e28: e59f2858 ldr r2, [pc, #2136] ; 5688 <bsp_section_rodata_size+0x7d4>
for (page = 0; page < sc->pages; page++, pd++)
{
if (rtems_fdisk_page_desc_erased (pd))
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
4e2c: e5950014 ldr r0, [r5, #20]
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
4e30: e5921008 ldr r1, [r2, #8]
rtems_fdisk_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++)
4e34: e3a03000 mov r3, #0
* Calculate the checksum of a page in a segment.
*/
static uint16_t
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
4e38: e59f2874 ldr r2, [pc, #2164] ; 56b4 <bsp_section_rodata_size+0x800>
4e3c: ea000005 b 4e58 <rtems_fdisk_ioctl+0x78c>
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
4e40: e7d9c003 ldrb ip, [r9, r3]
4e44: e02c2002 eor r2, ip, r2
4e48: e20220ff and r2, r2, #255 ; 0xff
4e4c: e1a02082 lsl r2, r2, #1
4e50: e19120b2 ldrh r2, [r1, r2]
rtems_fdisk_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++)
4e54: e2833001 add r3, r3, #1
4e58: e1530000 cmp r3, r0
4e5c: 1afffff7 bne 4e40 <rtems_fdisk_ioctl+0x774>
bc->page = page;
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_ACTIVE);
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%d=>%02d-%03d-%03d: write: " \
4e60: e5940020 ldr r0, [r4, #32]
4e64: e594e01c ldr lr, [r4, #28]
if (rtems_fdisk_page_desc_erased (pd))
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
pd->block = block;
bc->segment = sc;
4e68: e59dc03c ldr ip, [sp, #60] ; 0x3c
bc->page = page;
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_ACTIVE);
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%d=>%02d-%03d-%03d: write: " \
4e6c: e58d0040 str r0, [sp, #64] ; 0x40
4e70: e5940000 ldr r0, [r4]
for (page = 0; page < sc->pages; page++, pd++)
{
if (rtems_fdisk_page_desc_erased (pd))
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
4e74: e1c820b0 strh r2, [r8]
pd->block = block;
4e78: e5886004 str r6, [r8, #4]
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
4e7c: e1d810b2 ldrh r1, [r8, #2]
if (rtems_fdisk_page_desc_erased (pd))
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
pd->block = block;
bc->segment = sc;
4e80: e78c4186 str r4, [ip, r6, lsl #3]
bc->page = page;
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_ACTIVE);
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%d=>%02d-%03d-%03d: write: " \
4e84: e58de03c str lr, [sp, #60] ; 0x3c
4e88: e594c024 ldr ip, [r4, #36] ; 0x24
4e8c: e59fe814 ldr lr, [pc, #2068] ; 56a8 <bsp_section_rodata_size+0x7f4>
4e90: e3500000 cmp r0, #0
4e94: e59d003c ldr r0, [sp, #60] ; 0x3c
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
4e98: e3c11001 bic r1, r1, #1
bc->page = page;
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_ACTIVE);
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%d=>%02d-%03d-%03d: write: " \
4e9c: e58dc048 str ip, [sp, #72] ; 0x48
4ea0: e59fc7fc ldr ip, [pc, #2044] ; 56a4 <bsp_section_rodata_size+0x7f0>
4ea4: 01a0c00e moveq ip, lr
4ea8: e594e00c ldr lr, [r4, #12]
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
pd->block = block;
bc->segment = sc;
bc->page = page;
4eac: e58a7004 str r7, [sl, #4]
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_ACTIVE);
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%d=>%02d-%03d-%03d: write: " \
4eb0: e5943008 ldr r3, [r4, #8]
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
4eb4: e1c810b2 strh r1, [r8, #2]
bc->page = page;
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_ACTIVE);
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%d=>%02d-%03d-%03d: write: " \
4eb8: e58d000c str r0, [sp, #12]
4ebc: e59d0048 ldr r0, [sp, #72] ; 0x48
4ec0: e58de000 str lr, [sp]
4ec4: e59de040 ldr lr, [sp, #64] ; 0x40
4ec8: e58d0014 str r0, [sp, #20]
4ecc: e58d101c str r1, [sp, #28]
4ed0: e58d2020 str r2, [sp, #32]
4ed4: e59f180c ldr r1, [pc, #2060] ; 56e8 <bsp_section_rodata_size+0x834>
4ed8: e1a02006 mov r2, r6
4edc: e1a00005 mov r0, r5
4ee0: e58de010 str lr, [sp, #16]
4ee4: e58dc018 str ip, [sp, #24]
4ee8: e58d6024 str r6, [sp, #36] ; 0x24
4eec: e98d0880 stmib sp, {r7, fp}
4ef0: ebfffa16 bl 3750 <rtems_fdisk_info>
/*
* We use the segment page offset not the page number used in the
* driver. This skips the page descriptors.
*/
ret = rtems_fdisk_seg_write_page (fd, sc, page + sc->pages_desc, buffer);
4ef4: e5942018 ldr r2, [r4, #24]
4ef8: e1a00005 mov r0, r5
4efc: e1a01004 mov r1, r4
4f00: e0872002 add r2, r7, r2
4f04: e1a03009 mov r3, r9
4f08: ebfffac4 bl 3a20 <rtems_fdisk_seg_write_page>
if (ret)
4f0c: e2506000 subs r6, r0, #0
4f10: 0a000009 beq 4f3c <bsp_section_rodata_size+0x88>
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: write page failed: " \
4f14: e594a008 ldr sl, [r4, #8] <== NOT EXECUTED
4f18: e594800c ldr r8, [r4, #12] <== NOT EXECUTED
4f1c: eb006b70 bl 1fce4 <strerror> <== NOT EXECUTED
4f20: e58d7000 str r7, [sp] <== NOT EXECUTED
4f24: e98d0041 stmib sp, {r0, r6} <== NOT EXECUTED
4f28: e59f17bc ldr r1, [pc, #1980] ; 56ec <bsp_section_rodata_size+0x838><== NOT EXECUTED
4f2c: e1a00005 mov r0, r5 <== NOT EXECUTED
4f30: e1a0200a mov r2, sl <== NOT EXECUTED
4f34: e1a03008 mov r3, r8 <== NOT EXECUTED
4f38: ea000013 b 4f8c <bsp_section_rodata_size+0xd8> <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
ret = rtems_fdisk_seg_write_page_desc (fd, sc, page, pd);
4f3c: e1a03008 mov r3, r8
4f40: e1a00005 mov r0, r5
4f44: e1a01004 mov r1, r4
4f48: e1a02007 mov r2, r7
4f4c: ebfffa9e bl 39cc <rtems_fdisk_seg_write_page_desc>
if (ret)
4f50: e2506000 subs r6, r0, #0
strerror (ret), ret);
#endif
}
else
{
sc->pages_active++;
4f54: 0594301c ldreq r3, [r4, #28]
4f58: 02833001 addeq r3, r3, #1
4f5c: 0584301c streq r3, [r4, #28]
#endif
}
else
{
ret = rtems_fdisk_seg_write_page_desc (fd, sc, page, pd);
if (ret)
4f60: 0a00000a beq 4f90 <bsp_section_rodata_size+0xdc>
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: " \
4f64: e5948008 ldr r8, [r4, #8] <== NOT EXECUTED
4f68: e594700c ldr r7, [r4, #12] <== NOT EXECUTED
4f6c: e59aa004 ldr sl, [sl, #4] <== NOT EXECUTED
4f70: eb006b5b bl 1fce4 <strerror> <== NOT EXECUTED
4f74: e58da000 str sl, [sp] <== NOT EXECUTED
4f78: e59f1770 ldr r1, [pc, #1904] ; 56f0 <bsp_section_rodata_size+0x83c><== NOT EXECUTED
4f7c: e98d0041 stmib sp, {r0, r6} <== NOT EXECUTED
4f80: e1a02008 mov r2, r8 <== NOT EXECUTED
4f84: e1a00005 mov r0, r5 <== NOT EXECUTED
4f88: e1a03007 mov r3, r7 <== NOT EXECUTED
4f8c: ebfff9ef bl 3750 <rtems_fdisk_info> <== NOT EXECUTED
{
sc->pages_active++;
}
}
rtems_fdisk_queue_segment (fd, sc);
4f90: e1a00005 mov r0, r5
4f94: e1a01004 mov r1, r4
4f98: ebfffb32 bl 3c68 <rtems_fdisk_queue_segment>
static bool
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
4f9c: e5952028 ldr r2, [r5, #40] ; 0x28
4fa0: e5953024 ldr r3, [r5, #36] ; 0x24
4fa4: e1520003 cmp r2, r3
4fa8: 2a000016 bcs 5008 <bsp_section_rodata_size+0x154>
fd->starvations++;
4fac: e5953070 ldr r3, [r5, #112] ; 0x70
4fb0: e2833001 add r3, r3, #1
4fb4: e5853070 str r3, [r5, #112] ; 0x70
}
rtems_fdisk_queue_segment (fd, sc);
if (rtems_fdisk_is_erased_blocks_starvation (fd))
rtems_fdisk_compact (fd);
4fb8: e1a00005 mov r0, r5
4fbc: ebfffc80 bl 41c4 <rtems_fdisk_compact>
4fc0: ea000010 b 5008 <bsp_section_rodata_size+0x154>
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
for (page = 0; page < sc->pages; page++, pd++)
4fc4: e2877001 add r7, r7, #1
4fc8: e2888008 add r8, r8, #8
4fcc: e594b014 ldr fp, [r4, #20]
4fd0: e157000b cmp r7, fp
4fd4: 3affff8f bcc 4e18 <rtems_fdisk_ioctl+0x74c>
return ret;
}
}
rtems_fdisk_error ("write-block: no erased page descs in segment: %d-%d",
4fd8: e2841008 add r1, r4, #8 <== NOT EXECUTED
4fdc: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
4fe0: e59f070c ldr r0, [pc, #1804] ; 56f4 <bsp_section_rodata_size+0x840><== NOT EXECUTED
4fe4: e59db030 ldr fp, [sp, #48] ; 0x30 <== NOT EXECUTED
4fe8: ebfffac3 bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
sc->device, sc->segment);
sc->failed = true;
4fec: e3a03001 mov r3, #1 <== NOT EXECUTED
4ff0: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, sc);
4ff4: e1a00005 mov r0, r5 <== NOT EXECUTED
4ff8: e1a01004 mov r1, r4 <== NOT EXECUTED
4ffc: ebfffb19 bl 3c68 <rtems_fdisk_queue_segment> <== NOT EXECUTED
return EIO;
5000: e3a06005 mov r6, #5 <== NOT EXECUTED
5004: ea00000e b 5044 <bsp_section_rodata_size+0x190> <== NOT EXECUTED
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
{
ret = rtems_fdisk_write_block (fd, sg->block + b, data);
if (ret)
5008: e3560000 cmp r6, #0
500c: 1a00000b bne 5040 <bsp_section_rodata_size+0x18c>
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
5010: e59dc038 ldr ip, [sp, #56] ; 0x38
5014: e5953014 ldr r3, [r5, #20]
5018: e28cc001 add ip, ip, #1
501c: e58dc038 str ip, [sp, #56] ; 0x38
5020: e0899003 add r9, r9, r3
5024: e59dc038 ldr ip, [sp, #56] ; 0x38
5028: e59de050 ldr lr, [sp, #80] ; 0x50
502c: e15c000e cmp ip, lr
5030: 1afffeb0 bne 4af8 <rtems_fdisk_ioctl+0x42c>
5034: e59db030 ldr fp, [sp, #48] ; 0x30
5038: e3a06000 mov r6, #0
503c: ea000000 b 5044 <bsp_section_rodata_size+0x190>
5040: e59db030 ldr fp, [sp, #48] ; 0x30 <== NOT EXECUTED
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
5044: e59dc044 ldr ip, [sp, #68] ; 0x44
5048: e28cc001 add ip, ip, #1
504c: e58dc044 str ip, [sp, #68] ; 0x44
5050: e59dc02c ldr ip, [sp, #44] ; 0x2c
5054: e3560000 cmp r6, #0
5058: e28cc010 add ip, ip, #16
505c: e58dc02c str ip, [sp, #44] ; 0x2c
5060: 1a000006 bne 5080 <bsp_section_rodata_size+0x1cc>
5064: e59b3010 ldr r3, [fp, #16]
5068: e59dc044 ldr ip, [sp, #68] ; 0x44
506c: e15c0003 cmp ip, r3
5070: 3afffe95 bcc 4acc <rtems_fdisk_ioctl+0x400>
5074: e1a0400b mov r4, fp
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
5078: e3a01000 mov r1, #0
507c: ea000001 b 5088 <bsp_section_rodata_size+0x1d4>
5080: e1a0400b mov r4, fp <== NOT EXECUTED
5084: e3a0101b mov r1, #27 <== NOT EXECUTED
5088: e1a00004 mov r0, r4
508c: e1a0e00f mov lr, pc
5090: e594f004 ldr pc, [r4, #4]
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
break;
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
5094: e59dc04c ldr ip, [sp, #76] ; 0x4c
5098: e3a03000 mov r3, #0
509c: e58c3000 str r3, [ip]
break;
50a0: ea0001f0 b 5868 <bsp_section_rodata_size+0x9b4>
default:
errno = EINVAL;
50a4: eb00614a bl 1d5d4 <__errno> <== NOT EXECUTED
50a8: e3a03016 mov r3, #22 <== NOT EXECUTED
50ac: e5803000 str r3, [r0] <== NOT EXECUTED
break;
50b0: ea0001ec b 5868 <bsp_section_rodata_size+0x9b4> <== NOT EXECUTED
}
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
50b4: eb006146 bl 1d5d4 <__errno> <== NOT EXECUTED
50b8: e5964000 ldr r4, [r6] <== NOT EXECUTED
50bc: e59dc034 ldr ip, [sp, #52] ; 0x34 <== NOT EXECUTED
50c0: e084400c add r4, r4, ip <== NOT EXECUTED
50c4: e1a07000 mov r7, r0 <== NOT EXECUTED
{
uint32_t device;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "erase-disk");
50c8: e59f1628 ldr r1, [pc, #1576] ; 56f8 <bsp_section_rodata_size+0x844><== NOT EXECUTED
50cc: e1a00004 mov r0, r4 <== NOT EXECUTED
50d0: ebfff99e bl 3750 <rtems_fdisk_info> <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
50d4: e1a06005 mov r6, r5 <== NOT EXECUTED
50d8: ea000015 b 5134 <bsp_section_rodata_size+0x280> <== NOT EXECUTED
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " erase-flash:%02d", device);
50dc: e59f1618 ldr r1, [pc, #1560] ; 56fc <bsp_section_rodata_size+0x848><== NOT EXECUTED
50e0: e1a02006 mov r2, r6 <== NOT EXECUTED
50e4: e1a00004 mov r0, r4 <== NOT EXECUTED
50e8: ebfff998 bl 3750 <rtems_fdisk_info> <== NOT EXECUTED
*/
static int
rtems_fdisk_device_erase (const rtems_flashdisk* fd, uint32_t device)
{
const rtems_fdisk_driver_handlers* ops;
ops = fd->devices[device].descriptor->flash_ops;
50ec: e594302c ldr r3, [r4, #44] ; 0x2c <== NOT EXECUTED
50f0: e0833005 add r3, r3, r5 <== NOT EXECUTED
50f4: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
#if RTEMS_FDISK_TRACE rtems_fdisk_printf (fd, " device-erase: %02d", device);
50f8: e59f1600 ldr r1, [pc, #1536] ; 5700 <bsp_section_rodata_size+0x84c><== NOT EXECUTED
50fc: e1a02006 mov r2, r6 <== NOT EXECUTED
5100: e1a00004 mov r0, r4 <== NOT EXECUTED
*/
static int
rtems_fdisk_device_erase (const rtems_flashdisk* fd, uint32_t device)
{
const rtems_fdisk_driver_handlers* ops;
ops = fd->devices[device].descriptor->flash_ops;
5104: e5938008 ldr r8, [r3, #8] <== NOT EXECUTED
#if RTEMS_FDISK_TRACE rtems_fdisk_printf (fd, " device-erase: %02d", device);
5108: ebfff9b0 bl 37d0 <rtems_fdisk_printf> <== NOT EXECUTED
#endif return ops->erase_device (fd->devices[device].descriptor, device);
510c: e594302c ldr r3, [r4, #44] ; 0x2c <== NOT EXECUTED
5110: e0833005 add r3, r3, r5 <== NOT EXECUTED
5114: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
5118: e1a01006 mov r1, r6 <== NOT EXECUTED
511c: e1a0e00f mov lr, pc <== NOT EXECUTED
5120: e598f014 ldr pc, [r8, #20] <== NOT EXECUTED
rtems_fdisk_info (fd, " erase-flash:%02d", device);
#endif
ret = rtems_fdisk_device_erase (fd, device);
if (ret != 0)
5124: e3500000 cmp r0, #0 <== NOT EXECUTED
const rtems_fdisk_driver_handlers* ops; ops = fd->devices[device].descriptor->flash_ops; #if RTEMS_FDISK_TRACE rtems_fdisk_printf (fd, " device-erase: %02d", device); #endif return ops->erase_device (fd->devices[device].descriptor, device);
5128: e285500c add r5, r5, #12 <== NOT EXECUTED
rtems_fdisk_info (fd, " erase-flash:%02d", device);
#endif
ret = rtems_fdisk_device_erase (fd, device);
if (ret != 0)
512c: 1a000016 bne 518c <bsp_section_rodata_size+0x2d8> <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
5130: e2866001 add r6, r6, #1 <== NOT EXECUTED
5134: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED
5138: e1560003 cmp r6, r3 <== NOT EXECUTED
513c: 3affffe6 bcc 50dc <bsp_section_rodata_size+0x228> <== NOT EXECUTED
5140: e3a05000 mov r5, #0 <== NOT EXECUTED
5144: e1a06005 mov r6, r5 <== NOT EXECUTED
5148: ea000009 b 5174 <bsp_section_rodata_size+0x2c0> <== NOT EXECUTED
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
{
if (!fd->devices[device].segments)
514c: e594302c ldr r3, [r4, #44] ; 0x2c <== NOT EXECUTED
5150: e7933005 ldr r3, [r3, r5] <== NOT EXECUTED
5154: e3530000 cmp r3, #0 <== NOT EXECUTED
5158: 0a00000a beq 5188 <bsp_section_rodata_size+0x2d4> <== NOT EXECUTED
return ENOMEM;
ret = rtems_fdisk_recover_block_mappings (fd);
515c: e1a00004 mov r0, r4 <== NOT EXECUTED
5160: ebfffc92 bl 43b0 <rtems_fdisk_recover_block_mappings> <== NOT EXECUTED
if (ret)
5164: e3500000 cmp r0, #0 <== NOT EXECUTED
for (device = 0; device < fd->device_count; device++)
{
if (!fd->devices[device].segments)
return ENOMEM;
ret = rtems_fdisk_recover_block_mappings (fd);
5168: e285500c add r5, r5, #12 <== NOT EXECUTED
if (ret)
516c: 1a000006 bne 518c <bsp_section_rodata_size+0x2d8> <== NOT EXECUTED
ret = rtems_fdisk_erase_flash (fd);
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
5170: e2866001 add r6, r6, #1 <== NOT EXECUTED
5174: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED
5178: e1560003 cmp r6, r3 <== NOT EXECUTED
517c: 3afffff2 bcc 514c <bsp_section_rodata_size+0x298> <== NOT EXECUTED
5180: e3a00000 mov r0, #0 <== NOT EXECUTED
5184: ea000000 b 518c <bsp_section_rodata_size+0x2d8> <== NOT EXECUTED
{
if (!fd->devices[device].segments)
return ENOMEM;
5188: e3a0000c mov r0, #12 <== NOT EXECUTED
}
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
518c: e5870000 str r0, [r7] <== NOT EXECUTED
break;
5190: ea0001b4 b 5868 <bsp_section_rodata_size+0x9b4> <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_COMPACT:
errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);
5194: eb00610e bl 1d5d4 <__errno> <== NOT EXECUTED
5198: e59dc034 ldr ip, [sp, #52] ; 0x34 <== NOT EXECUTED
519c: e1a04000 mov r4, r0 <== NOT EXECUTED
51a0: e5960000 ldr r0, [r6] <== NOT EXECUTED
51a4: e080000c add r0, r0, ip <== NOT EXECUTED
51a8: ebfffc05 bl 41c4 <rtems_fdisk_compact> <== NOT EXECUTED
51ac: e5840000 str r0, [r4] <== NOT EXECUTED
break;
51b0: ea0001ac b 5868 <bsp_section_rodata_size+0x9b4> <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
51b4: eb006106 bl 1d5d4 <__errno> <== NOT EXECUTED
51b8: e5964000 ldr r4, [r6] <== NOT EXECUTED
51bc: e59dc034 ldr ip, [sp, #52] ; 0x34 <== NOT EXECUTED
51c0: e084400c add r4, r4, ip <== NOT EXECUTED
51c4: e1a07000 mov r7, r0 <== NOT EXECUTED
rtems_fdisk_erase_used (rtems_flashdisk* fd)
{
rtems_fdisk_segment_ctl* sc;
int latched_ret = 0;
while ((sc = rtems_fdisk_segment_queue_pop_head (&fd->erase)))
51c8: e284604c add r6, r4, #76 ; 0x4c <== NOT EXECUTED
51cc: ea000007 b 51f0 <bsp_section_rodata_size+0x33c> <== NOT EXECUTED
{
/*
* The segment will either end up on the available queue or
* the failed queue.
*/
int ret = rtems_fdisk_erase_segment (fd, sc);
51d0: e1a00004 mov r0, r4 <== NOT EXECUTED
51d4: ebfffa64 bl 3b6c <rtems_fdisk_erase_segment> <== NOT EXECUTED
if (ret && !latched_ret)
51d8: e2903000 adds r3, r0, #0 <== NOT EXECUTED
51dc: 13a03001 movne r3, #1 <== NOT EXECUTED
51e0: e3550000 cmp r5, #0 <== NOT EXECUTED
51e4: 13a03000 movne r3, #0 <== NOT EXECUTED
51e8: e3530000 cmp r3, #0 <== NOT EXECUTED
51ec: 11a05000 movne r5, r0 <== NOT EXECUTED
rtems_fdisk_erase_used (rtems_flashdisk* fd)
{
rtems_fdisk_segment_ctl* sc;
int latched_ret = 0;
while ((sc = rtems_fdisk_segment_queue_pop_head (&fd->erase)))
51f0: e1a00006 mov r0, r6 <== NOT EXECUTED
51f4: ebfff8ba bl 34e4 <rtems_fdisk_segment_queue_pop_head> <== NOT EXECUTED
51f8: e2501000 subs r1, r0, #0 <== NOT EXECUTED
51fc: 1afffff3 bne 51d0 <bsp_section_rodata_size+0x31c> <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_COMPACT:
errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);
break;
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
5200: e5875000 str r5, [r7] <== NOT EXECUTED
break;
5204: ea000197 b 5868 <bsp_section_rodata_size+0x9b4> <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_MONITORING:
errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
5208: eb0060f1 bl 1d5d4 <__errno> <== NOT EXECUTED
520c: e5962000 ldr r2, [r6] <== NOT EXECUTED
5210: e59dc034 ldr ip, [sp, #52] ; 0x34 <== NOT EXECUTED
5214: e082200c add r2, r2, ip <== NOT EXECUTED
rtems_fdisk_monitor_data* data)
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
5218: e5923014 ldr r3, [r2, #20] <== NOT EXECUTED
data->block_count = fd->block_count; data->unavail_blocks = fd->unavail_blocks;
521c: e5921020 ldr r1, [r2, #32] <== NOT EXECUTED
data->device_count = fd->device_count;
5220: e5926030 ldr r6, [r2, #48] ; 0x30 <== NOT EXECUTED
rtems_fdisk_monitor_data* data)
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
5224: e5843000 str r3, [r4] <== NOT EXECUTED
data->block_count = fd->block_count;
5228: e592301c ldr r3, [r2, #28] <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks;
522c: e5841008 str r1, [r4, #8] <== NOT EXECUTED
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
data->block_count = fd->block_count;
5230: e5843004 str r3, [r4, #4] <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks; data->device_count = fd->device_count;
5234: e584600c str r6, [r4, #12] <== NOT EXECUTED
data->blocks_used = 0;
5238: e5845018 str r5, [r4, #24] <== NOT EXECUTED
523c: ea000006 b 525c <bsp_section_rodata_size+0x3a8> <== NOT EXECUTED
for (i = 0; i < fd->block_count; i++)
if (fd->blocks[i].segment)
5240: e5921018 ldr r1, [r2, #24] <== NOT EXECUTED
5244: e7911185 ldr r1, [r1, r5, lsl #3] <== NOT EXECUTED
5248: e3510000 cmp r1, #0 <== NOT EXECUTED
data->blocks_used++;
524c: 15941018 ldrne r1, [r4, #24] <== NOT EXECUTED
5250: 12811001 addne r1, r1, #1 <== NOT EXECUTED
5254: 15841018 strne r1, [r4, #24] <== NOT EXECUTED
data->block_count = fd->block_count;
data->unavail_blocks = fd->unavail_blocks;
data->device_count = fd->device_count;
data->blocks_used = 0;
for (i = 0; i < fd->block_count; i++)
5258: e2855001 add r5, r5, #1 <== NOT EXECUTED
525c: e1550003 cmp r5, r3 <== NOT EXECUTED
5260: 1afffff6 bne 5240 <bsp_section_rodata_size+0x38c> <== NOT EXECUTED
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
5264: e5923034 ldr r3, [r2, #52] ; 0x34 <== NOT EXECUTED
uint32_t count = 0;
5268: e3a01000 mov r1, #0 <== NOT EXECUTED
526c: ea000001 b 5278 <bsp_section_rodata_size+0x3c4> <== NOT EXECUTED
while (sc)
{
count++;
sc = sc->next;
5270: e5933000 ldr r3, [r3] <== NOT EXECUTED
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
{
count++;
5274: e2811001 add r1, r1, #1 <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
5278: e3530000 cmp r3, #0 <== NOT EXECUTED
527c: 1afffffb bne 5270 <bsp_section_rodata_size+0x3bc> <== NOT EXECUTED
data->blocks_used = 0;
for (i = 0; i < fd->block_count; i++)
if (fd->blocks[i].segment)
data->blocks_used++;
data->segs_available = rtems_fdisk_segment_count_queue (&fd->available);
5280: e584101c str r1, [r4, #28] <== NOT EXECUTED
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
5284: e5921040 ldr r1, [r2, #64] ; 0x40 <== NOT EXECUTED
5288: ea000001 b 5294 <bsp_section_rodata_size+0x3e0> <== NOT EXECUTED
uint32_t count = 0;
while (sc)
{
count++;
sc = sc->next;
528c: e5911000 ldr r1, [r1] <== NOT EXECUTED
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
{
count++;
5290: e2833001 add r3, r3, #1 <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
5294: e3510000 cmp r1, #0 <== NOT EXECUTED
5298: 1afffffb bne 528c <bsp_section_rodata_size+0x3d8> <== NOT EXECUTED
for (i = 0; i < fd->block_count; i++)
if (fd->blocks[i].segment)
data->blocks_used++;
data->segs_available = rtems_fdisk_segment_count_queue (&fd->available);
data->segs_used = rtems_fdisk_segment_count_queue (&fd->used);
529c: e5843020 str r3, [r4, #32] <== NOT EXECUTED
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
52a0: e5923058 ldr r3, [r2, #88] ; 0x58 <== NOT EXECUTED
52a4: ea000001 b 52b0 <bsp_section_rodata_size+0x3fc> <== NOT EXECUTED
uint32_t count = 0;
while (sc)
{
count++;
sc = sc->next;
52a8: e5933000 ldr r3, [r3] <== NOT EXECUTED
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
{
count++;
52ac: e2811001 add r1, r1, #1 <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
52b0: e3530000 cmp r3, #0 <== NOT EXECUTED
52b4: 1afffffb bne 52a8 <bsp_section_rodata_size+0x3f4> <== NOT EXECUTED
if (fd->blocks[i].segment)
data->blocks_used++;
data->segs_available = rtems_fdisk_segment_count_queue (&fd->available);
data->segs_used = rtems_fdisk_segment_count_queue (&fd->used);
data->segs_failed = rtems_fdisk_segment_count_queue (&fd->failed);
52b8: e5841024 str r1, [r4, #36] ; 0x24 <== NOT EXECUTED
data->segment_count = 0;
52bc: e5843010 str r3, [r4, #16] <== NOT EXECUTED
data->page_count = 0;
52c0: e5843014 str r3, [r4, #20] <== NOT EXECUTED
data->pages_desc = 0;
52c4: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
data->pages_active = 0;
52c8: e5843030 str r3, [r4, #48] ; 0x30 <== NOT EXECUTED
data->pages_used = 0;
52cc: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED
data->pages_bad = 0;
52d0: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
data->seg_erases = 0;
52d4: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
for (i = 0; i < fd->device_count; i++)
52d8: e1a0e003 mov lr, r3 <== NOT EXECUTED
52dc: ea000028 b 5384 <bsp_section_rodata_size+0x4d0> <== NOT EXECUTED
{
data->segment_count += fd->devices[i].segment_count;
52e0: e592802c ldr r8, [r2, #44] ; 0x2c <== NOT EXECUTED
52e4: e0888003 add r8, r8, r3 <== NOT EXECUTED
52e8: e5987004 ldr r7, [r8, #4] <== NOT EXECUTED
52ec: e5941010 ldr r1, [r4, #16] <== NOT EXECUTED
52f0: e3a0c000 mov ip, #0 <== NOT EXECUTED
52f4: e0811007 add r1, r1, r7 <== NOT EXECUTED
52f8: e5841010 str r1, [r4, #16] <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
52fc: e1a0500c mov r5, ip <== NOT EXECUTED
5300: ea00001b b 5374 <bsp_section_rodata_size+0x4c0> <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
5304: e5981000 ldr r1, [r8] <== NOT EXECUTED
5308: e081100c add r1, r1, ip <== NOT EXECUTED
data->page_count += sc->pages;
530c: e591a014 ldr sl, [r1, #20] <== NOT EXECUTED
5310: e5949014 ldr r9, [r4, #20] <== NOT EXECUTED
5314: e089a00a add sl, r9, sl <== NOT EXECUTED
5318: e584a014 str sl, [r4, #20] <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
531c: e594902c ldr r9, [r4, #44] ; 0x2c <== NOT EXECUTED
5320: e591a018 ldr sl, [r1, #24] <== NOT EXECUTED
5324: e089a00a add sl, r9, sl <== NOT EXECUTED
5328: e584a02c str sl, [r4, #44] ; 0x2c <== NOT EXECUTED
data->pages_active += sc->pages_active;
532c: e5949030 ldr r9, [r4, #48] ; 0x30 <== NOT EXECUTED
5330: e591a01c ldr sl, [r1, #28] <== NOT EXECUTED
5334: e089a00a add sl, r9, sl <== NOT EXECUTED
5338: e584a030 str sl, [r4, #48] ; 0x30 <== NOT EXECUTED
data->pages_used += sc->pages_used;
533c: e5949034 ldr r9, [r4, #52] ; 0x34 <== NOT EXECUTED
5340: e591a020 ldr sl, [r1, #32] <== NOT EXECUTED
5344: e089a00a add sl, r9, sl <== NOT EXECUTED
5348: e584a034 str sl, [r4, #52] ; 0x34 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
534c: e5949038 ldr r9, [r4, #56] ; 0x38 <== NOT EXECUTED
5350: e591a024 ldr sl, [r1, #36] ; 0x24 <== NOT EXECUTED
5354: e089a00a add sl, r9, sl <== NOT EXECUTED
data->seg_erases += sc->erased;
5358: e591102c ldr r1, [r1, #44] ; 0x2c <== NOT EXECUTED
data->page_count += sc->pages;
data->pages_desc += sc->pages_desc;
data->pages_active += sc->pages_active;
data->pages_used += sc->pages_used;
data->pages_bad += sc->pages_bad;
535c: e584a038 str sl, [r4, #56] ; 0x38 <== NOT EXECUTED
data->seg_erases += sc->erased;
5360: e594a028 ldr sl, [r4, #40] ; 0x28 <== NOT EXECUTED
5364: e08a1001 add r1, sl, r1 <== NOT EXECUTED
5368: e5841028 str r1, [r4, #40] ; 0x28 <== NOT EXECUTED
for (i = 0; i < fd->device_count; i++)
{
data->segment_count += fd->devices[i].segment_count;
for (j = 0; j < fd->devices[i].segment_count; j++)
536c: e2855001 add r5, r5, #1 <== NOT EXECUTED
5370: e28cc030 add ip, ip, #48 ; 0x30 <== NOT EXECUTED
5374: e1550007 cmp r5, r7 <== NOT EXECUTED
5378: 1affffe1 bne 5304 <bsp_section_rodata_size+0x450> <== NOT EXECUTED
data->pages_active = 0;
data->pages_used = 0;
data->pages_bad = 0;
data->seg_erases = 0;
for (i = 0; i < fd->device_count; i++)
537c: e28ee001 add lr, lr, #1 <== NOT EXECUTED
5380: e283300c add r3, r3, #12 <== NOT EXECUTED
5384: e15e0006 cmp lr, r6 <== NOT EXECUTED
5388: 1affffd4 bne 52e0 <bsp_section_rodata_size+0x42c> <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
data->seg_erases += sc->erased;
}
}
data->info_level = fd->info_level;
538c: e592306c ldr r3, [r2, #108] ; 0x6c <== NOT EXECUTED
5390: e584303c str r3, [r4, #60] ; 0x3c <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
break;
case RTEMS_FDISK_IOCTL_MONITORING:
errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
5394: e3a03000 mov r3, #0 <== NOT EXECUTED
5398: eaffff43 b 50ac <bsp_section_rodata_size+0x1f8> <== NOT EXECUTED
(rtems_fdisk_monitor_data*) argp);
break;
case RTEMS_FDISK_IOCTL_INFO_LEVEL:
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
539c: e5963000 ldr r3, [r6] <== NOT EXECUTED
53a0: e59dc034 ldr ip, [sp, #52] ; 0x34 <== NOT EXECUTED
53a4: e083300c add r3, r3, ip <== NOT EXECUTED
53a8: e583406c str r4, [r3, #108] ; 0x6c <== NOT EXECUTED
break;
53ac: ea00012d b 5868 <bsp_section_rodata_size+0x9b4> <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
53b0: eb006087 bl 1d5d4 <__errno>
53b4: e5963000 ldr r3, [r6]
53b8: e59dc034 ldr ip, [sp, #52] ; 0x34
53bc: e083400c add r4, r3, ip
*/
static int
rtems_fdisk_print_status (rtems_flashdisk* fd)
{
#if RTEMS_FDISK_TRACE
uint32_t current_info_level = fd->info_level;
53c0: e594c06c ldr ip, [r4, #108] ; 0x6c
53c4: e58dc03c str ip, [sp, #60] ; 0x3c
uint32_t count;
uint32_t device;
fd->info_level = 3;
rtems_fdisk_printf (fd,
53c8: e59dc034 ldr ip, [sp, #52] ; 0x34
uint32_t current_info_level = fd->info_level;
uint32_t total;
uint32_t count;
uint32_t device;
fd->info_level = 3;
53cc: e3a02003 mov r2, #3
case RTEMS_FDISK_IOCTL_INFO_LEVEL:
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
break;
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
53d0: e58d0044 str r0, [sp, #68] ; 0x44
uint32_t current_info_level = fd->info_level;
uint32_t total;
uint32_t count;
uint32_t device;
fd->info_level = 3;
53d4: e584206c str r2, [r4, #108] ; 0x6c
rtems_fdisk_printf (fd,
53d8: e59f1324 ldr r1, [pc, #804] ; 5704 <bsp_section_rodata_size+0x850>
53dc: e793200c ldr r2, [r3, ip]
53e0: e1a00004 mov r0, r4
53e4: e5943004 ldr r3, [r4, #4]
53e8: ebfff8f8 bl 37d0 <rtems_fdisk_printf>
"Flash Disk Driver Status : %d.%d", fd->major, fd->minor);
rtems_fdisk_printf (fd, "Block count\t%d", fd->block_count);
53ec: e59f1314 ldr r1, [pc, #788] ; 5708 <bsp_section_rodata_size+0x854>
53f0: e594201c ldr r2, [r4, #28]
53f4: e1a00004 mov r0, r4
53f8: ebfff8f4 bl 37d0 <rtems_fdisk_printf>
rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);
53fc: e59f1308 ldr r1, [pc, #776] ; 570c <bsp_section_rodata_size+0x858>
5400: e5942020 ldr r2, [r4, #32]
5404: e1a00004 mov r0, r4
5408: ebfff8f0 bl 37d0 <rtems_fdisk_printf>
rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
540c: e59f12fc ldr r1, [pc, #764] ; 5710 <bsp_section_rodata_size+0x85c>
5410: e5942024 ldr r2, [r4, #36] ; 0x24
5414: e1a00004 mov r0, r4
5418: ebfff8ec bl 37d0 <rtems_fdisk_printf>
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
541c: e1a00004 mov r0, r4
5420: e59f12ec ldr r1, [pc, #748] ; 5714 <bsp_section_rodata_size+0x860>
5424: e5942070 ldr r2, [r4, #112] ; 0x70
5428: ebfff8e8 bl 37d0 <rtems_fdisk_printf>
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
542c: e5947034 ldr r7, [r4, #52] ; 0x34
5430: ea000001 b 543c <bsp_section_rodata_size+0x588>
uint32_t count = 0;
while (sc)
{
count++;
sc = sc->next;
5434: e5977000 ldr r7, [r7]
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
{
count++;
5438: e2855001 add r5, r5, #1
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
543c: e3570000 cmp r7, #0
5440: 1afffffb bne 5434 <bsp_section_rodata_size+0x580>
rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);
rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
count = rtems_fdisk_segment_count_queue (&fd->available);
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
5444: e1a02005 mov r2, r5
5448: e1a00004 mov r0, r4
544c: e59f12c4 ldr r1, [pc, #708] ; 5718 <bsp_section_rodata_size+0x864>
5450: e594303c ldr r3, [r4, #60] ; 0x3c
5454: ebfff8dd bl 37d0 <rtems_fdisk_printf>
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
5458: e5946040 ldr r6, [r4, #64] ; 0x40
uint32_t count = 0;
545c: e1a02007 mov r2, r7
5460: ea000001 b 546c <bsp_section_rodata_size+0x5b8>
while (sc)
{
count++;
sc = sc->next;
5464: e5966000 ldr r6, [r6]
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
{
count++;
5468: e2822001 add r2, r2, #1
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
546c: e3560000 cmp r6, #0
5470: 1afffffb bne 5464 <bsp_section_rodata_size+0x5b0>
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->available));
count = rtems_fdisk_segment_count_queue (&fd->used);
total += count;
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
5474: e1a00004 mov r0, r4
5478: e59f129c ldr r1, [pc, #668] ; 571c <bsp_section_rodata_size+0x868>
547c: e5943048 ldr r3, [r4, #72] ; 0x48
count = rtems_fdisk_segment_count_queue (&fd->available);
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->available));
count = rtems_fdisk_segment_count_queue (&fd->used);
total += count;
5480: e0828005 add r8, r2, r5
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
5484: ebfff8d1 bl 37d0 <rtems_fdisk_printf>
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
5488: e594504c ldr r5, [r4, #76] ; 0x4c
uint32_t count = 0;
548c: e1a02006 mov r2, r6
5490: ea000001 b 549c <bsp_section_rodata_size+0x5e8>
while (sc)
{
count++;
sc = sc->next;
5494: e5955000 ldr r5, [r5] <== NOT EXECUTED
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
{
count++;
5498: e2822001 add r2, r2, #1 <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
549c: e3550000 cmp r5, #0
54a0: 1afffffb bne 5494 <bsp_section_rodata_size+0x5e0>
total += count;
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->used));
count = rtems_fdisk_segment_count_queue (&fd->erase);
total += count;
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
54a4: e1a00004 mov r0, r4
54a8: e59f1270 ldr r1, [pc, #624] ; 5720 <bsp_section_rodata_size+0x86c>
54ac: e5943054 ldr r3, [r4, #84] ; 0x54
count = rtems_fdisk_segment_count_queue (&fd->used);
total += count;
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->used));
count = rtems_fdisk_segment_count_queue (&fd->erase);
total += count;
54b0: e0888002 add r8, r8, r2
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
54b4: ebfff8c5 bl 37d0 <rtems_fdisk_printf>
* Count the number of elements on the list.
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
54b8: e5946058 ldr r6, [r4, #88] ; 0x58
uint32_t count = 0;
54bc: e1a02005 mov r2, r5
54c0: ea000001 b 54cc <bsp_section_rodata_size+0x618>
while (sc)
{
count++;
sc = sc->next;
54c4: e5966000 ldr r6, [r6] <== NOT EXECUTED
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
{
count++;
54c8: e2822001 add r2, r2, #1 <== NOT EXECUTED
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
54cc: e3560000 cmp r6, #0
54d0: 1afffffb bne 54c4 <bsp_section_rodata_size+0x610>
total += count;
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->erase));
count = rtems_fdisk_segment_count_queue (&fd->failed);
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
54d4: e59f1248 ldr r1, [pc, #584] ; 5724 <bsp_section_rodata_size+0x870>
54d8: e5943060 ldr r3, [r4, #96] ; 0x60
54dc: e1a00004 mov r0, r4
count = rtems_fdisk_segment_count_queue (&fd->erase);
total += count;
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->erase));
count = rtems_fdisk_segment_count_queue (&fd->failed);
total += count;
54e0: e0888002 add r8, r8, r2
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
54e4: ebfff8b9 bl 37d0 <rtems_fdisk_printf>
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
for (device = 0; device < fd->device_count; device++)
54e8: e5941030 ldr r1, [r4, #48] ; 0x30
54ec: e1a02006 mov r2, r6
count = rtems_fdisk_segment_count_queue (&fd->failed);
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
54f0: e1a03006 mov r3, r6
54f4: ea000005 b 5510 <bsp_section_rodata_size+0x65c>
for (device = 0; device < fd->device_count; device++)
count += fd->devices[device].segment_count;
54f8: e594002c ldr r0, [r4, #44] ; 0x2c
54fc: e0800006 add r0, r0, r6
5500: e5900004 ldr r0, [r0, #4]
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
for (device = 0; device < fd->device_count; device++)
5504: e2822001 add r2, r2, #1
count += fd->devices[device].segment_count;
5508: e0833000 add r3, r3, r0
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
for (device = 0; device < fd->device_count; device++)
550c: e286600c add r6, r6, #12
5510: e1520001 cmp r2, r1
5514: 1afffff7 bne 54f8 <bsp_section_rodata_size+0x644>
count += fd->devices[device].segment_count;
rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
5518: e59f1208 ldr r1, [pc, #520] ; 5728 <bsp_section_rodata_size+0x874>
551c: e59f2208 ldr r2, [pc, #520] ; 572c <bsp_section_rodata_size+0x878>
5520: e1580003 cmp r8, r3
5524: 11a02001 movne r2, r1
5528: e58d2000 str r2, [sp]
552c: e59f11fc ldr r1, [pc, #508] ; 5730 <bsp_section_rodata_size+0x87c>
5530: e1a02008 mov r2, r8
5534: e1a00004 mov r0, r4
5538: ebfff8a4 bl 37d0 <rtems_fdisk_printf>
total == count ? "ok" : "MISSING");
rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);
553c: e3a0a000 mov sl, #0
5540: e1a00004 mov r0, r4
5544: e59f11e8 ldr r1, [pc, #488] ; 5734 <bsp_section_rodata_size+0x880>
5548: e5942030 ldr r2, [r4, #48] ; 0x30
554c: ebfff89f bl 37d0 <rtems_fdisk_printf>
for (device = 0; device < fd->device_count; device++)
5550: e58da02c str sl, [sp, #44] ; 0x2c
5554: ea0000a3 b 57e8 <bsp_section_rodata_size+0x934>
{
uint32_t block;
uint32_t seg;
rtems_fdisk_printf (fd, " Device\t\t%ld", device);
5558: e59f11d8 ldr r1, [pc, #472] ; 5738 <bsp_section_rodata_size+0x884>
555c: e59d202c ldr r2, [sp, #44] ; 0x2c
5560: e1a00004 mov r0, r4
5564: ebfff899 bl 37d0 <rtems_fdisk_printf>
rtems_fdisk_printf (fd, " Segment count\t%ld",
5568: e594302c ldr r3, [r4, #44] ; 0x2c
556c: e083300a add r3, r3, sl
5570: e1a00004 mov r0, r4
5574: e59f11c0 ldr r1, [pc, #448] ; 573c <bsp_section_rodata_size+0x888>
5578: e5932004 ldr r2, [r3, #4]
557c: e3a09000 mov r9, #0
5580: ebfff892 bl 37d0 <rtems_fdisk_printf>
fd->devices[device].segment_count);
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
5584: e1a0b009 mov fp, r9
5588: ea00008d b 57c4 <bsp_section_rodata_size+0x910>
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
558c: e793500a ldr r5, [r3, sl]
5590: e0855009 add r5, r5, r9
uint32_t page;
uint32_t erased = 0;
uint32_t active = 0;
uint32_t used = 0;
bool is_active = false;
5594: e3a07000 mov r7, #0
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
5598: e1a00004 mov r0, r4
559c: e1a01005 mov r1, r5
55a0: e28d205c add r2, sp, #92 ; 0x5c
55a4: ebfff818 bl 360c <rtems_fdisk_queue_status>
for (page = 0; page < sc->pages; page++)
55a8: e1a08007 mov r8, r7
55ac: e58d9040 str r9, [sp, #64] ; 0x40
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
uint32_t page;
uint32_t erased = 0;
uint32_t active = 0;
uint32_t used = 0;
55b0: e58d7038 str r7, [sp, #56] ; 0x38
55b4: e1a0900a mov r9, sl
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
uint32_t page;
uint32_t erased = 0;
55b8: e58d7030 str r7, [sp, #48] ; 0x30
55bc: e1a0a007 mov sl, r7
55c0: ea000026 b 5660 <bsp_section_rodata_size+0x7ac>
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
55c4: e5956010 ldr r6, [r5, #16]
55c8: e0866188 add r6, r6, r8, lsl #3
55cc: e1a00006 mov r0, r6
55d0: ebfff83c bl 36c8 <rtems_fdisk_page_desc_erased>
55d4: e3500000 cmp r0, #0
erased++;
55d8: 159dc030 ldrne ip, [sp, #48] ; 0x30
55dc: 128cc001 addne ip, ip, #1
55e0: 158dc030 strne ip, [sp, #48] ; 0x30
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
55e4: 1a000008 bne 560c <bsp_section_rodata_size+0x758>
* only set a flag by changing it from 1 to 0.
*/
static bool
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{
return (pd->flags & flags) == 0 ? true : false;
55e8: e1d630b2 ldrh r3, [r6, #2]
for (page = 0; page < sc->pages; page++)
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
erased++;
else if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
55ec: e3130001 tst r3, #1
55f0: 1a000005 bne 560c <bsp_section_rodata_size+0x758>
RTEMS_FDISK_PAGE_ACTIVE))
{
if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
55f4: e3130002 tst r3, #2
RTEMS_FDISK_PAGE_USED))
used++;
55f8: 059dc038 ldreq ip, [sp, #56] ; 0x38
55fc: 028cc001 addeq ip, ip, #1
5600: 058dc038 streq ip, [sp, #56] ; 0x38
else
{
active++;
5604: 128aa001 addne sl, sl, #1
is_active = true;
5608: 13a07001 movne r7, #1
}
}
for (block = 0; block < fd->block_count; block++)
560c: e3a06000 mov r6, #0
5610: ea00000e b 5650 <bsp_section_rodata_size+0x79c>
{
if ((fd->blocks[block].segment == sc) &&
5614: e5943018 ldr r3, [r4, #24]
5618: e0832186 add r2, r3, r6, lsl #3
561c: e7933186 ldr r3, [r3, r6, lsl #3]
5620: e1530005 cmp r3, r5
5624: 1a000008 bne 564c <bsp_section_rodata_size+0x798>
5628: e5923004 ldr r3, [r2, #4]
562c: e1530008 cmp r3, r8
5630: 1a000005 bne 564c <bsp_section_rodata_size+0x798>
(fd->blocks[block].page == page) && !is_active)
5634: e3570000 cmp r7, #0
rtems_fdisk_printf (fd,
5638: 01a00004 moveq r0, r4
563c: 059f10fc ldreq r1, [pc, #252] ; 5740 <bsp_section_rodata_size+0x88c>
5640: 01a02008 moveq r2, r8
5644: 01a03006 moveq r3, r6
5648: 0bfff860 bleq 37d0 <rtems_fdisk_printf>
active++;
is_active = true;
}
}
for (block = 0; block < fd->block_count; block++)
564c: e2866001 add r6, r6, #1
5650: e594301c ldr r3, [r4, #28]
5654: e1560003 cmp r6, r3
5658: 3affffed bcc 5614 <bsp_section_rodata_size+0x760>
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
565c: e2888001 add r8, r8, #1
5660: e5951014 ldr r1, [r5, #20]
5664: e1580001 cmp r8, r1
5668: 3affffd5 bcc 55c4 <bsp_section_rodata_size+0x710>
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
566c: e3a03000 mov r3, #0
5670: e1a0c00a mov ip, sl
5674: e594001c ldr r0, [r4, #28]
5678: e1a0a009 mov sl, r9
567c: e1a02003 mov r2, r3
5680: e59d9040 ldr r9, [sp, #64] ; 0x40
5684: ea000037 b 5768 <bsp_section_rodata_size+0x8b4>
5688: 00043168 .word 0x00043168
568c: 20004283 .word 0x20004283 <== NOT EXECUTED
5690: 20004285 .word 0x20004285 <== NOT EXECUTED
5694: c0184201 .word 0xc0184201 <== NOT EXECUTED
5698: 0002e4bf .word 0x0002e4bf <== NOT EXECUTED
569c: 0002e4cd .word 0x0002e4cd <== NOT EXECUTED
56a0: 0002e4f0 .word 0x0002e4f0 <== NOT EXECUTED
56a4: 000303ea .word 0x000303ea <== NOT EXECUTED
56a8: 0002e109 .word 0x0002e109 <== NOT EXECUTED
56ac: 0002e513 .word 0x0002e513 <== NOT EXECUTED
56b0: 0002e55a .word 0x0002e55a <== NOT EXECUTED
56b4: 0000ffff .word 0x0000ffff <== NOT EXECUTED
56b8: 0002e58f .word 0x0002e58f <== NOT EXECUTED
56bc: 0002e5c2 .word 0x0002e5c2 <== NOT EXECUTED
56c0: 0002e5f6 .word 0x0002e5f6 <== NOT EXECUTED
56c4: 0002e626 .word 0x0002e626 <== NOT EXECUTED
56c8: 0002e635 .word 0x0002e635 <== NOT EXECUTED
56cc: 0002e659 .word 0x0002e659 <== NOT EXECUTED
56d0: 0002e67a .word 0x0002e67a <== NOT EXECUTED
56d4: 0002e69f .word 0x0002e69f <== NOT EXECUTED
56d8: 0002e6cd .word 0x0002e6cd <== NOT EXECUTED
56dc: 0002e717 .word 0x0002e717 <== NOT EXECUTED
56e0: 0002e753 .word 0x0002e753 <== NOT EXECUTED
56e4: 0002e773 .word 0x0002e773 <== NOT EXECUTED
56e8: 0002e799 .word 0x0002e799 <== NOT EXECUTED
56ec: 0002e7e8 .word 0x0002e7e8 <== NOT EXECUTED
56f0: 0002e81f .word 0x0002e81f <== NOT EXECUTED
56f4: 0002e85b .word 0x0002e85b <== NOT EXECUTED
56f8: 0002e88f .word 0x0002e88f <== NOT EXECUTED
56fc: 0002e89a .word 0x0002e89a <== NOT EXECUTED
5700: 0002e8ac .word 0x0002e8ac <== NOT EXECUTED
5704: 0002e8c0 .word 0x0002e8c0 <== NOT EXECUTED
5708: 0002e8e1 .word 0x0002e8e1 <== NOT EXECUTED
570c: 0002e8f0 .word 0x0002e8f0 <== NOT EXECUTED
5710: 0002e902 .word 0x0002e902 <== NOT EXECUTED
5714: 0002e91a .word 0x0002e91a <== NOT EXECUTED
5718: 0002e929 .word 0x0002e929 <== NOT EXECUTED
571c: 0002e943 .word 0x0002e943 <== NOT EXECUTED
5720: 0002e958 .word 0x0002e958 <== NOT EXECUTED
5724: 0002e96e .word 0x0002e96e <== NOT EXECUTED
5728: 0002e4b7 .word 0x0002e4b7 <== NOT EXECUTED
572c: 0002e4b4 .word 0x0002e4b4 <== NOT EXECUTED
5730: 0002e985 .word 0x0002e985 <== NOT EXECUTED
5734: 0002e9a0 .word 0x0002e9a0 <== NOT EXECUTED
5738: 0002e9b0 .word 0x0002e9b0 <== NOT EXECUTED
573c: 0002e9bd .word 0x0002e9bd <== NOT EXECUTED
5740: 0002e9d1 .word 0x0002e9d1 <== NOT EXECUTED
5744: 0002e9fe .word 0x0002e9fe <== NOT EXECUTED
5748: 0002ea3a .word 0x0002ea3a <== NOT EXECUTED
574c: 0002ea45 .word 0x0002ea45 <== NOT EXECUTED
5750: 00043168 .word 0x00043168 <== NOT EXECUTED
{
if (fd->blocks[block].segment == sc)
5754: e594e018 ldr lr, [r4, #24]
5758: e79ee183 ldr lr, [lr, r3, lsl #3]
575c: e15e0005 cmp lr, r5
count++;
5760: 02822001 addeq r2, r2, #1
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
5764: e2833001 add r3, r3, #1
5768: e1530000 cmp r3, r0
576c: 1afffff8 bne 5754 <bsp_section_rodata_size+0x8a0>
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
" u:%3ld/%3ld e:%3ld/%3ld br:%ld",
seg, queues,
sc->pages, sc->pages_active, active,
sc->pages_used, used, erased,
sc->pages - (sc->pages_active +
5770: e595301c ldr r3, [r5, #28]
sc->pages_used + sc->pages_bad),
5774: e5950020 ldr r0, [r5, #32]
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
5778: e88d100a stm sp, {r1, r3, ip}
577c: e59dc038 ldr ip, [sp, #56] ; 0x38
5780: e58dc010 str ip, [sp, #16]
5784: e59dc030 ldr ip, [sp, #48] ; 0x30
5788: e58d000c str r0, [sp, #12]
578c: e58dc014 str ip, [sp, #20]
* @param req IOCTL request code. * @param argp IOCTL argument. * @retval The IOCTL return value */ static int rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
5790: e595c024 ldr ip, [r5, #36] ; 0x24
5794: e080000c add r0, r0, ip
5798: e0803003 add r3, r0, r3
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
579c: e0631001 rsb r1, r3, r1
57a0: e58d1018 str r1, [sp, #24]
57a4: e58d201c str r2, [sp, #28]
57a8: e1a00004 mov r0, r4
57ac: e1a0200b mov r2, fp
57b0: e51f1074 ldr r1, [pc, #-116] ; 5744 <bsp_section_rodata_size+0x890>
57b4: e28d305c add r3, sp, #92 ; 0x5c
57b8: ebfff804 bl 37d0 <rtems_fdisk_printf>
rtems_fdisk_printf (fd, " Device\t\t%ld", device);
rtems_fdisk_printf (fd, " Segment count\t%ld",
fd->devices[device].segment_count);
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
57bc: e28bb001 add fp, fp, #1
57c0: e2899030 add r9, r9, #48 ; 0x30
57c4: e594302c ldr r3, [r4, #44] ; 0x2c
57c8: e083200a add r2, r3, sl
57cc: e5922004 ldr r2, [r2, #4]
57d0: e15b0002 cmp fp, r2
57d4: 3affff6c bcc 558c <bsp_section_rodata_size+0x6d8>
rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
total == count ? "ok" : "MISSING");
rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);
for (device = 0; device < fd->device_count; device++)
57d8: e59dc02c ldr ip, [sp, #44] ; 0x2c
57dc: e28cc001 add ip, ip, #1
57e0: e58dc02c str ip, [sp, #44] ; 0x2c
57e4: e28aa00c add sl, sl, #12
57e8: e5943030 ldr r3, [r4, #48] ; 0x30
57ec: e59dc02c ldr ip, [sp, #44] ; 0x2c
57f0: e15c0003 cmp ip, r3
57f4: 3affff57 bcc 5558 <bsp_section_rodata_size+0x6a4>
}
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
57f8: e1a00004 mov r0, r4
57fc: e51f10bc ldr r1, [pc, #-188] ; 5748 <bsp_section_rodata_size+0x894>
count);
}
}
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
5800: e5945040 ldr r5, [r4, #64] ; 0x40
int count = 0;
5804: e3a06000 mov r6, #0
rtems_fdisk_printf (fd, "Used List:");
5808: ebfff7f0 bl 37d0 <rtems_fdisk_printf>
580c: ea00000a b 583c <bsp_section_rodata_size+0x988>
while (sc)
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
5810: e595300c ldr r3, [r5, #12]
5814: e58d3000 str r3, [sp]
5818: e5953020 ldr r3, [r5, #32]
581c: e58d3004 str r3, [sp, #4]
5820: e1a02006 mov r2, r6
5824: e5953008 ldr r3, [r5, #8]
5828: e1a00004 mov r0, r4
582c: e51f10e8 ldr r1, [pc, #-232] ; 574c <bsp_section_rodata_size+0x898>
5830: ebfff7e6 bl 37d0 <rtems_fdisk_printf>
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
5834: e5955000 ldr r5, [r5]
count++;
5838: e2866001 add r6, r6, #1
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
while (sc)
583c: e3550000 cmp r5, #0
5840: 1afffff2 bne 5810 <bsp_section_rodata_size+0x95c>
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
count++;
}
}
fd->info_level = current_info_level;
5844: e59dc03c ldr ip, [sp, #60] ; 0x3c
5848: e584c06c str ip, [r4, #108] ; 0x6c
case RTEMS_FDISK_IOCTL_INFO_LEVEL:
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
break;
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
584c: e59dc044 ldr ip, [sp, #68] ; 0x44
5850: e58c5000 str r5, [ip]
break;
5854: ea000003 b 5868 <bsp_section_rodata_size+0x9b4>
default:
rtems_blkdev_ioctl (dd, req, argp);
5858: e1a0000a mov r0, sl
585c: e1a01007 mov r1, r7
5860: e1a02004 mov r2, r4
5864: eb003813 bl 138b8 <rtems_blkdev_ioctl>
break;
}
sc = rtems_semaphore_release (rtems_flashdisks[minor].lock);
5868: e51f3120 ldr r3, [pc, #-288] ; 5750 <bsp_section_rodata_size+0x89c>
586c: e59dc034 ldr ip, [sp, #52] ; 0x34
5870: e5933000 ldr r3, [r3]
5874: e083300c add r3, r3, ip
5878: e5930064 ldr r0, [r3, #100] ; 0x64
587c: eb001577 bl ae60 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
5880: e3500000 cmp r0, #0
5884: 0a000002 beq 5894 <bsp_section_rodata_size+0x9e0>
errno = EIO;
5888: eb005f51 bl 1d5d4 <__errno> <== NOT EXECUTED
588c: e3a03005 mov r3, #5 <== NOT EXECUTED
5890: e5803000 str r3, [r0] <== NOT EXECUTED
}
return errno == 0 ? 0 : -1;
5894: eb005f4e bl 1d5d4 <__errno>
5898: e5900000 ldr r0, [r0]
589c: e3500000 cmp r0, #0
}
58a0: 13e00000 mvnne r0, #0
58a4: e28dd064 add sp, sp, #100 ; 0x64
58a8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
58ac: e59dc030 ldr ip, [sp, #48] ; 0x30
58b0: e5963014 ldr r3, [r6, #20]
58b4: e28cc001 add ip, ip, #1
58b8: e58dc030 str ip, [sp, #48] ; 0x30
58bc: e0877003 add r7, r7, r3
58c0: eafffc5a b 4a30 <rtems_fdisk_ioctl+0x364>
00003c68 <rtems_fdisk_queue_segment>:
* @param fd The flash disk control table.
* @param sc The segment control table to be reallocated
*/
static void
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
3c68: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
#if RTEMS_FDISK_TRACE rtems_fdisk_info (fd, " queue-seg:%02d-%03d: p=%d a=%d u=%d b=%d f=%s n=%s",
3c6c: e591a028 ldr sl, [r1, #40] ; 0x28
* @param fd The flash disk control table.
* @param sc The segment control table to be reallocated
*/
static void
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
3c70: e1a04001 mov r4, r1
#if RTEMS_FDISK_TRACE rtems_fdisk_info (fd, " queue-seg:%02d-%03d: p=%d a=%d u=%d b=%d f=%s n=%s",
3c74: e5918014 ldr r8, [r1, #20]
3c78: e591701c ldr r7, [r1, #28]
3c7c: e2812008 add r2, r1, #8
3c80: e2816020 add r6, r1, #32
3c84: e5949000 ldr r9, [r4]
3c88: e59f116c ldr r1, [pc, #364] ; 3dfc <rtems_fdisk_queue_segment+0x194>
3c8c: e35a0000 cmp sl, #0
3c90: e59fa168 ldr sl, [pc, #360] ; 3e00 <rtems_fdisk_queue_segment+0x198>
3c94: e59fc168 ldr ip, [pc, #360] ; 3e04 <rtems_fdisk_queue_segment+0x19c>
3c98: 11a0c001 movne ip, r1
3c9c: e59f1164 ldr r1, [pc, #356] ; 3e08 <rtems_fdisk_queue_segment+0x1a0>
3ca0: e3590000 cmp r9, #0
* @param fd The flash disk control table.
* @param sc The segment control table to be reallocated
*/
static void
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
3ca4: e24dd018 sub sp, sp, #24
#if RTEMS_FDISK_TRACE rtems_fdisk_info (fd, " queue-seg:%02d-%03d: p=%d a=%d u=%d b=%d f=%s n=%s",
3ca8: e8964040 ldm r6, {r6, lr}
3cac: 11a0100a movne r1, sl
3cb0: e892000c ldm r2, {r2, r3}
3cb4: e58d1014 str r1, [sp, #20]
3cb8: e59f114c ldr r1, [pc, #332] ; 3e0c <rtems_fdisk_queue_segment+0x1a4>
* @param fd The flash disk control table.
* @param sc The segment control table to be reallocated
*/
static void
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
3cbc: e1a05000 mov r5, r0
#if RTEMS_FDISK_TRACE rtems_fdisk_info (fd, " queue-seg:%02d-%03d: p=%d a=%d u=%d b=%d f=%s n=%s",
3cc0: e58d8000 str r8, [sp]
3cc4: e58d7004 str r7, [sp, #4]
3cc8: e58d6008 str r6, [sp, #8]
3ccc: e58de00c str lr, [sp, #12]
3cd0: e58dc010 str ip, [sp, #16]
3cd4: ebfffe9d bl 3750 <rtems_fdisk_info>
/*
* If the segment has failed then check the failed queue and append
* if not failed.
*/
if (sc->failed)
3cd8: e5943028 ldr r3, [r4, #40] ; 0x28
3cdc: e3530000 cmp r3, #0
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
3ce0: 15953058 ldrne r3, [r5, #88] ; 0x58
/*
* If the segment has failed then check the failed queue and append
* if not failed.
*/
if (sc->failed)
3ce4: 1a000003 bne 3cf8 <rtems_fdisk_queue_segment+0x90>
3ce8: ea000005 b 3d04 <rtems_fdisk_queue_segment+0x9c>
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
{
if (it == sc)
3cec: e1530004 cmp r3, r4 <== NOT EXECUTED
3cf0: 0a00003f beq 3df4 <rtems_fdisk_queue_segment+0x18c> <== NOT EXECUTED
return true;
it = it->next;
3cf4: e5933000 ldr r3, [r3] <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
3cf8: e3530000 cmp r3, #0 <== NOT EXECUTED
3cfc: 1afffffa bne 3cec <rtems_fdisk_queue_segment+0x84> <== NOT EXECUTED
3d00: ea000032 b 3dd0 <rtems_fdisk_queue_segment+0x168> <== NOT EXECUTED
}
/*
* Remove the queue from the available or used queue.
*/
rtems_fdisk_segment_queue_remove (&fd->available, sc);
3d04: e2856034 add r6, r5, #52 ; 0x34
3d08: e1a00006 mov r0, r6
3d0c: e1a01004 mov r1, r4
rtems_fdisk_segment_queue_remove (&fd->used, sc);
3d10: e2857040 add r7, r5, #64 ; 0x40
}
/*
* Remove the queue from the available or used queue.
*/
rtems_fdisk_segment_queue_remove (&fd->available, sc);
3d14: ebfffe0f bl 3558 <rtems_fdisk_segment_queue_remove>
rtems_fdisk_segment_queue_remove (&fd->used, sc);
3d18: e1a00007 mov r0, r7
3d1c: e1a01004 mov r1, r4
3d20: ebfffe0c bl 3558 <rtems_fdisk_segment_queue_remove>
* If they are and the driver has been configured to background * erase place the segment on the used queue. If not configured * to background erase perform the erase now. * */ if (rtems_fdisk_seg_pages_available (sc) == 0)
3d24: e1a00004 mov r0, r4
3d28: ebfffe70 bl 36f0 <rtems_fdisk_seg_pages_available>
3d2c: e2508000 subs r8, r0, #0
* bit is cleared for that segment. When 32 erasers
* has occurred the page is re-written to the flash
* with all the counters updated with the number of
* bits cleared and all bits set back to 1.
*/
rtems_fdisk_segment_ctl* seg = fd->available.head;
3d30: 15955034 ldrne r5, [r5, #52] ; 0x34
* If they are and the driver has been configured to background
* erase place the segment on the used queue. If not configured
* to background erase perform the erase now.
*
*/
if (rtems_fdisk_seg_pages_available (sc) == 0)
3d34: 1a00001c bne 3dac <rtems_fdisk_queue_segment+0x144>
{
if (sc->pages_active)
3d38: e594301c ldr r3, [r4, #28]
3d3c: e3530000 cmp r3, #0
/*
* Keep the used queue sorted by the most number of used
* pages. When we compact we want to move the pages into
* a new segment and cover more than one segment.
*/
rtems_fdisk_segment_ctl* seg = fd->used.head;
3d40: 15951040 ldrne r1, [r5, #64] ; 0x40
* to background erase perform the erase now.
*
*/
if (rtems_fdisk_seg_pages_available (sc) == 0)
{
if (sc->pages_active)
3d44: 1a000005 bne 3d60 <rtems_fdisk_queue_segment+0xf8>
3d48: ea000009 b 3d74 <rtems_fdisk_queue_segment+0x10c> <== NOT EXECUTED
*/
rtems_fdisk_segment_ctl* seg = fd->used.head;
while (seg)
{
if (sc->pages_used > seg->pages_used)
3d4c: e5942020 ldr r2, [r4, #32]
3d50: e5913020 ldr r3, [r1, #32]
3d54: e1520003 cmp r2, r3
3d58: 8a000003 bhi 3d6c <rtems_fdisk_queue_segment+0x104>
break;
seg = seg->next;
3d5c: e5911000 ldr r1, [r1]
* pages. When we compact we want to move the pages into
* a new segment and cover more than one segment.
*/
rtems_fdisk_segment_ctl* seg = fd->used.head;
while (seg)
3d60: e3510000 cmp r1, #0
3d64: 1afffff8 bne 3d4c <rtems_fdisk_queue_segment+0xe4>
3d68: ea00001a b 3dd8 <rtems_fdisk_queue_segment+0x170>
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->used, seg, sc);
3d6c: e1a00007 mov r0, r7
3d70: ea000012 b 3dc0 <rtems_fdisk_queue_segment+0x158>
else
rtems_fdisk_segment_queue_push_tail (&fd->used, sc);
}
else
{
if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))
3d74: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
3d78: e3130001 tst r3, #1 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->erase, sc);
3d7c: 1285004c addne r0, r5, #76 ; 0x4c <== NOT EXECUTED
else
rtems_fdisk_segment_queue_push_tail (&fd->used, sc);
}
else
{
if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))
3d80: 1a000017 bne 3de4 <rtems_fdisk_queue_segment+0x17c> <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->erase, sc);
else
rtems_fdisk_erase_segment (fd, sc);
3d84: e1a00005 mov r0, r5 <== NOT EXECUTED
3d88: e1a01004 mov r1, r4 <== NOT EXECUTED
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
else
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
3d8c: e28dd018 add sp, sp, #24 <== NOT EXECUTED
3d90: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
else
{
if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))
rtems_fdisk_segment_queue_push_tail (&fd->erase, sc);
else
rtems_fdisk_erase_segment (fd, sc);
3d94: eaffff74 b 3b6c <rtems_fdisk_erase_segment> <== NOT EXECUTED
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
{
if (rtems_fdisk_seg_pages_available (sc) <
rtems_fdisk_seg_pages_available (seg))
3d98: e1a00005 mov r0, r5
3d9c: ebfffe53 bl 36f0 <rtems_fdisk_seg_pages_available>
*/
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
{
if (rtems_fdisk_seg_pages_available (sc) <
3da0: e1580000 cmp r8, r0
3da4: 3a000003 bcc 3db8 <rtems_fdisk_queue_segment+0x150>
rtems_fdisk_seg_pages_available (seg))
break;
seg = seg->next;
3da8: e5955000 ldr r5, [r5]
* with all the counters updated with the number of
* bits cleared and all bits set back to 1.
*/
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
3dac: e3550000 cmp r5, #0
3db0: 1afffff8 bne 3d98 <rtems_fdisk_queue_segment+0x130>
3db4: ea000009 b 3de0 <rtems_fdisk_queue_segment+0x178>
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
3db8: e1a00006 mov r0, r6
3dbc: e1a01005 mov r1, r5
3dc0: e1a02004 mov r2, r4
else
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
3dc4: e28dd018 add sp, sp, #24
3dc8: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
3dcc: eafffdfb b 35c0 <rtems_fdisk_segment_queue_insert_before>
* if not failed.
*/
if (sc->failed)
{
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
3dd0: e2850058 add r0, r5, #88 ; 0x58 <== NOT EXECUTED
3dd4: ea000002 b 3de4 <rtems_fdisk_queue_segment+0x17c> <== NOT EXECUTED
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->used, seg, sc);
else
rtems_fdisk_segment_queue_push_tail (&fd->used, sc);
3dd8: e1a00007 mov r0, r7
3ddc: ea000000 b 3de4 <rtems_fdisk_queue_segment+0x17c>
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
else
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
3de0: e1a00006 mov r0, r6
3de4: e1a01004 mov r1, r4
} }
3de8: e28dd018 add sp, sp, #24
3dec: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
else
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
3df0: eafffdc9 b 351c <rtems_fdisk_segment_queue_push_tail>
} }
3df4: e28dd018 add sp, sp, #24 <== NOT EXECUTED
3df8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
0000360c <rtems_fdisk_queue_status>:
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
360c: e5903034 ldr r3, [r0, #52] ; 0x34
3610: ea000002 b 3620 <rtems_fdisk_queue_status+0x14>
while (it)
{
if (it == sc)
3614: e1530001 cmp r3, r1
3618: 0a000004 beq 3630 <rtems_fdisk_queue_status+0x24>
return true;
it = it->next;
361c: e5933000 ldr r3, [r3]
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
3620: e3530000 cmp r3, #0
3624: 1afffffa bne 3614 <rtems_fdisk_queue_status+0x8>
static void
rtems_fdisk_queue_status (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
char queues[5])
{
queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
3628: e3a0302d mov r3, #45 ; 0x2d
362c: ea000000 b 3634 <rtems_fdisk_queue_status+0x28>
3630: e3a03041 mov r3, #65 ; 0x41
3634: e5c23000 strb r3, [r2]
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
3638: e5903040 ldr r3, [r0, #64] ; 0x40
363c: ea000002 b 364c <rtems_fdisk_queue_status+0x40>
while (it)
{
if (it == sc)
3640: e1530001 cmp r3, r1
3644: 0a000004 beq 365c <rtems_fdisk_queue_status+0x50>
return true;
it = it->next;
3648: e5933000 ldr r3, [r3]
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
364c: e3530000 cmp r3, #0
3650: 1afffffa bne 3640 <rtems_fdisk_queue_status+0x34>
rtems_fdisk_queue_status (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
char queues[5])
{
queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc) ? 'U' : '-';
3654: e3a0302d mov r3, #45 ; 0x2d
3658: ea000000 b 3660 <rtems_fdisk_queue_status+0x54>
365c: e3a03055 mov r3, #85 ; 0x55
3660: e5c23001 strb r3, [r2, #1]
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
3664: e590304c ldr r3, [r0, #76] ; 0x4c
3668: ea000002 b 3678 <rtems_fdisk_queue_status+0x6c>
while (it)
{
if (it == sc)
366c: e1530001 cmp r3, r1 <== NOT EXECUTED
3670: 0a000004 beq 3688 <rtems_fdisk_queue_status+0x7c> <== NOT EXECUTED
return true;
it = it->next;
3674: e5933000 ldr r3, [r3] <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
3678: e3530000 cmp r3, #0
367c: 1afffffa bne 366c <rtems_fdisk_queue_status+0x60>
rtems_fdisk_segment_ctl* sc,
char queues[5])
{
queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc) ? 'U' : '-';
queues[2] = rtems_fdisk_segment_queue_present (&fd->erase, sc) ? 'E' : '-';
3680: e3a0302d mov r3, #45 ; 0x2d
3684: ea000000 b 368c <rtems_fdisk_queue_status+0x80>
3688: e3a03045 mov r3, #69 ; 0x45 <== NOT EXECUTED
368c: e5c23002 strb r3, [r2, #2]
*/
static bool
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
3690: e5903058 ldr r3, [r0, #88] ; 0x58
3694: ea000002 b 36a4 <rtems_fdisk_queue_status+0x98>
while (it)
{
if (it == sc)
3698: e1530001 cmp r3, r1 <== NOT EXECUTED
369c: 0a000004 beq 36b4 <rtems_fdisk_queue_status+0xa8> <== NOT EXECUTED
return true;
it = it->next;
36a0: e5933000 ldr r3, [r3] <== NOT EXECUTED
rtems_fdisk_segment_queue_present (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
36a4: e3530000 cmp r3, #0
36a8: 1afffffa bne 3698 <rtems_fdisk_queue_status+0x8c>
char queues[5])
{
queues[0] = rtems_fdisk_segment_queue_present (&fd->available, sc) ? 'A' : '-';
queues[1] = rtems_fdisk_segment_queue_present (&fd->used, sc) ? 'U' : '-';
queues[2] = rtems_fdisk_segment_queue_present (&fd->erase, sc) ? 'E' : '-';
queues[3] = rtems_fdisk_segment_queue_present (&fd->failed, sc) ? 'F' : '-';
36ac: e3a0302d mov r3, #45 ; 0x2d
36b0: ea000000 b 36b8 <rtems_fdisk_queue_status+0xac>
36b4: e3a03046 mov r3, #70 ; 0x46 <== NOT EXECUTED
36b8: e5c23003 strb r3, [r2, #3]
queues[4] = '\0';
36bc: e3a03000 mov r3, #0
36c0: e5c23004 strb r3, [r2, #4]
}
36c4: e12fff1e bx lr
000043b0 <rtems_fdisk_recover_block_mappings>:
/**
* Recover the block mappings from the devices.
*/
static int
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)
{
43b0: e92d4fff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, lr}
* Initialise the segment control queue.
*/
static void
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue)
{
queue->head = queue->tail = 0;
43b4: e3a09000 mov r9, #0
/**
* Recover the block mappings from the devices.
*/
static int
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)
{
43b8: e1a04000 mov r4, r0
* Initialise the segment control queue.
*/
static void
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue)
{
queue->head = queue->tail = 0;
43bc: e5809038 str r9, [r0, #56] ; 0x38
43c0: e5809034 str r9, [r0, #52] ; 0x34
queue->count = 0;
43c4: e580903c str r9, [r0, #60] ; 0x3c
* Initialise the segment control queue.
*/
static void
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue)
{
queue->head = queue->tail = 0;
43c8: e5809044 str r9, [r0, #68] ; 0x44
43cc: e5809040 str r9, [r0, #64] ; 0x40
queue->count = 0;
43d0: e5809048 str r9, [r0, #72] ; 0x48
* Initialise the segment control queue.
*/
static void
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue)
{
queue->head = queue->tail = 0;
43d4: e5809050 str r9, [r0, #80] ; 0x50
43d8: e580904c str r9, [r0, #76] ; 0x4c
queue->count = 0;
43dc: e5809054 str r9, [r0, #84] ; 0x54
* Initialise the segment control queue.
*/
static void
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue)
{
queue->head = queue->tail = 0;
43e0: e580905c str r9, [r0, #92] ; 0x5c
43e4: e5809058 str r9, [r0, #88] ; 0x58
queue->count = 0;
43e8: e5809060 str r9, [r0, #96] ; 0x60
rtems_fdisk_segment_queue_init (&fd->failed);
/*
* Clear the lock mappings.
*/
memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
43ec: e2800018 add r0, r0, #24
43f0: e8900005 ldm r0, {r0, r2}
43f4: e1a01009 mov r1, r9
43f8: e1a02182 lsl r2, r2, #3
43fc: eb006919 bl 1e868 <memset>
/* * Scan each segment or each device recovering the valid pages. */ fd->erased_blocks = 0; fd->starvation_threshold = 0; for (device = 0; device < fd->device_count; device++)
4400: e1a08009 mov r8, r9
memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
4404: e5849028 str r9, [r4, #40] ; 0x28
fd->starvation_threshold = 0;
4408: e5849024 str r9, [r4, #36] ; 0x24
for (device = 0; device < fd->device_count; device++)
440c: ea0000a0 b 4694 <rtems_fdisk_recover_block_mappings+0x2e4>
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[segment];
4410: e7935009 ldr r5, [r3, r9]
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
4414: e1a02008 mov r2, r8
for (device = 0; device < fd->device_count; device++)
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[segment];
4418: e085500b add r5, r5, fp
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
441c: e1a0300a mov r3, sl
4420: e59f1288 ldr r1, [pc, #648] ; 46b0 <rtems_fdisk_recover_block_mappings+0x300>
4424: e1a00004 mov r0, r4
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[segment];
const rtems_fdisk_segment_desc* sd = sc->descriptor;
4428: e5956004 ldr r6, [r5, #4]
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
442c: ebfffcc7 bl 3750 <rtems_fdisk_info>
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
4430: e5947014 ldr r7, [r4, #20]
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
4434: e5960008 ldr r0, [r6, #8]
4438: e1a01007 mov r1, r7
443c: ebfff53f bl 1940 <__aeabi_uidiv>
4440: e1a06000 mov r6, r0
static uint32_t
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
4444: e1a00180 lsl r0, r0, #3
return ((bytes - 1) / page_size) + 1;
4448: e2400001 sub r0, r0, #1
444c: e1a01007 mov r1, r7
4450: ebfff53a bl 1940 <__aeabi_uidiv>
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
if (sc->pages > fd->starvation_threshold)
4454: e5942024 ldr r2, [r4, #36] ; 0x24
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
return ((bytes - 1) / page_size) + 1;
4458: e2803001 add r3, r0, #1
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
445c: e0636006 rsb r6, r3, r6
if (sc->pages > fd->starvation_threshold)
4460: e1560002 cmp r6, r2
fd->starvation_threshold = sc->pages;
sc->pages_active = 0;
4464: e3a02000 mov r2, #0
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
4468: e5853018 str r3, [r5, #24]
sc->pages =
446c: e5856014 str r6, [r5, #20]
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
if (sc->pages > fd->starvation_threshold)
fd->starvation_threshold = sc->pages;
4470: 85846024 strhi r6, [r4, #36] ; 0x24
sc->pages_active = 0;
4474: e585201c str r2, [r5, #28]
sc->pages_used = 0;
4478: e5852020 str r2, [r5, #32]
sc->pages_bad = 0;
447c: e5852024 str r2, [r5, #36] ; 0x24
sc->failed = false;
4480: e5852028 str r2, [r5, #40] ; 0x28
if (!sc->page_descriptors)
4484: e5952010 ldr r2, [r5, #16]
4488: e3520000 cmp r2, #0
448c: 1a000004 bne 44a4 <rtems_fdisk_recover_block_mappings+0xf4>
sc->page_descriptors = malloc (sc->pages_desc * fd->block_size);
4490: e0000397 mul r0, r7, r3
4494: e58d300c str r3, [sp, #12]
4498: eb000a4c bl 6dd0 <malloc>
449c: e59d300c ldr r3, [sp, #12]
44a0: e5850010 str r0, [r5, #16]
if (!sc->page_descriptors)
44a4: e5956010 ldr r6, [r5, #16]
44a8: e3560000 cmp r6, #0
rtems_fdisk_abort ("no memory for page descriptors");
44ac: 059f0200 ldreq r0, [pc, #512] ; 46b4 <rtems_fdisk_recover_block_mappings+0x304>
44b0: 0bfff078 bleq 698 <rtems_fdisk_abort>
* descriptors.
*
* @todo It may be better to ask the driver to get these value
* so NAND flash could be better supported.
*/
ret = rtems_fdisk_seg_read (fd, sc, 0, (void*) pd,
44b4: e0070793 mul r7, r3, r7
44b8: e1a00004 mov r0, r4
44bc: e1a01005 mov r1, r5
44c0: e3a02000 mov r2, #0
44c4: e1a03006 mov r3, r6
44c8: e58d7000 str r7, [sp]
44cc: ebfffcdf bl 3850 <rtems_fdisk_seg_read>
sc->pages_desc * fd->block_size);
if (ret)
44d0: e2507000 subs r7, r0, #0
44d4: 0a00005c beq 464c <rtems_fdisk_recover_block_mappings+0x29c>
{
rtems_fdisk_error ("recover-block-mappings:%02d-%03d: " \
44d8: eb006e01 bl 1fce4 <strerror> <== NOT EXECUTED
44dc: e1a01008 mov r1, r8 <== NOT EXECUTED
44e0: e1a03000 mov r3, r0 <== NOT EXECUTED
44e4: e1a0200a mov r2, sl <== NOT EXECUTED
44e8: e59f01c8 ldr r0, [pc, #456] ; 46b8 <rtems_fdisk_recover_block_mappings+0x308><== NOT EXECUTED
44ec: e58d7000 str r7, [sp] <== NOT EXECUTED
44f0: ebfffd81 bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
"read page desc failed: %s (%d)",
device, segment, strerror (ret), ret);
return ret;
44f4: ea00006a b 46a4 <rtems_fdisk_recover_block_mappings+0x2f4> <== NOT EXECUTED
* If the page is active see if the block is with-in range and
* if the block is a duplicate.
*/
for (page = 0; page < sc->pages; page++, pd++)
{
if (rtems_fdisk_page_desc_erased (pd))
44f8: e1a00006 mov r0, r6
44fc: ebfffc71 bl 36c8 <rtems_fdisk_page_desc_erased>
4500: e3500000 cmp r0, #0
4504: 0a000023 beq 4598 <rtems_fdisk_recover_block_mappings+0x1e8>
{
/*
* Is the page erased ?
*/
ret = rtems_fdisk_seg_blank_check_page (fd, sc,
4508: e5952018 ldr r2, [r5, #24]
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page)
{
return rtems_fdisk_seg_blank_check (fd, sc,
page * fd->block_size, fd->block_size);
450c: e5943014 ldr r3, [r4, #20]
if (rtems_fdisk_page_desc_erased (pd))
{
/*
* Is the page erased ?
*/
ret = rtems_fdisk_seg_blank_check_page (fd, sc,
4510: e0872002 add r2, r7, r2
static int
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page)
{
return rtems_fdisk_seg_blank_check (fd, sc,
4514: e0020293 mul r2, r3, r2
4518: e1a00004 mov r0, r4
451c: e1a01005 mov r1, r5
4520: ebfffce8 bl 38c8 <rtems_fdisk_seg_blank_check>
* Is the page erased ?
*/
ret = rtems_fdisk_seg_blank_check_page (fd, sc,
page + sc->pages_desc);
if (ret == 0)
4524: e3500000 cmp r0, #0
{
++fd->erased_blocks;
4528: 05943028 ldreq r3, [r4, #40] ; 0x28
452c: 02833001 addeq r3, r3, #1
4530: 05843028 streq r3, [r4, #40] ; 0x28
* Is the page erased ?
*/
ret = rtems_fdisk_seg_blank_check_page (fd, sc,
page + sc->pages_desc);
if (ret == 0)
4534: 0a000042 beq 4644 <rtems_fdisk_recover_block_mappings+0x294>
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
4538: e58d7000 str r7, [sp] <== NOT EXECUTED
453c: e5963004 ldr r3, [r6, #4] <== NOT EXECUTED
4540: e59f1174 ldr r1, [pc, #372] ; 46bc <rtems_fdisk_recover_block_mappings+0x30c><== NOT EXECUTED
4544: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
4548: e1a02008 mov r2, r8 <== NOT EXECUTED
454c: e1a0300a mov r3, sl <== NOT EXECUTED
4550: e1a00004 mov r0, r4 <== NOT EXECUTED
4554: ebfffd49 bl 3a80 <rtems_fdisk_warning> <== NOT EXECUTED
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
4558: e1d630b2 ldrh r3, [r6, #2] <== NOT EXECUTED
455c: e3c33002 bic r3, r3, #2 <== NOT EXECUTED
4560: e1c630b2 strh r3, [r6, #2] <== NOT EXECUTED
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
device, segment, page, pd->block);
#endif
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
4564: e1a00004 mov r0, r4 <== NOT EXECUTED
4568: e1a01005 mov r1, r5 <== NOT EXECUTED
456c: e1a02007 mov r2, r7 <== NOT EXECUTED
4570: e1a03006 mov r3, r6 <== NOT EXECUTED
4574: ebfffd14 bl 39cc <rtems_fdisk_seg_write_page_desc> <== NOT EXECUTED
page, pd);
if (ret)
4578: e3500000 cmp r0, #0 <== NOT EXECUTED
457c: 0a000008 beq 45a4 <rtems_fdisk_recover_block_mappings+0x1f4><== NOT EXECUTED
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
4580: e1a01008 mov r1, r8 <== NOT EXECUTED
4584: e1a0200a mov r2, sl <== NOT EXECUTED
4588: e1a03007 mov r3, r7 <== NOT EXECUTED
458c: e59f012c ldr r0, [pc, #300] ; 46c0 <rtems_fdisk_recover_block_mappings+0x310><== NOT EXECUTED
4590: ebfffd59 bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
4594: ea000002 b 45a4 <rtems_fdisk_recover_block_mappings+0x1f4> <== NOT EXECUTED
* only set a flag by changing it from 1 to 0.
*/
static bool
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{
return (pd->flags & flags) == 0 ? true : false;
4598: e1d630b2 ldrh r3, [r6, #2] <== NOT EXECUTED
sc->pages_used++;
}
}
else
{
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_USED))
459c: e3130002 tst r3, #2 <== NOT EXECUTED
45a0: 1a000003 bne 45b4 <rtems_fdisk_recover_block_mappings+0x204><== NOT EXECUTED
{
sc->pages_used++;
45a4: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED
45a8: e2833001 add r3, r3, #1 <== NOT EXECUTED
45ac: e5853020 str r3, [r5, #32] <== NOT EXECUTED
45b0: ea000023 b 4644 <rtems_fdisk_recover_block_mappings+0x294> <== NOT EXECUTED
}
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
45b4: e3130001 tst r3, #1 <== NOT EXECUTED
45b8: 1a00001e bne 4638 <rtems_fdisk_recover_block_mappings+0x288><== NOT EXECUTED
{
if (pd->block >= fd->block_count)
45bc: e5961004 ldr r1, [r6, #4] <== NOT EXECUTED
45c0: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
45c4: e1510003 cmp r1, r3 <== NOT EXECUTED
45c8: 3a000007 bcc 45ec <rtems_fdisk_recover_block_mappings+0x23c><== NOT EXECUTED
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd,
45cc: e58d1004 str r1, [sp, #4] <== NOT EXECUTED
45d0: e1a00004 mov r0, r4 <== NOT EXECUTED
45d4: e59f10e8 ldr r1, [pc, #232] ; 46c4 <rtems_fdisk_recover_block_mappings+0x314><== NOT EXECUTED
45d8: e1a02008 mov r2, r8 <== NOT EXECUTED
45dc: e1a0300a mov r3, sl <== NOT EXECUTED
45e0: e58d7000 str r7, [sp] <== NOT EXECUTED
45e4: ebfffd25 bl 3a80 <rtems_fdisk_warning> <== NOT EXECUTED
45e8: ea000012 b 4638 <rtems_fdisk_recover_block_mappings+0x288> <== NOT EXECUTED
"invalid block number: %d-%d-%d: block: %d",
device, segment, page, pd->block);
#endif
sc->pages_bad++;
}
else if (fd->blocks[pd->block].segment)
45ec: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED
45f0: e7902181 ldr r2, [r0, r1, lsl #3] <== NOT EXECUTED
45f4: e3520000 cmp r2, #0 <== NOT EXECUTED
45f8: e0803181 add r3, r0, r1, lsl #3 <== NOT EXECUTED
45fc: 0a000007 beq 4620 <rtems_fdisk_recover_block_mappings+0x270><== NOT EXECUTED
* each block so we can tell which is the later block when
* duplicates appear. A power down with a failed wirte could cause
* a duplicate.
*/
const rtems_fdisk_segment_ctl* bsc = fd->blocks[pd->block].segment;
rtems_fdisk_error ("duplicate block: %d-%d-%d: " \
4600: e88d0500 stm sp, {r8, sl} <== NOT EXECUTED
4604: e58d7008 str r7, [sp, #8] <== NOT EXECUTED
4608: e2821008 add r1, r2, #8 <== NOT EXECUTED
460c: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
4610: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
4614: e59f00ac ldr r0, [pc, #172] ; 46c8 <rtems_fdisk_recover_block_mappings+0x318><== NOT EXECUTED
4618: ebfffd37 bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
461c: ea000005 b 4638 <rtems_fdisk_recover_block_mappings+0x288> <== NOT EXECUTED
/**
* @todo
* Add start up crc checks here.
*/
fd->blocks[pd->block].segment = sc;
fd->blocks[pd->block].page = page;
4620: e5837004 str r7, [r3, #4] <== NOT EXECUTED
/*
* The page is active.
*/
sc->pages_active++;
4624: e595301c ldr r3, [r5, #28] <== NOT EXECUTED
4628: e2833001 add r3, r3, #1 <== NOT EXECUTED
{
/**
* @todo
* Add start up crc checks here.
*/
fd->blocks[pd->block].segment = sc;
462c: e7805181 str r5, [r0, r1, lsl #3] <== NOT EXECUTED
fd->blocks[pd->block].page = page;
/*
* The page is active.
*/
sc->pages_active++;
4630: e585301c str r3, [r5, #28] <== NOT EXECUTED
4634: ea000002 b 4644 <rtems_fdisk_recover_block_mappings+0x294> <== NOT EXECUTED
}
}
else
sc->pages_bad++;
4638: e5953024 ldr r3, [r5, #36] ; 0x24 <== NOT EXECUTED
463c: e2833001 add r3, r3, #1 <== NOT EXECUTED
4640: e5853024 str r3, [r5, #36] ; 0x24 <== NOT EXECUTED
* are active and how many are used.
*
* If the page is active see if the block is with-in range and
* if the block is a duplicate.
*/
for (page = 0; page < sc->pages; page++, pd++)
4644: e2877001 add r7, r7, #1
4648: e2866008 add r6, r6, #8
464c: e5953014 ldr r3, [r5, #20]
4650: e1570003 cmp r7, r3
4654: 3affffa7 bcc 44f8 <rtems_fdisk_recover_block_mappings+0x148>
}
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, sc);
4658: e1a00004 mov r0, r4
465c: e1a01005 mov r1, r5
4660: ebfffd80 bl 3c68 <rtems_fdisk_queue_segment>
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
4664: e28aa001 add sl, sl, #1
4668: e28bb030 add fp, fp, #48 ; 0x30
466c: ea000001 b 4678 <rtems_fdisk_recover_block_mappings+0x2c8>
/* * Scan each segment or each device recovering the valid pages. */ fd->erased_blocks = 0; fd->starvation_threshold = 0; for (device = 0; device < fd->device_count; device++)
4670: e3a0b000 mov fp, #0
4674: e1a0a00b mov sl, fp
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
4678: e594302c ldr r3, [r4, #44] ; 0x2c
467c: e0832009 add r2, r3, r9
4680: e5922004 ldr r2, [r2, #4]
4684: e15a0002 cmp sl, r2
4688: 3affff60 bcc 4410 <rtems_fdisk_recover_block_mappings+0x60>
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
468c: e2888001 add r8, r8, #1
4690: e289900c add r9, r9, #12
4694: e5943030 ldr r3, [r4, #48] ; 0x30
4698: e1580003 cmp r8, r3
469c: 3afffff3 bcc 4670 <rtems_fdisk_recover_block_mappings+0x2c0>
*/
rtems_fdisk_queue_segment (fd, sc);
}
}
return 0;
46a0: e3a07000 mov r7, #0
}
46a4: e1a00007 mov r0, r7
46a8: e28dd010 add sp, sp, #16
46ac: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00003e10 <rtems_fdisk_recycle_segment>:
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* ssc,
rtems_fdisk_segment_ctl* dsc,
uint32_t *pages)
{
3e10: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
int ret; uint32_t spage; uint32_t used = 0; uint32_t active = 0;
3e14: e3a0b000 mov fp, #0
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* ssc,
rtems_fdisk_segment_ctl* dsc,
uint32_t *pages)
{
3e18: e24dd02c sub sp, sp, #44 ; 0x2c
3e1c: e1a06002 mov r6, r2
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
if (dst_pages == 0)
dsc = rtems_fdisk_seg_most_available (&fd->available);
3e20: e2802034 add r2, r0, #52 ; 0x34
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* ssc,
rtems_fdisk_segment_ctl* dsc,
uint32_t *pages)
{
3e24: e1a04000 mov r4, r0
3e28: e1a05001 mov r5, r1
3e2c: e58d3020 str r3, [sp, #32]
int ret; uint32_t spage; uint32_t used = 0;
3e30: e58db01c str fp, [sp, #28]
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
3e34: e1a0a00b mov sl, fp
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
if (dst_pages == 0)
dsc = rtems_fdisk_seg_most_available (&fd->available);
3e38: e58d2028 str r2, [sp, #40] ; 0x28
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
3e3c: ea0000c0 b 4144 <rtems_fdisk_recycle_segment+0x334>
{
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
if (!dsc && ssc->pages_active > 0)
3e40: e3560000 cmp r6, #0
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
{
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
3e44: e5959010 ldr r9, [r5, #16]
if (!dsc && ssc->pages_active > 0)
3e48: 1a000005 bne 3e64 <rtems_fdisk_recycle_segment+0x54>
3e4c: e595301c ldr r3, [r5, #28]
3e50: e3530000 cmp r3, #0
3e54: 0a000002 beq 3e64 <rtems_fdisk_recycle_segment+0x54>
{
rtems_fdisk_error ("recycle: no available dst segment");
3e58: e59f0344 ldr r0, [pc, #836] ; 41a4 <rtems_fdisk_recycle_segment+0x394><== NOT EXECUTED
3e5c: ebffff26 bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
3e60: ea00004d b 3f9c <rtems_fdisk_recycle_segment+0x18c> <== NOT EXECUTED
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
{
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
3e64: e089918a add r9, r9, sl, lsl #3
* only set a flag by changing it from 1 to 0.
*/
static bool
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{
return (pd->flags & flags) == 0 ? true : false;
3e68: e1d930b2 ldrh r3, [r9, #2]
{
rtems_fdisk_error ("recycle: no available dst segment");
return EIO;
}
if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
3e6c: e2137001 ands r7, r3, #1
3e70: 1a0000a9 bne 411c <rtems_fdisk_recycle_segment+0x30c>
3e74: e3130002 tst r3, #2
* Find the next available page in a segment.
*/
static uint32_t
rtems_fdisk_seg_next_available_page (rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_page_desc* pd = &sc->page_descriptors[0];
3e78: 15963010 ldrne r3, [r6, #16]
3e7c: 158d3024 strne r3, [sp, #36] ; 0x24
3e80: 11a08003 movne r8, r3
{
rtems_fdisk_error ("recycle: no available dst segment");
return EIO;
}
if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
3e84: 1a00002c bne 3f3c <rtems_fdisk_recycle_segment+0x12c>
3e88: ea0000a3 b 411c <rtems_fdisk_recycle_segment+0x30c>
{
rtems_fdisk_page_desc* pd = &sc->page_descriptors[0];
uint32_t page;
for (page = 0; page < sc->pages; page++, pd++)
if (rtems_fdisk_page_desc_erased (pd))
3e8c: e1a00008 mov r0, r8
3e90: ebfffe0c bl 36c8 <rtems_fdisk_page_desc_erased>
3e94: e3500000 cmp r0, #0
3e98: 0a000025 beq 3f34 <rtems_fdisk_recycle_segment+0x124>
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return EIO;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recycle: %02d-%03d-%03d=>%02d-%03d-%03d",
3e9c: e58da000 str sl, [sp]
3ea0: e5963008 ldr r3, [r6, #8]
3ea4: e58d3004 str r3, [sp, #4]
3ea8: e596300c ldr r3, [r6, #12]
3eac: e58d700c str r7, [sp, #12]
3eb0: e58d3008 str r3, [sp, #8]
3eb4: e2852008 add r2, r5, #8
3eb8: e892000c ldm r2, {r2, r3}
3ebc: e59f12e4 ldr r1, [pc, #740] ; 41a8 <rtems_fdisk_recycle_segment+0x398>
3ec0: e1a00004 mov r0, r4
3ec4: ebfffe21 bl 3750 <rtems_fdisk_info>
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage);
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
3ec8: e5958018 ldr r8, [r5, #24]
3ecc: e08a8008 add r8, sl, r8
3ed0: e596c018 ldr ip, [r6, #24]
rtems_fdisk_segment_ctl* dst_sc,
uint32_t dst_page)
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-copy-page: %02d-%03d~%03d=>%02d-%03d~%03d",
3ed4: e58d8000 str r8, [sp]
3ed8: e5963008 ldr r3, [r6, #8]
3edc: e58d3004 str r3, [sp, #4]
3ee0: e596300c ldr r3, [r6, #12]
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recycle: %02d-%03d-%03d=>%02d-%03d-%03d",
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage);
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
3ee4: e087c00c add ip, r7, ip
rtems_fdisk_segment_ctl* dst_sc,
uint32_t dst_page)
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-copy-page: %02d-%03d~%03d=>%02d-%03d~%03d",
3ee8: e58dc00c str ip, [sp, #12]
3eec: e58d3008 str r3, [sp, #8]
3ef0: e2852008 add r2, r5, #8
3ef4: e892000c ldm r2, {r2, r3}
3ef8: e59f12ac ldr r1, [pc, #684] ; 41ac <rtems_fdisk_recycle_segment+0x39c>
3efc: e1a00004 mov r0, r4
3f00: e58dc018 str ip, [sp, #24]
3f04: ebfffe31 bl 37d0 <rtems_fdisk_printf>
rtems_fdisk_segment_ctl* sc,
uint32_t page,
void* buffer)
{
return rtems_fdisk_seg_read (fd, sc,
page * fd->block_size, buffer, fd->block_size);
3f08: e5942014 ldr r2, [r4, #20]
rtems_fdisk_seg_read_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page,
void* buffer)
{
return rtems_fdisk_seg_read (fd, sc,
3f0c: e1a00004 mov r0, r4
3f10: e58d2000 str r2, [sp]
3f14: e1a01005 mov r1, r5
3f18: e0020298 mul r2, r8, r2
3f1c: e5943068 ldr r3, [r4, #104] ; 0x68
3f20: ebfffe4a bl 3850 <rtems_fdisk_seg_read>
src_sc->device, src_sc->segment, src_page,
dst_sc->device, dst_sc->segment, dst_page);
#endif
ret = rtems_fdisk_seg_read_page (fd, src_sc, src_page,
fd->copy_buffer);
if (ret)
3f24: e2508000 subs r8, r0, #0
3f28: e59dc018 ldr ip, [sp, #24]
3f2c: 1a000023 bne 3fc0 <rtems_fdisk_recycle_segment+0x1b0>
3f30: ea00001b b 3fa4 <rtems_fdisk_recycle_segment+0x194>
rtems_fdisk_seg_next_available_page (rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_page_desc* pd = &sc->page_descriptors[0];
uint32_t page;
for (page = 0; page < sc->pages; page++, pd++)
3f34: e2877001 add r7, r7, #1
3f38: e2888008 add r8, r8, #8
3f3c: e5963014 ldr r3, [r6, #20]
3f40: e1570003 cmp r7, r3
3f44: 3affffd0 bcc 3e8c <rtems_fdisk_recycle_segment+0x7c>
active++;
if (dpage >= dsc->pages)
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
3f48: e1a00006 mov r0, r6 <== NOT EXECUTED
3f4c: ebfffde7 bl 36f0 <rtems_fdisk_seg_pages_available> <== NOT EXECUTED
3f50: e2861008 add r1, r6, #8 <== NOT EXECUTED
3f54: e1a03000 mov r3, r0 <== NOT EXECUTED
3f58: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
3f5c: e59f024c ldr r0, [pc, #588] ; 41b0 <rtems_fdisk_recycle_segment+0x3a0><== NOT EXECUTED
3f60: ebfffee5 bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
"no page desc available: %d",
dsc->device, dsc->segment,
rtems_fdisk_seg_pages_available (dsc));
dsc->failed = true;
3f64: e3a03001 mov r3, #1 <== NOT EXECUTED
3f68: e5863028 str r3, [r6, #40] ; 0x28 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, dsc);
3f6c: e1a00004 mov r0, r4 <== NOT EXECUTED
3f70: e1a01006 mov r1, r6 <== NOT EXECUTED
3f74: ebffff3b bl 3c68 <rtems_fdisk_queue_segment> <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = queue->head;
3f78: e5943040 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED
3f7c: e5853000 str r3, [r5] <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
3f80: e5943044 ldr r3, [r4, #68] ; 0x44 <== NOT EXECUTED
3f84: e3530000 cmp r3, #0 <== NOT EXECUTED
queue->tail = sc;
queue->count++;
3f88: e5943048 ldr r3, [r4, #72] ; 0x48 <== NOT EXECUTED
3f8c: e2833001 add r3, r3, #1 <== NOT EXECUTED
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = queue->head;
queue->head = sc;
3f90: e5845040 str r5, [r4, #64] ; 0x40 <== NOT EXECUTED
if (queue->tail == 0)
queue->tail = sc;
3f94: 05845044 streq r5, [r4, #68] ; 0x44 <== NOT EXECUTED
queue->count++;
3f98: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
dsc->device, dsc->segment,
rtems_fdisk_seg_pages_available (dsc));
dsc->failed = true;
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return EIO;
3f9c: e3a08005 mov r8, #5 <== NOT EXECUTED
3fa0: ea00007c b 4198 <rtems_fdisk_recycle_segment+0x388> <== NOT EXECUTED
#endif
ret = rtems_fdisk_seg_read_page (fd, src_sc, src_page,
fd->copy_buffer);
if (ret)
return ret;
return rtems_fdisk_seg_write_page (fd, dst_sc, dst_page,
3fa4: e1a00004 mov r0, r4
3fa8: e1a01006 mov r1, r6
3fac: e1a0200c mov r2, ip
3fb0: e5943068 ldr r3, [r4, #104] ; 0x68
3fb4: ebfffe99 bl 3a20 <rtems_fdisk_seg_write_page>
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
spage + ssc->pages_desc,
dsc,
dpage + dsc->pages_desc);
if (ret)
3fb8: e2508000 subs r8, r0, #0
3fbc: 0a00000f beq 4000 <rtems_fdisk_recycle_segment+0x1f0>
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
3fc0: e2862008 add r2, r6, #8 <== NOT EXECUTED
3fc4: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
3fc8: e1a00008 mov r0, r8 <== NOT EXECUTED
3fcc: e58d2018 str r2, [sp, #24] <== NOT EXECUTED
3fd0: e58d3014 str r3, [sp, #20] <== NOT EXECUTED
3fd4: e595b008 ldr fp, [r5, #8] <== NOT EXECUTED
3fd8: e595900c ldr r9, [r5, #12] <== NOT EXECUTED
3fdc: eb006f40 bl 1fce4 <strerror> <== NOT EXECUTED
3fe0: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED
3fe4: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED
3fe8: e58d000c str r0, [sp, #12] <== NOT EXECUTED
3fec: e58d2000 str r2, [sp] <== NOT EXECUTED
3ff0: e98d0088 stmib sp, {r3, r7} <== NOT EXECUTED
3ff4: e58d8010 str r8, [sp, #16] <== NOT EXECUTED
3ff8: e59f01b4 ldr r0, [pc, #436] ; 41b4 <rtems_fdisk_recycle_segment+0x3a4><== NOT EXECUTED
3ffc: ea000017 b 4060 <rtems_fdisk_recycle_segment+0x250> <== NOT EXECUTED
uint32_t dst_pages;
rtems_fdisk_page_desc* dpd;
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
4000: e59d2024 ldr r2, [sp, #36] ; 0x24
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
*dpd = *spd;
4004: e8990003 ldm r9, {r0, r1}
uint32_t dst_pages;
rtems_fdisk_page_desc* dpd;
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
4008: e0823187 add r3, r2, r7, lsl #3
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
*dpd = *spd;
400c: e8830003 stm r3, {r0, r1}
ret = rtems_fdisk_seg_write_page_desc (fd,
4010: e1a02007 mov r2, r7
4014: e1a00004 mov r0, r4
4018: e1a01006 mov r1, r6
401c: ebfffe6a bl 39cc <rtems_fdisk_seg_write_page_desc>
dsc,
dpage, dpd);
if (ret)
4020: e2508000 subs r8, r0, #0
4024: 0a00001e beq 40a4 <rtems_fdisk_recycle_segment+0x294>
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
4028: e2862008 add r2, r6, #8 <== NOT EXECUTED
402c: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
4030: e595b008 ldr fp, [r5, #8] <== NOT EXECUTED
4034: e58d2018 str r2, [sp, #24] <== NOT EXECUTED
4038: e58d3014 str r3, [sp, #20] <== NOT EXECUTED
403c: e595900c ldr r9, [r5, #12] <== NOT EXECUTED
4040: eb006f27 bl 1fce4 <strerror> <== NOT EXECUTED
4044: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED
4048: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED
404c: e98d0088 stmib sp, {r3, r7} <== NOT EXECUTED
4050: e58d000c str r0, [sp, #12] <== NOT EXECUTED
4054: e58d2000 str r2, [sp] <== NOT EXECUTED
4058: e58d8010 str r8, [sp, #16] <== NOT EXECUTED
405c: e59f0154 ldr r0, [pc, #340] ; 41b8 <rtems_fdisk_recycle_segment+0x3a8><== NOT EXECUTED
4060: e1a0300a mov r3, sl <== NOT EXECUTED
4064: e1a0100b mov r1, fp <== NOT EXECUTED
4068: e1a02009 mov r2, r9 <== NOT EXECUTED
406c: ebfffea2 bl 3afc <rtems_fdisk_error> <== NOT EXECUTED
"%02d-%03d-%03d: copy pd failed: %s (%d)",
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage,
strerror (ret), ret);
rtems_fdisk_queue_segment (fd, dsc);
4070: e1a00004 mov r0, r4 <== NOT EXECUTED
4074: e1a01006 mov r1, r6 <== NOT EXECUTED
4078: ebfffefa bl 3c68 <rtems_fdisk_queue_segment> <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = queue->head;
407c: e5943040 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED
4080: e5853000 str r3, [r5] <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
4084: e5943044 ldr r3, [r4, #68] ; 0x44 <== NOT EXECUTED
4088: e3530000 cmp r3, #0 <== NOT EXECUTED
queue->tail = sc;
queue->count++;
408c: e5943048 ldr r3, [r4, #72] ; 0x48 <== NOT EXECUTED
4090: e2833001 add r3, r3, #1 <== NOT EXECUTED
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = queue->head;
queue->head = sc;
4094: e5845040 str r5, [r4, #64] ; 0x40 <== NOT EXECUTED
if (queue->tail == 0)
queue->tail = sc;
4098: 05845044 streq r5, [r4, #68] ; 0x44 <== NOT EXECUTED
queue->count++;
409c: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
40a0: ea00003c b 4198 <rtems_fdisk_recycle_segment+0x388> <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
dsc->pages_active++;
40a4: e596301c ldr r3, [r6, #28]
40a8: e2833001 add r3, r3, #1
40ac: e586301c str r3, [r6, #28]
* segment will be erased. Power down could be a problem.
* We do the stats to make sure everything is as it should
* be.
*/
ssc->pages_active--;
40b0: e595301c ldr r3, [r5, #28]
40b4: e2433001 sub r3, r3, #1
40b8: e585301c str r3, [r5, #28]
ssc->pages_used++;
40bc: e5953020 ldr r3, [r5, #32]
40c0: e2833001 add r3, r3, #1
fd->blocks[spd->block].segment = dsc;
40c4: e5992004 ldr r2, [r9, #4]
* We do the stats to make sure everything is as it should
* be.
*/
ssc->pages_active--;
ssc->pages_used++;
40c8: e5853020 str r3, [r5, #32]
fd->blocks[spd->block].segment = dsc;
40cc: e5943018 ldr r3, [r4, #24]
40d0: e0831182 add r1, r3, r2, lsl #3
40d4: e7836182 str r6, [r3, r2, lsl #3]
fd->blocks[spd->block].page = dpage;
40d8: e5817004 str r7, [r1, #4]
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, dsc);
40dc: e1a00004 mov r0, r4
40e0: e1a01006 mov r1, r6
40e4: ebfffedf bl 3c68 <rtems_fdisk_queue_segment>
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
40e8: e1a00006 mov r0, r6
40ec: ebfffd7f bl 36f0 <rtems_fdisk_seg_pages_available>
if (dst_pages == 0)
40f0: e3500000 cmp r0, #0
40f4: 1a000002 bne 4104 <rtems_fdisk_recycle_segment+0x2f4>
dsc = rtems_fdisk_seg_most_available (&fd->available);
40f8: e59d0028 ldr r0, [sp, #40] ; 0x28
40fc: ebfffd83 bl 3710 <rtems_fdisk_seg_most_available>
4100: e1a06000 mov r6, r0
(*pages)--;
4104: e59d2020 ldr r2, [sp, #32]
4108: e5923000 ldr r3, [r2]
410c: e2433001 sub r3, r3, #1
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
active++;
4110: e28bb001 add fp, fp, #1
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
if (dst_pages == 0)
dsc = rtems_fdisk_seg_most_available (&fd->available);
(*pages)--;
4114: e5823000 str r3, [r2]
return EIO;
}
if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
!rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_USED))
{
4118: ea000008 b 4140 <rtems_fdisk_recycle_segment+0x330>
if (dst_pages == 0)
dsc = rtems_fdisk_seg_most_available (&fd->available);
(*pages)--;
}
else if (rtems_fdisk_page_desc_erased (spd))
411c: e1a00009 mov r0, r9
4120: ebfffd68 bl 36c8 <rtems_fdisk_page_desc_erased>
4124: e3500000 cmp r0, #0
{
--fd->erased_blocks;
4128: 15943028 ldrne r3, [r4, #40] ; 0x28
}
else
{
used++;
412c: 059d301c ldreq r3, [sp, #28]
(*pages)--;
}
else if (rtems_fdisk_page_desc_erased (spd))
{
--fd->erased_blocks;
4130: 12433001 subne r3, r3, #1
}
else
{
used++;
4134: 02833001 addeq r3, r3, #1
(*pages)--;
}
else if (rtems_fdisk_page_desc_erased (spd))
{
--fd->erased_blocks;
4138: 15843028 strne r3, [r4, #40] ; 0x28
}
else
{
used++;
413c: 058d301c streq r3, [sp, #28]
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
4140: e28aa001 add sl, sl, #1
4144: e5953014 ldr r3, [r5, #20]
4148: e15a0003 cmp sl, r3
414c: 3affff3b bcc 3e40 <rtems_fdisk_recycle_segment+0x30>
used++;
}
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, "ssc end: %d-%d: p=%ld, a=%ld, u=%ld",
4150: e59d2020 ldr r2, [sp, #32]
4154: e59d301c ldr r3, [sp, #28]
4158: e88d0804 stm sp, {r2, fp}
415c: e58d3008 str r3, [sp, #8]
4160: e2852008 add r2, r5, #8
4164: e59f1050 ldr r1, [pc, #80] ; 41bc <rtems_fdisk_recycle_segment+0x3ac>
4168: e1a00004 mov r0, r4
416c: e892000c ldm r2, {r2, r3}
4170: ebfffd96 bl 37d0 <rtems_fdisk_printf>
ssc->device, ssc->segment,
pages, active, used);
#endif
if (ssc->pages_active != 0)
4174: e595101c ldr r1, [r5, #28]
4178: e3510000 cmp r1, #0
{
rtems_fdisk_error ("compacting: ssc pages not 0: %d",
417c: 159f003c ldrne r0, [pc, #60] ; 41c0 <rtems_fdisk_recycle_segment+0x3b0>
4180: 1bfffe5d blne 3afc <rtems_fdisk_error>
ssc->pages_active);
}
ret = rtems_fdisk_erase_segment (fd, ssc);
4184: e1a00004 mov r0, r4
4188: e1a01005 mov r1, r5
return ret;
}
418c: e28dd02c add sp, sp, #44 ; 0x2c
4190: e8bd4ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, lr}
{
rtems_fdisk_error ("compacting: ssc pages not 0: %d",
ssc->pages_active);
}
ret = rtems_fdisk_erase_segment (fd, ssc);
4194: eafffe74 b 3b6c <rtems_fdisk_erase_segment>
return ret;
}
4198: e1a00008 mov r0, r8 <== NOT EXECUTED
419c: e28dd02c add sp, sp, #44 ; 0x2c <== NOT EXECUTED
41a0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
000035c0 <rtems_fdisk_segment_queue_insert_before>:
static void
rtems_fdisk_segment_queue_insert_before (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* item,
rtems_fdisk_segment_ctl* sc)
{
if (item)
35c0: e3510000 cmp r1, #0
{
rtems_fdisk_segment_ctl** prev = &queue->head;
35c4: 11a0c000 movne ip, r0
rtems_fdisk_segment_ctl* it = queue->head;
35c8: 15903000 ldrne r3, [r0]
static void
rtems_fdisk_segment_queue_insert_before (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* item,
rtems_fdisk_segment_ctl* sc)
{
if (item)
35cc: 1a00000a bne 35fc <rtems_fdisk_segment_queue_insert_before+0x3c>
35d0: ea00000b b 3604 <rtems_fdisk_segment_queue_insert_before+0x44><== NOT EXECUTED
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
{
if (item == it)
35d4: e1510003 cmp r1, r3
35d8: 1a000005 bne 35f4 <rtems_fdisk_segment_queue_insert_before+0x34>
{
sc->next = item;
*prev = sc;
queue->count++;
35dc: e5903008 ldr r3, [r0, #8]
35e0: e2833001 add r3, r3, #1
while (it)
{
if (item == it)
{
sc->next = item;
35e4: e5821000 str r1, [r2]
*prev = sc;
35e8: e58c2000 str r2, [ip]
queue->count++;
35ec: e5803008 str r3, [r0, #8]
it = it->next;
}
}
rtems_fdisk_segment_queue_push_tail (queue, sc);
}
35f0: e12fff1e bx lr
*prev = sc;
queue->count++;
return;
}
prev = &it->next;
35f4: e1a0c003 mov ip, r3
it = it->next;
35f8: e5933000 ldr r3, [r3]
if (item)
{
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
35fc: e3530000 cmp r3, #0
3600: 1afffff3 bne 35d4 <rtems_fdisk_segment_queue_insert_before+0x14>
prev = &it->next;
it = it->next;
}
}
rtems_fdisk_segment_queue_push_tail (queue, sc);
3604: e1a01002 mov r1, r2 <== NOT EXECUTED
3608: eaffffc3 b 351c <rtems_fdisk_segment_queue_push_tail> <== NOT EXECUTED
00003a80 <rtems_fdisk_warning>:
* @param ... The arguments for the format text.
* @return int The number of bytes written to the output.
*/
static int
rtems_fdisk_warning (const rtems_flashdisk* fd, const char *format, ...)
{
3a80: e92d000e push {r1, r2, r3} <== NOT EXECUTED
3a84: e92d4031 push {r0, r4, r5, lr} <== NOT EXECUTED
int ret = 0; if (fd->info_level >= 1)
3a88: e590506c ldr r5, [r0, #108] ; 0x6c <== NOT EXECUTED
3a8c: e3550000 cmp r5, #0 <== NOT EXECUTED
3a90: 0a000013 beq 3ae4 <rtems_fdisk_warning+0x64> <== NOT EXECUTED
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:warning:");
3a94: e59f4058 ldr r4, [pc, #88] ; 3af4 <rtems_fdisk_warning+0x74><== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
3a98: e28d3014 add r3, sp, #20 <== NOT EXECUTED
3a9c: e58d3000 str r3, [sp] <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
3aa0: e5943000 ldr r3, [r4] <== NOT EXECUTED
3aa4: e59f004c ldr r0, [pc, #76] ; 3af8 <rtems_fdisk_warning+0x78><== NOT EXECUTED
3aa8: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED
3aac: eb006907 bl 1ded0 <fputs> <== NOT EXECUTED
ret = vfprintf (stdout, format, args);
3ab0: e5943000 ldr r3, [r4] <== NOT EXECUTED
3ab4: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
3ab8: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
3abc: e59d2000 ldr r2, [sp] <== NOT EXECUTED
3ac0: eb008bbe bl 269c0 <vfprintf> <== NOT EXECUTED
fprintf (stdout, "\n");
3ac4: e5943000 ldr r3, [r4] <== NOT EXECUTED
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:warning:");
ret = vfprintf (stdout, format, args);
3ac8: e1a05000 mov r5, r0 <== NOT EXECUTED
fprintf (stdout, "\n");
3acc: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED
3ad0: e3a0000a mov r0, #10 <== NOT EXECUTED
3ad4: eb0068c8 bl 1ddfc <fputc> <== NOT EXECUTED
fflush (stdout);
3ad8: e5943000 ldr r3, [r4] <== NOT EXECUTED
3adc: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
3ae0: eb0067b8 bl 1d9c8 <fflush> <== NOT EXECUTED
va_end (args);
}
return ret;
}
3ae4: e1a00005 mov r0, r5 <== NOT EXECUTED
3ae8: e8bd4038 pop {r3, r4, r5, lr} <== NOT EXECUTED
3aec: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3af0: e12fff1e bx lr <== NOT EXECUTED
000036c0 <rtems_filesystem_eval_path_recursive>:
void rtems_filesystem_eval_path_recursive(
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
36c0: e92d41f0 push {r4, r5, r6, r7, r8, lr}
if (pathlen > 0) {
36c4: e2528000 subs r8, r2, #0
void rtems_filesystem_eval_path_recursive(
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
36c8: e1a04000 mov r4, r0
36cc: e1a05001 mov r5, r1
if (pathlen > 0) {
36d0: 0a00001e beq 3750 <rtems_filesystem_eval_path_recursive+0x90>
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
36d4: e5903014 ldr r3, [r0, #20]
36d8: e353001f cmp r3, #31
36dc: ca000019 bgt 3748 <rtems_filesystem_eval_path_recursive+0x88>
const char *saved_path = ctx->path;
size_t saved_pathlen = ctx->pathlen;
if (rtems_filesystem_is_delimiter(path [0])) {
36e0: e5d13000 ldrb r3, [r1]
36e4: e353002f cmp r3, #47 ; 0x2f
36e8: 1353005c cmpne r3, #92 ; 0x5c
size_t pathlen
)
{
if (pathlen > 0) {
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
const char *saved_path = ctx->path;
36ec: e5907000 ldr r7, [r0]
size_t saved_pathlen = ctx->pathlen;
36f0: e5906004 ldr r6, [r0, #4]
if (rtems_filesystem_is_delimiter(path [0])) {
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
36f4: 02801030 addeq r1, r0, #48 ; 0x30
36f8: 0bffffd6 bleq 3658 <rtems_filesystem_eval_path_restart>
}
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
36fc: e5943014 ldr r3, [r4, #20]
3700: e2833001 add r3, r3, #1
if (rtems_filesystem_is_delimiter(path [0])) {
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
}
ctx->path = path;
ctx->pathlen = pathlen;
3704: e8840120 stm r4, {r5, r8}
++ctx->recursionlevel;
3708: e5843014 str r3, [r4, #20]
while (ctx->pathlen > 0) {
370c: ea000004 b 3724 <rtems_filesystem_eval_path_recursive+0x64>
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
3710: e594302c ldr r3, [r4, #44] ; 0x2c
3714: e1a00004 mov r0, r4
3718: e593300c ldr r3, [r3, #12]
371c: e1a0e00f mov lr, pc
3720: e593f008 ldr pc, [r3, #8]
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
3724: e5943004 ldr r3, [r4, #4]
3728: e3530000 cmp r3, #0
372c: 1afffff7 bne 3710 <rtems_filesystem_eval_path_recursive+0x50>
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
3730: e5943014 ldr r3, [r4, #20]
3734: e2433001 sub r3, r3, #1
3738: e5843014 str r3, [r4, #20]
ctx->path = saved_path;
373c: e5847000 str r7, [r4]
ctx->pathlen = saved_pathlen;
3740: e5846004 str r6, [r4, #4]
rtems_filesystem_eval_path_error(ctx, ELOOP);
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
}
}
3744: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
--ctx->recursionlevel;
ctx->path = saved_path;
ctx->pathlen = saved_pathlen;
} else {
rtems_filesystem_eval_path_error(ctx, ELOOP);
3748: e3a0105c mov r1, #92 ; 0x5c
374c: ea000000 b 3754 <rtems_filesystem_eval_path_recursive+0x94>
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
3750: e3a01002 mov r1, #2 <== NOT EXECUTED
} }
3754: e8bd41f0 pop {r4, r5, r6, r7, r8, lr}
ctx->pathlen = saved_pathlen;
} else {
rtems_filesystem_eval_path_error(ctx, ELOOP);
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
3758: eafffeec b 3310 <rtems_filesystem_eval_path_error>
00002078 <rtems_filesystem_initialize>:
/*
* Default mode for created files.
*/
void rtems_filesystem_initialize( void )
{
2078: e92d4001 push {r0, lr}
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
207c: e59f3038 ldr r3, [pc, #56] ; 20bc <rtems_filesystem_initialize+0x44>
2080: e5932010 ldr r2, [r3, #16]
2084: e58d2000 str r2, [sp]
2088: e893000f ldm r3, {r0, r1, r2, r3}
208c: eb0001e4 bl 2824 <mount>
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
2090: e3500000 cmp r0, #0
rtems_fatal_error_occurred( 0xABCD0002 );
2094: 159f0024 ldrne r0, [pc, #36] ; 20c0 <rtems_filesystem_initialize+0x48>
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
2098: 1a000005 bne 20b4 <rtems_filesystem_initialize+0x3c>
*
* NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually
* created that way by the IMFS.
*/
rv = mkdir( "/dev", 0777);
209c: e59f0020 ldr r0, [pc, #32] ; 20c4 <rtems_filesystem_initialize+0x4c>
20a0: e59f1020 ldr r1, [pc, #32] ; 20c8 <rtems_filesystem_initialize+0x50>
20a4: eb00019d bl 2720 <mkdir>
if ( rv != 0 )
20a8: e3500000 cmp r0, #0
20ac: 0a000001 beq 20b8 <rtems_filesystem_initialize+0x40>
rtems_fatal_error_occurred( 0xABCD0003 );
20b0: e59f0014 ldr r0, [pc, #20] ; 20cc <rtems_filesystem_initialize+0x54><== NOT EXECUTED
20b4: eb001185 bl 66d0 <rtems_fatal_error_occurred> <== NOT EXECUTED
* 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. */ }
20b8: e8bd8008 pop {r3, pc}
000038b8 <rtems_filesystem_location_remove_from_mt_entry>:
}
void rtems_filesystem_location_remove_from_mt_entry(
rtems_filesystem_location_info_t *loc
)
{
38b8: e92d4030 push {r4, r5, lr}
38bc: e1a04000 mov r4, r0
rtems_filesystem_mt_entry_declare_lock_context(lock_context);
bool do_unmount;
rtems_filesystem_mt_entry_lock(lock_context);
38c0: ebffffa5 bl 375c <arm_interrupt_disable>
38c4: e1a05000 mov r5, r0
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
38c8: e894000c ldm r4, {r2, r3}
rtems_chain_extract_unprotected(&loc->mt_entry_node); do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
38cc: e5940014 ldr r0, [r4, #20]
next->previous = previous;
38d0: e5823004 str r3, [r2, #4]
previous->next = next;
38d4: e5832000 str r2, [r3]
38d8: ebffffa3 bl 376c <rtems_filesystem_is_ready_for_unmount>
38dc: e129f005 msr CPSR_fc, r5
rtems_filesystem_mt_entry_unlock(lock_context);
if (do_unmount) {
38e0: e3500000 cmp r0, #0
38e4: 08bd8030 popeq {r4, r5, pc}
rtems_filesystem_do_unmount(loc->mt_entry);
38e8: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED
} }
38ec: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
rtems_chain_extract_unprotected(&loc->mt_entry_node);
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
rtems_filesystem_mt_entry_unlock(lock_context);
if (do_unmount) {
rtems_filesystem_do_unmount(loc->mt_entry);
38f0: eaffffd1 b 383c <rtems_filesystem_do_unmount> <== NOT EXECUTED
00003ab8 <rtems_filesystem_location_transform_to_global>:
}
rtems_filesystem_global_location_t *rtems_filesystem_location_transform_to_global(
rtems_filesystem_location_info_t *loc
)
{
3ab8: e92d4031 push {r0, r4, r5, lr}
3abc: e1a05000 mov r5, r0
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
3ac0: e3a00024 mov r0, #36 ; 0x24
3ac4: ebfffadc bl 263c <malloc>
if (global_loc != NULL) {
3ac8: e2504000 subs r4, r0, #0
3acc: 0a000009 beq 3af8 <rtems_filesystem_location_transform_to_global+0x40>
global_loc->reference_count = 1;
3ad0: e3a03001 mov r3, #1
3ad4: e5843018 str r3, [r4, #24]
global_loc->deferred_released_next = NULL;
3ad8: e3a03000 mov r3, #0
3adc: e584301c str r3, [r4, #28]
global_loc->deferred_released_count = 0;
3ae0: e5843020 str r3, [r4, #32]
rtems_filesystem_location_copy(&global_loc->location, loc);
3ae4: e1a01005 mov r1, r5
3ae8: ebffff36 bl 37c8 <rtems_filesystem_location_copy>
rtems_filesystem_location_remove_from_mt_entry(loc);
3aec: e1a00005 mov r0, r5
3af0: ebffff70 bl 38b8 <rtems_filesystem_location_remove_from_mt_entry>
3af4: ea000009 b 3b20 <rtems_filesystem_location_transform_to_global+0x68>
} else {
rtems_filesystem_location_free(loc);
3af8: e1a00005 mov r0, r5 <== NOT EXECUTED
3afc: eb0019e8 bl a2a4 <rtems_filesystem_location_free> <== NOT EXECUTED
);
static inline rtems_filesystem_global_location_t *
rtems_filesystem_global_location_obtain_null(void)
{
rtems_filesystem_global_location_t *global_loc = NULL;
3b00: e28d0004 add r0, sp, #4 <== NOT EXECUTED
3b04: e5204004 str r4, [r0, #-4]! <== NOT EXECUTED
return rtems_filesystem_global_location_obtain( &global_loc );
3b08: e1a0000d mov r0, sp <== NOT EXECUTED
3b0c: ebffffba bl 39fc <rtems_filesystem_global_location_obtain> <== NOT EXECUTED
3b10: e1a04000 mov r4, r0 <== NOT EXECUTED
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
3b14: eb002706 bl d734 <__errno> <== NOT EXECUTED
3b18: e3a0300c mov r3, #12 <== NOT EXECUTED
3b1c: e5803000 str r3, [r0] <== NOT EXECUTED
}
return global_loc;
}
3b20: e1a00004 mov r0, r4
3b24: e8bd8038 pop {r3, r4, r5, pc}
00002b84 <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
2b84: e92d4070 push {r4, r5, r6, lr}
2b88: e1a06000 mov r6, r0
* pointer to the buffer that will hold the value of the key itself. * We have to to this, because the others functions on this interface * deal with the value of the key, as used with the POSIX API. */ /* Do not pull your hair, trust me this works. :-) */ __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
2b8c: e3a00008 mov r0, #8
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
2b90: e1a05001 mov r5, r1
* pointer to the buffer that will hold the value of the key itself. * We have to to this, because the others functions on this interface * deal with the value of the key, as used with the POSIX API. */ /* Do not pull your hair, trust me this works. :-) */ __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
2b94: eb0000e7 bl 2f38 <malloc>
2b98: e1a04000 mov r4, r0
*key = new_key;
2b9c: e5860000 str r0, [r6]
"gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
2ba0: e1a01004 mov r1, r4
* deal with the value of the key, as used with the POSIX API. */ /* Do not pull your hair, trust me this works. :-) */ __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) ); *key = new_key; new_key->val = NULL;
2ba4: e3a00000 mov r0, #0
"gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
2ba8: e1a02005 mov r2, r5
*/ /* Do not pull your hair, trust me this works. :-) */ __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) ); *key = new_key; new_key->val = NULL; new_key->dtor = dtor;
2bac: e8840021 stm r4, {r0, r5}
"gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
2bb0: eb0010be bl 6eb0 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL )
2bb4: e3500000 cmp r0, #0
2bb8: 08bd8070 popeq {r4, r5, r6, pc}
return 0;
free( new_key );
2bbc: e1a00004 mov r0, r4 <== NOT EXECUTED
2bc0: ebffff8c bl 29f8 <free> <== NOT EXECUTED
return -1;
2bc4: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
2bc8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
000039b8 <rtems_ide_part_table_free>:
* RETURNS:
* N/A
*/
void
rtems_ide_part_table_free(rtems_disk_desc_t *disk_desc)
{
39b8: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
39bc: e1a06000 mov r6, r0 <== NOT EXECUTED
39c0: e1a05000 mov r5, r0 <== NOT EXECUTED
39c4: e3a04004 mov r4, #4 <== NOT EXECUTED
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
partition_free(disk_desc->partitions[part_num]);
39c8: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
39cc: ebfffed9 bl 3538 <partition_free> <== NOT EXECUTED
static void
partition_table_free(rtems_disk_desc_t *disk_desc)
{
int part_num;
for (part_num = 0;
39d0: e2544001 subs r4, r4, #1 <== NOT EXECUTED
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
partition_free(disk_desc->partitions[part_num]);
39d4: e2855004 add r5, r5, #4 <== NOT EXECUTED
static void
partition_table_free(rtems_disk_desc_t *disk_desc)
{
int part_num;
for (part_num = 0;
39d8: 1afffffa bne 39c8 <rtems_ide_part_table_free+0x10> <== NOT EXECUTED
part_num++)
{
partition_free(disk_desc->partitions[part_num]);
}
free(disk_desc);
39dc: e1a00006 mov r0, r6 <== NOT EXECUTED
*/
void
rtems_ide_part_table_free(rtems_disk_desc_t *disk_desc)
{
partition_table_free( disk_desc );
}
39e0: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED
part_num++)
{
partition_free(disk_desc->partitions[part_num]);
}
free(disk_desc);
39e4: ea000292 b 4434 <free> <== NOT EXECUTED
000039e8 <rtems_ide_part_table_get>:
* RTEMS_INTERNAL_ERROR otherwise
*/
rtems_status_code
rtems_ide_part_table_get(const char *dev_name, rtems_disk_desc_t *disk_desc)
{
return partition_table_get( dev_name, disk_desc );
39e8: eaffff86 b 3808 <partition_table_get> <== NOT EXECUTED
000036b0 <rtems_libio_share_private_env>:
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
36b0: e92d4031 push {r0, r4, r5, lr}
36b4: e1a04000 mov r4, r0
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_id self_task_id = rtems_task_self();
36b8: eb00057a bl 4ca8 <rtems_task_self>
if (task_id != RTEMS_SELF && self_task_id != task_id) {
36bc: e1500004 cmp r0, r4
36c0: 13540000 cmpne r4, #0
36c4: 03a05000 moveq r5, #0
36c8: 13a05001 movne r5, #1
36cc: 0a00001f beq 3750 <rtems_libio_share_private_env+0xa0>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
36d0: e59f3080 ldr r3, [pc, #128] ; 3758 <rtems_libio_share_private_env+0xa8>
36d4: e5932000 ldr r2, [r3]
++level;
36d8: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
36dc: e5832000 str r2, [r3]
/*
* We have to disable the thread dispatching to prevent deletion of the
* environment in the meantime.
*/
_Thread_Disable_dispatch();
sc = rtems_task_variable_get(
36e0: e59f1074 ldr r1, [pc, #116] ; 375c <rtems_libio_share_private_env+0xac>
36e4: e1a0200d mov r2, sp
36e8: e1a00004 mov r0, r4
36ec: eb0005d2 bl 4e3c <rtems_task_variable_get>
task_id,
(void *) &rtems_current_user_env,
(void *) &env
);
if (sc == RTEMS_SUCCESSFUL) {
36f0: e2505000 subs r5, r0, #0
++env->reference_count;
36f4: 059d3000 ldreq r3, [sp]
36f8: 05932028 ldreq r2, [r3, #40] ; 0x28
36fc: 02822001 addeq r2, r2, #1
3700: 05832028 streq r2, [r3, #40] ; 0x28
} else {
sc = RTEMS_UNSATISFIED;
3704: 13a0500d movne r5, #13
}
_Thread_Enable_dispatch();
3708: eb000d2f bl 6bcc <_Thread_Enable_dispatch>
if (sc == RTEMS_SUCCESSFUL) {
370c: e3550000 cmp r5, #0
3710: 1a00000e bne 3750 <rtems_libio_share_private_env+0xa0>
sc = rtems_task_variable_add(
3714: e59f4040 ldr r4, [pc, #64] ; 375c <rtems_libio_share_private_env+0xac>
3718: e1a00005 mov r0, r5
371c: e1a01004 mov r1, r4
3720: e59f2038 ldr r2, [pc, #56] ; 3760 <rtems_libio_share_private_env+0xb0>
3724: eb00057c bl 4d1c <rtems_task_variable_add>
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
3728: e2505000 subs r5, r0, #0
372c: 1a000004 bne 3744 <rtems_libio_share_private_env+0x94>
free_user_env_protected(rtems_current_user_env);
3730: e5940000 ldr r0, [r4]
3734: ebffff94 bl 358c <free_user_env_protected>
rtems_current_user_env = env;
3738: e59d3000 ldr r3, [sp]
373c: e5843000 str r3, [r4]
3740: ea000002 b 3750 <rtems_libio_share_private_env+0xa0>
} else {
free_user_env_protected(env);
3744: e59d0000 ldr r0, [sp] <== NOT EXECUTED
3748: ebffff8f bl 358c <free_user_env_protected> <== NOT EXECUTED
sc = RTEMS_TOO_MANY;
374c: e3a05005 mov r5, #5 <== NOT EXECUTED
}
}
}
return sc;
}
3750: e1a00005 mov r0, r5
3754: e8bd8038 pop {r3, r4, r5, pc}
00003764 <rtems_libio_use_global_env>:
void rtems_libio_use_global_env(void)
{
3764: e92d4030 push {r4, r5, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_user_env_t *env = rtems_current_user_env;
bool uses_private_env = env != &rtems_global_user_env;
if (uses_private_env) {
3768: e59f402c ldr r4, [pc, #44] ; 379c <rtems_libio_use_global_env+0x38>
376c: e59f502c ldr r5, [pc, #44] ; 37a0 <rtems_libio_use_global_env+0x3c>
3770: e5943000 ldr r3, [r4]
3774: e1530005 cmp r3, r5
3778: 08bd8030 popeq {r4, r5, pc}
sc = rtems_task_variable_delete(
377c: e3a00000 mov r0, #0
3780: e1a01004 mov r1, r4
3784: eb00058e bl 4dc4 <rtems_task_variable_delete>
RTEMS_SELF,
(void **) &rtems_current_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
3788: e3500000 cmp r0, #0
rtems_fatal_error_occurred(0xdeadbeef);
}
rtems_current_user_env = &rtems_global_user_env;
378c: 05845000 streq r5, [r4]
if (uses_private_env) {
sc = rtems_task_variable_delete(
RTEMS_SELF,
(void **) &rtems_current_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
3790: 08bd8030 popeq {r4, r5, pc}
rtems_fatal_error_occurred(0xdeadbeef);
3794: e59f0008 ldr r0, [pc, #8] ; 37a4 <rtems_libio_use_global_env+0x40><== NOT EXECUTED
3798: eb000628 bl 5040 <rtems_fatal_error_occurred> <== NOT EXECUTED
000070b0 <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
70b0: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
void *ptr = NULL; rtems_chain_control *free_chain = &control->free_chunk_chain; rtems_rbtree_control *chunk_tree = &control->chunk_tree; uintptr_t alignment = control->alignment;
70b4: e5906030 ldr r6, [r0, #48] ; 0x30
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
70b8: e1a05001 mov r5, r1
70bc: e1a04000 mov r4, r0
#include <stdlib.h>
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
70c0: e1a00001 mov r0, r1
70c4: e1a01006 mov r1, r6
70c8: eb00424f bl 17a0c <__umodsi3>
if (excess > 0) {
70cc: e3500000 cmp r0, #0
value += alignment - excess;
70d0: 10856006 addne r6, r5, r6
70d4: 10606006 rsbne r6, r0, r6
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
if (excess > 0) {
70d8: 01a06005 moveq r6, r5
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
70dc: e1550006 cmp r5, r6
70e0: 83a00000 movhi r0, #0
70e4: 93a00001 movls r0, #1
70e8: e3550000 cmp r5, #0
70ec: 03a00000 moveq r0, #0
70f0: e3500000 cmp r0, #0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
70f4: 11a02004 movne r2, r4
70f8: 14923004 ldrne r3, [r2], #4
size_t size
)
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
rtems_rbheap_chunk *big_enough = NULL;
70fc: 13a07000 movne r7, #0
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
7100: 1a000005 bne 711c <rtems_rbheap_allocate+0x6c>
7104: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
rtems_rbheap_chunk *big_enough = NULL;
while (current != tail && big_enough == NULL) {
rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current;
if (free_chunk->size >= size) {
7108: e593701c ldr r7, [r3, #28]
710c: e1570006 cmp r7, r6
7110: 21a07003 movcs r7, r3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
7114: e5933000 ldr r3, [r3]
7118: 33a07000 movcc r7, #0
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
rtems_rbheap_chunk *big_enough = NULL;
while (current != tail && big_enough == NULL) {
711c: e2778001 rsbs r8, r7, #1
7120: 33a08000 movcc r8, #0
7124: e1530002 cmp r3, r2
7128: 03a08000 moveq r8, #0
712c: e3580000 cmp r8, #0
7130: 1afffff4 bne 7108 <rtems_rbheap_allocate+0x58>
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size);
if (free_chunk != NULL) {
7134: e3570000 cmp r7, #0
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
7138: 01a00007 moveq r0, r7
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size);
if (free_chunk != NULL) {
713c: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc}
uintptr_t free_size = free_chunk->size;
7140: e597901c ldr r9, [r7, #28]
if (free_size > aligned_size) {
7144: e1590006 cmp r9, r6
7148: 9a00001f bls 71cc <rtems_rbheap_allocate+0x11c>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
714c: e1a0a004 mov sl, r4
7150: e5ba500c ldr r5, [sl, #12]!
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
7154: e2843010 add r3, r4, #16
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
7158: e1550003 cmp r5, r3
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
715c: 15953000 ldrne r3, [r5]
head->next = new_first;
7160: 1584300c strne r3, [r4, #12]
new_first->previous = head;
7164: 1583a004 strne sl, [r3, #4]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
7168: 1a000009 bne 7194 <rtems_rbheap_allocate+0xe4>
{
rtems_chain_control *chain = &control->spare_descriptor_chain;
rtems_chain_node *chunk = rtems_chain_get_unprotected(chain);
if (chunk == NULL) {
(*control->extend_descriptors)(control);
716c: e1a00004 mov r0, r4 <== NOT EXECUTED
7170: e1a0e00f mov lr, pc <== NOT EXECUTED
7174: e594f034 ldr pc, [r4, #52] ; 0x34 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
7178: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
717c: e1530005 cmp r3, r5 <== NOT EXECUTED
7180: 0a000018 beq 71e8 <rtems_rbheap_allocate+0x138> <== NOT EXECUTED
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
7184: e5932000 ldr r2, [r3] <== NOT EXECUTED
head->next = new_first;
7188: e584200c str r2, [r4, #12] <== NOT EXECUTED
new_first->previous = head;
718c: e582a004 str sl, [r2, #4] <== NOT EXECUTED
7190: e1a05003 mov r5, r3 <== NOT EXECUTED
if (new_chunk != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
7194: e5973018 ldr r3, [r7, #24]
if (free_size > aligned_size) {
rtems_rbheap_chunk *new_chunk = get_chunk(control);
if (new_chunk != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
7198: e0669009 rsb r9, r6, r9
free_chunk->size = new_free_size;
719c: e587901c str r9, [r7, #28]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
71a0: e1a01005 mov r1, r5
new_chunk->begin = free_chunk->begin + new_free_size;
71a4: e0899003 add r9, r9, r3
71a8: e3a03000 mov r3, #0
71ac: e5859018 str r9, [r5, #24]
new_chunk->size = aligned_size;
71b0: e585601c str r6, [r5, #28]
71b4: e5853004 str r3, [r5, #4]
71b8: e4813008 str r3, [r1], #8
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_chunk *chunk
)
{
_RBTree_Insert_unprotected(tree, &chunk->tree_node);
71bc: e2840018 add r0, r4, #24
71c0: eb000650 bl 8b08 <_RBTree_Insert_unprotected>
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
new_chunk->size = aligned_size;
rtems_chain_set_off_chain(&new_chunk->chain_node);
insert_into_tree(chunk_tree, new_chunk);
ptr = (void *) new_chunk->begin;
71c4: e5950018 ldr r0, [r5, #24]
71c8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
71cc: e897000c ldm r7, {r2, r3}
}
} else {
rtems_chain_extract_unprotected(&free_chunk->chain_node);
rtems_chain_set_off_chain(&free_chunk->chain_node);
ptr = (void *) free_chunk->begin;
71d0: e5970018 ldr r0, [r7, #24]
next->previous = previous;
71d4: e5823004 str r3, [r2, #4]
previous->next = next;
71d8: e5832000 str r2, [r3]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
71dc: e5878004 str r8, [r7, #4]
71e0: e5878000 str r8, [r7]
71e4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
71e8: e1a00008 mov r0, r8 <== NOT EXECUTED
}
}
}
return ptr;
}
71ec: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
00007374 <rtems_rbheap_extend_descriptors_with_malloc>:
void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control)
{
7374: e92d4010 push {r4, lr} <== NOT EXECUTED
7378: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
737c: e3a00020 mov r0, #32 <== NOT EXECUTED
7380: ebffee8e bl 2dc0 <malloc> <== NOT EXECUTED
if (chunk != NULL) {
7384: e3500000 cmp r0, #0 <== NOT EXECUTED
7388: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert_unprotected(_Chain_Head(the_chain), the_node);
738c: e284300c add r3, r4, #12 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
7390: e5803004 str r3, [r0, #4] <== NOT EXECUTED
before_node = after_node->next;
7394: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
after_node->next = the_node;
7398: e584000c str r0, [r4, #12] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
739c: e5830004 str r0, [r3, #4] <== NOT EXECUTED
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
73a0: e5803000 str r3, [r0] <== NOT EXECUTED
73a4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
000071f0 <rtems_rbheap_free>:
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
71f0: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
71f4: e2516000 subs r6, r1, #0
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
71f8: e24dd020 sub sp, sp, #32
71fc: e1a05000 mov r5, r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
7200: 0a000057 beq 7364 <rtems_rbheap_free+0x174>
#define NULL_PAGE rtems_rbheap_chunk_of_node(NULL)
static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key)
{
rtems_rbheap_chunk chunk = { .begin = key };
7204: e1a0000d mov r0, sp
7208: e3a01000 mov r1, #0
720c: e3a02020 mov r2, #32
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
7210: e3a04000 mov r4, #0
7214: eb002035 bl f2f0 <memset>
return rtems_rbheap_chunk_of_node(
7218: e08d3004 add r3, sp, r4
#define NULL_PAGE rtems_rbheap_chunk_of_node(NULL)
static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key)
{
rtems_rbheap_chunk chunk = { .begin = key };
721c: e58d6018 str r6, [sp, #24]
return rtems_rbheap_chunk_of_node(
7220: e2837008 add r7, r3, #8
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
7224: e595601c ldr r6, [r5, #28]
7228: ea00000d b 7264 <rtems_rbheap_free+0x74>
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
722c: e1a00007 mov r0, r7
7230: e1a01006 mov r1, r6
7234: e1a0e00f mov lr, pc
7238: e595f028 ldr pc, [r5, #40] ; 0x28
if ( _RBTree_Is_equal( compare_result ) ) {
723c: e3500000 cmp r0, #0
7240: 1a000003 bne 7254 <rtems_rbheap_free+0x64>
found = iter_node;
if ( the_rbtree->is_unique )
7244: e5d5302c ldrb r3, [r5, #44] ; 0x2c
7248: e3530000 cmp r3, #0
724c: 1a000007 bne 7270 <rtems_rbheap_free+0x80>
7250: e1a04006 mov r4, r6 <== NOT EXECUTED
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
7254: e3500000 cmp r0, #0
7258: c3a00008 movgt r0, #8
725c: d3a00004 movle r0, #4
7260: e7906006 ldr r6, [r0, r6]
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
7264: e3560000 cmp r6, #0
7268: 1affffef bne 722c <rtems_rbheap_free+0x3c>
726c: e1a06004 mov r6, r4
7270: e2464008 sub r4, r6, #8
if (ptr != NULL) {
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr);
if (chunk != NULL_PAGE) {
7274: e3740008 cmn r4, #8
check_and_merge(free_chain, chunk_tree, chunk, pred);
} else {
sc = RTEMS_INCORRECT_STATE;
}
} else {
sc = RTEMS_INVALID_ID;
7278: 03a06004 moveq r6, #4
if (ptr != NULL) {
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr);
if (chunk != NULL_PAGE) {
727c: 0a000038 beq 7364 <rtems_rbheap_free+0x174>
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
7280: e5163008 ldr r3, [r6, #-8]
7284: e3530000 cmp r3, #0
7288: 13a0a000 movne sl, #0
728c: 1a000002 bne 729c <rtems_rbheap_free+0xac>
add_to_chain(free_chain, b);
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
7290: e594a004 ldr sl, [r4, #4]
7294: e27aa001 rsbs sl, sl, #1
7298: 33a0a000 movcc sl, #0
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr);
if (chunk != NULL_PAGE) {
if (!rtems_rbheap_is_chunk_free(chunk)) {
729c: e23aa001 eors sl, sl, #1
check_and_merge(free_chain, chunk_tree, chunk, succ);
add_to_chain(free_chain, chunk);
check_and_merge(free_chain, chunk_tree, chunk, pred);
} else {
sc = RTEMS_INCORRECT_STATE;
72a0: 13a0600e movne r6, #14
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr);
if (chunk != NULL_PAGE) {
if (!rtems_rbheap_is_chunk_free(chunk)) {
72a4: 1a00002e bne 7364 <rtems_rbheap_free+0x174>
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
72a8: e2849008 add r9, r4, #8
72ac: e1a0100a mov r1, sl
72b0: e1a00009 mov r0, r9
72b4: eb000698 bl 8d1c <_RBTree_Next_unprotected>
72b8: e3a01001 mov r1, #1
72bc: e1a06000 mov r6, r0
72c0: e2408008 sub r8, r0, #8
72c4: e1a00009 mov r0, r9
72c8: eb000693 bl 8d1c <_RBTree_Next_unprotected>
72cc: e2403008 sub r3, r0, #8
rtems_rbtree_control *chunk_tree,
rtems_rbheap_chunk *a,
rtems_rbheap_chunk *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
72d0: e3730008 cmn r3, #8
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
72d4: e2857018 add r7, r5, #24
rtems_rbtree_control *chunk_tree,
rtems_rbheap_chunk *a,
rtems_rbheap_chunk *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
72d8: 0a00000a beq 7308 <rtems_rbheap_free+0x118>
72dc: e5102008 ldr r2, [r0, #-8]
72e0: e3520000 cmp r2, #0
72e4: 1a000002 bne 72f4 <rtems_rbheap_free+0x104>
add_to_chain(free_chain, b);
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
72e8: e510a004 ldr sl, [r0, #-4]
72ec: e27aa001 rsbs sl, sl, #1
72f0: 33a0a000 movcc sl, #0
rtems_rbtree_control *chunk_tree,
rtems_rbheap_chunk *a,
rtems_rbheap_chunk *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
72f4: e35a0000 cmp sl, #0
72f8: 01a00005 moveq r0, r5
72fc: 01a01007 moveq r1, r7
7300: 01a02004 moveq r2, r4
7304: 0bffff08 bleq 6f2c <check_and_merge.part.1>
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
7308: e5953000 ldr r3, [r5]
730c: e3780008 cmn r8, #8
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
7310: e5845004 str r5, [r4, #4]
before_node = after_node->next; after_node->next = the_node;
7314: e5854000 str r4, [r5]
the_node->next = before_node; before_node->previous = the_node;
7318: e5834004 str r4, [r3, #4]
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
731c: e5843000 str r3, [r4]
7320: 0a00000e beq 7360 <rtems_rbheap_free+0x170>
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
7324: e5163008 ldr r3, [r6, #-8]
7328: e3530000 cmp r3, #0
732c: 13a06000 movne r6, #0
7330: 1a000002 bne 7340 <rtems_rbheap_free+0x150>
add_to_chain(free_chain, b);
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
7334: e5166004 ldr r6, [r6, #-4]
7338: e2766001 rsbs r6, r6, #1
733c: 33a06000 movcc r6, #0
rtems_rbtree_control *chunk_tree,
rtems_rbheap_chunk *a,
rtems_rbheap_chunk *b
)
{
if (b != NULL_PAGE && rtems_rbheap_is_chunk_free(b)) {
7340: e21660ff ands r6, r6, #255 ; 0xff
7344: 1a000005 bne 7360 <rtems_rbheap_free+0x170>
7348: e1a00005 mov r0, r5
734c: e1a01007 mov r1, r7
7350: e1a02004 mov r2, r4
7354: e1a03008 mov r3, r8
7358: ebfffef3 bl 6f2c <check_and_merge.part.1>
735c: ea000000 b 7364 <rtems_rbheap_free+0x174>
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
7360: e3a06000 mov r6, #0
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
7364: e1a00006 mov r0, r6
7368: e28dd020 add sp, sp, #32
736c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
00017288 <rtems_rfs_bitmap_map_clear_all>:
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
17288: e92d4011 push {r0, r4, lr}
rtems_rfs_bitmap_bit last_search_bit;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
1728c: e1a0100d mov r1, sp
return 0;
}
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
17290: e1a04000 mov r4, r0
rtems_rfs_bitmap_bit last_search_bit;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
17294: ebfffed4 bl 16dec <rtems_rfs_bitmap_load_map>
if (rc > 0)
17298: e3500000 cmp r0, #0
1729c: ca00001f bgt 17320 <rtems_rfs_bitmap_map_clear_all+0x98>
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
172a0: e594100c ldr r1, [r4, #12] 172a4: e2411001 sub r1, r1, #1 172a8: e1a012a1 lsr r1, r1, #5 172ac: e2813001 add r3, r1, #1
control->free = elements;
172b0: e5843010 str r3, [r4, #16] 172b4: e59d0000 ldr r0, [sp]
for (e = 0; e < elements; e++)
172b8: e3a02000 mov r2, #0
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
172bc: e3e0c000 mvn ip, #0
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
172c0: ea000001 b 172cc <rtems_rfs_bitmap_map_clear_all+0x44>
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
172c4: e480c004 str ip, [r0], #4
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
172c8: e2822001 add r2, r2, #1 172cc: e1520003 cmp r2, r3
172d0: 3afffffb bcc 172c4 <rtems_rfs_bitmap_map_clear_all+0x3c>
* works.
*/
last_search_bit = rtems_rfs_bitmap_map_offset (elements);
if (last_search_bit == 0)
last_search_bit = rtems_rfs_bitmap_element_bits ();
172d4: e213201f ands r2, r3, #31 172d8: 03a02020 moveq r2, #32
elements = rtems_rfs_bitmap_elements (elements);
172dc: e1a0c2a1 lsr ip, r1, #5
for (e = 0; e < (elements - 1); e++)
172e0: e3a03000 mov r3, #0 172e4: e3e00000 mvn r0, #0 172e8: ea000001 b 172f4 <rtems_rfs_bitmap_map_clear_all+0x6c>
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
172ec: 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++)
172f0: e2833001 add r3, r3, #1 <== NOT EXECUTED
172f4: e153000c cmp r3, ip 172f8: e5941014 ldr r1, [r4, #20]
172fc: 1afffffa bne 172ec <rtems_rfs_bitmap_map_clear_all+0x64>
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
17300: e3e00000 mvn r0, #0 17304: e2622020 rsb r2, r2, #32 17308: e1a02230 lsr r2, r0, r2
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] =
1730c: e7812103 str r2, [r1, r3, lsl #2]
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);
17310: e5943000 ldr r3, [r4] 17314: e3a02001 mov r2, #1 17318: e5c32000 strb r2, [r3]
return 0;
1731c: e3a00000 mov r0, #0
}
17320: e8bd8018 pop {r3, r4, pc}
000170a8 <rtems_rfs_bitmap_map_set>:
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
170a8: e92d4071 push {r0, r4, r5, r6, lr}
170ac: e1a05001 mov r5, r1
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);
170b0: e1a0100d mov r1, sp
}
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
170b4: e1a04000 mov r4, r0
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);
170b8: ebffff4b bl 16dec <rtems_rfs_bitmap_load_map>
if (rc > 0)
170bc: e3500000 cmp r0, #0
170c0: ca000018 bgt 17128 <rtems_rfs_bitmap_map_set+0x80>
return rc;
if (bit >= control->size)
170c4: e594300c ldr r3, [r4, #12] 170c8: e1550003 cmp r5, r3
return EINVAL;
170cc: 23a00016 movcs r0, #22
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
170d0: 2a000014 bcs 17128 <rtems_rfs_bitmap_map_set+0x80>
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);
170d4: e59dc000 ldr ip, [sp]
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
170d8: e1a022c5 asr r2, r5, #5
*/
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);
170dc: e79c0102 ldr r0, [ip, r2, lsl #2]
return rc;
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);
170e0: e205601f and r6, r5, #31
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
170e4: e3a03001 mov r3, #1
*/
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);
170e8: e1c00613 bic r0, r0, r3, lsl r6
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))
170ec: e3500000 cmp r0, #0
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
170f0: e5941014 ldr r1, [r4, #20]
index = rtems_rfs_bitmap_map_index (bit); offset = rtems_rfs_bitmap_map_offset (bit); map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
170f4: e78c0102 str r0, [ip, r2, lsl #2]
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
control->free--;
rtems_rfs_buffer_mark_dirty (control->buffer);
}
return 0;
170f8: 13a00000 movne r0, #0
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))
170fc: 1a000009 bne 17128 <rtems_rfs_bitmap_map_set+0x80>
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
17100: e1a05545 asr r5, r5, #10 <== 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);
17104: e791c105 ldr ip, [r1, r5, lsl #2] <== NOT EXECUTED
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
17108: e202201f and r2, r2, #31 <== 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);
1710c: e1cc2213 bic r2, ip, r3, lsl r2 <== NOT EXECUTED
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
{
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);
17110: e7812105 str r2, [r1, r5, lsl #2] <== NOT EXECUTED
control->free--;
17114: e5942010 ldr r2, [r4, #16] <== NOT EXECUTED 17118: e2422001 sub r2, r2, #1 <== NOT EXECUTED 1711c: e5842010 str r2, [r4, #16] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
17120: e5942000 ldr r2, [r4] <== NOT EXECUTED 17124: e5c23000 strb r3, [r2] <== NOT EXECUTED
} return 0; }
17128: e8bd8078 pop {r3, r4, r5, r6, pc}
00017078 <rtems_rfs_bitmap_mask>:
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
return mask;
}
17078: e3e03000 mvn r3, #0 <== NOT EXECUTED
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK;
mask >>= (rtems_rfs_bitmap_element_bits () - size);
1707c: e2600020 rsb r0, r0, #32 <== NOT EXECUTED
return mask; }
17080: e1a00033 lsr r0, r3, r0 <== NOT EXECUTED 17084: e12fff1e bx lr <== NOT EXECUTED
000176f8 <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)
{
176f8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
176fc: e1a05003 mov r5, r3
/*
* 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);
17700: e3a03001 mov r3, #1
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)
{
17704: e1a06000 mov r6, r0 17708: e1a07001 mov r7, r1 1770c: e1a08002 mov r8, r2 17710: e59d4018 ldr r4, [sp, #24]
/*
* 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);
17714: eb000414 bl 1876c <rtems_rfs_buffer_handle_request>
if (rc > 0)
17718: e3500000 cmp r0, #0
1771c: c8bd81f0 popgt {r4, r5, r6, r7, r8, pc}
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
17720: e5973008 ldr r3, [r7, #8] 17724: e593101c ldr r1, [r3, #28] 17728: e0812105 add r2, r1, r5, lsl #2 1772c: e5d23003 ldrb r3, [r2, #3] 17730: e7d11105 ldrb r1, [r1, r5, lsl #2] 17734: e1833c01 orr r3, r3, r1, lsl #24 17738: e5d21001 ldrb r1, [r2, #1] 1773c: e5d22002 ldrb r2, [r2, #2] 17740: e1833801 orr r3, r3, r1, lsl #16 17744: e1833402 orr r3, r3, r2, lsl #8
if ((*result + 1) == 0)
*result = 0;
17748: e3730001 cmn r3, #1 1774c: 03a03000 moveq r3, #0
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
if (rc > 0)
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
if ((*result + 1) == 0)
17750: e5843000 str r3, [r4]
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
17754: e5962004 ldr r2, [r6, #4] 17758: e1530002 cmp r3, r2
1775c: 3a00000b bcc 17790 <rtems_rfs_block_find_indirect+0x98>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
17760: e3a00a01 mov r0, #4096 ; 0x1000 <== NOT EXECUTED 17764: e3a01000 mov r1, #0 <== NOT EXECUTED 17768: ebffe6bf bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1776c: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: block-find: invalid block in table:"
17770: 159f0020 ldrne r0, [pc, #32] ; 17798 <rtems_rfs_block_find_indirect+0xa0><== NOT EXECUTED 17774: 15941000 ldrne r1, [r4] <== NOT EXECUTED 17778: 11a02008 movne r2, r8 <== NOT EXECUTED 1777c: 11a03005 movne r3, r5 <== NOT EXECUTED 17780: 1b001ca9 blne 1ea2c <printf> <== NOT EXECUTED
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
17784: e3a00000 mov r0, #0 <== NOT EXECUTED
17788: e5840000 str r0, [r4] <== NOT EXECUTED
1778c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
*result = rtems_rfs_block_get_number (buffer, offset);
if ((*result + 1) == 0)
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
17790: e3a00000 mov r0, #0
*result = 0;
rc = EIO;
}
return 0;
}
17794: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
000177fc <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)
{
177fc: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
17800: e1a06001 mov r6, r1 <== NOT EXECUTED
17804: e1a07002 mov r7, r2 <== NOT EXECUTED
17808: e1a04003 mov r4, r3 <== NOT EXECUTED
if (pos == 0)
1780c: e1963007 orrs r3, r6, r7 <== 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;
17810: 03a03000 moveq r3, #0 <== NOT EXECUTED 17814: 05843000 streq r3, [r4] <== NOT EXECUTED
size->offset = 0;
17818: 05843004 streq r3, [r4, #4] <== NOT EXECUTED
1781c: 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;
17820: e5905008 ldr r5, [r0, #8] <== NOT EXECUTED 17824: e3a03000 mov r3, #0 <== NOT EXECUTED 17828: e1a00001 mov r0, r1 <== NOT EXECUTED 1782c: e1a01002 mov r1, r2 <== NOT EXECUTED 17830: e1a02005 mov r2, r5 <== NOT EXECUTED 17834: eb005324 bl 2c4cc <__udivdi3> <== NOT EXECUTED 17838: e2800001 add r0, r0, #1 <== NOT EXECUTED 1783c: e5840000 str r0, [r4] <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
17840: e1a01007 mov r1, r7 <== NOT EXECUTED
17844: e1a00006 mov r0, r6 <== NOT EXECUTED
17848: e1a02005 mov r2, r5 <== NOT EXECUTED
1784c: e3a03000 mov r3, #0 <== NOT EXECUTED
17850: eb005441 bl 2c95c <__umoddi3> <== NOT EXECUTED
17854: e5840004 str r0, [r4, #4] <== NOT EXECUTED
17858: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00017bc8 <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)
{
17bc8: e92d4ff7 push {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}
17bcc: e1a05003 mov r5, r3
int rc = 0;
*block = 0;
17bd0: e3a03000 mov r3, #0 17bd4: e5853000 str r3, [r5]
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
17bd8: e5928000 ldr r8, [r2] 17bdc: e1580003 cmp r8, r3
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)
{
17be0: e1a06000 mov r6, r0 17be4: e1a04001 mov r4, r1 17be8: e1a07002 mov r7, r2 17bec: e591a008 ldr sl, [r1, #8]
*block = 0;
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
17bf0: 0a000001 beq 17bfc <rtems_rfs_block_map_find+0x34>
17bf4: e15a0003 cmp sl, r3
17bf8: 0a000047 beq 17d1c <rtems_rfs_block_map_find+0x154>
17bfc: e158000a cmp r8, sl
17c00: 2a000045 bcs 17d1c <rtems_rfs_block_map_find+0x154>
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))
17c04: e5943010 ldr r3, [r4, #16] 17c08: e1580003 cmp r8, r3
17c0c: 1a000002 bne 17c1c <rtems_rfs_block_map_find+0x54>
17c10: e5943018 ldr r3, [r4, #24] 17c14: e3530000 cmp r3, #0
17c18: 1a000003 bne 17c2c <rtems_rfs_block_map_find+0x64>
/*
* 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)
17c1c: e35a0005 cmp sl, #5
17c20: 8a000003 bhi 17c34 <rtems_rfs_block_map_find+0x6c>
{
*block = map->blocks[bpos->bno];
17c24: e2888009 add r8, r8, #9 17c28: e7943108 ldr r3, [r4, r8, lsl #2] 17c2c: e5853000 str r3, [r5] 17c30: ea00002f b 17cf4 <rtems_rfs_block_map_find+0x12c>
* 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;
17c34: e5969034 ldr r9, [r6, #52] ; 0x34 17c38: e1a00008 mov r0, r8 17c3c: e1a01009 mov r1, r9 17c40: eb004cec bl 2aff8 <__umodsi3>
singly = bpos->bno / fs->blocks_per_block;
17c44: e1a01009 mov r1, r9
* 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;
17c48: e58d0004 str r0, [sp, #4]
singly = bpos->bno / fs->blocks_per_block;
17c4c: e1a00008 mov r0, r8 17c50: ebffa73a bl 1940 <__aeabi_uidiv>
if (map->size.count <= fs->block_map_singly_blocks)
17c54: e5963038 ldr r3, [r6, #56] ; 0x38 17c58: e15a0003 cmp sl, r3
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
singly = bpos->bno / fs->blocks_per_block;
17c5c: e1a0b000 mov fp, r0 17c60: e58d0008 str r0, [sp, #8]
if (map->size.count <= fs->block_map_singly_blocks)
17c64: 8a000005 bhi 17c80 <rtems_rfs_block_map_find+0xb8>
{
/*
* This is a single indirect table of blocks anchored off a slot in the
* inode.
*/
rc = rtems_rfs_block_find_indirect (fs,
17c68: e280b009 add fp, r0, #9 17c6c: e58d5000 str r5, [sp] 17c70: e1a00006 mov r0, r6 17c74: e2841038 add r1, r4, #56 ; 0x38 17c78: e794210b ldr r2, [r4, fp, lsl #2] 17c7c: ea000018 b 17ce4 <rtems_rfs_block_map_find+0x11c>
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
17c80: e1a01009 mov r1, r9 <== NOT EXECUTED 17c84: eb004cdb bl 2aff8 <__umodsi3> <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
17c88: e596303c ldr r3, [r6, #60] ; 0x3c <== NOT EXECUTED 17c8c: e15a0003 cmp sl, r3 <== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
17c90: e1a08000 mov r8, r0 <== NOT EXECUTED 17c94: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
17c98: 2a00001f bcs 17d1c <rtems_rfs_block_map_find+0x154> <== NOT EXECUTED
/*
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
17c9c: e1a01009 mov r1, r9 <== NOT EXECUTED 17ca0: e1a0000b mov r0, fp <== NOT EXECUTED 17ca4: ebffa725 bl 1940 <__aeabi_uidiv> <== NOT EXECUTED
singly %= fs->blocks_per_block;
if (map->size.count < fs->block_map_doubly_blocks)
{
rc = rtems_rfs_block_find_indirect (fs,
17ca8: e284a044 add sl, r4, #68 ; 0x44 <== NOT EXECUTED 17cac: e2803009 add r3, r0, #9 <== NOT EXECUTED 17cb0: e28d2008 add r2, sp, #8 <== NOT EXECUTED 17cb4: e58d2000 str r2, [sp] <== NOT EXECUTED 17cb8: e1a00006 mov r0, r6 <== NOT EXECUTED 17cbc: e7942103 ldr r2, [r4, r3, lsl #2] <== NOT EXECUTED 17cc0: e1a0100a mov r1, sl <== NOT EXECUTED 17cc4: e1a03008 mov r3, r8 <== NOT EXECUTED 17cc8: ebfffe8a bl 176f8 <rtems_rfs_block_find_indirect> <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
singly, &singly);
if (rc == 0)
17ccc: e3500000 cmp r0, #0 <== NOT EXECUTED 17cd0: 1a000012 bne 17d20 <rtems_rfs_block_map_find+0x158> <== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
17cd4: e58d5000 str r5, [sp] <== NOT EXECUTED 17cd8: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 17cdc: e1a00006 mov r0, r6 <== NOT EXECUTED 17ce0: e2841038 add r1, r4, #56 ; 0x38 <== NOT EXECUTED
17ce4: e59d3004 ldr r3, [sp, #4] 17ce8: ebfffe82 bl 176f8 <rtems_rfs_block_find_indirect>
}
}
}
}
if (rc == 0)
17cec: e3500000 cmp r0, #0
17cf0: 1a00000a bne 17d20 <rtems_rfs_block_map_find+0x158>
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
17cf4: e5973000 ldr r3, [r7] 17cf8: e5843010 str r3, [r4, #16] 17cfc: e5973004 ldr r3, [r7, #4] 17d00: e5843014 str r3, [r4, #20] 17d04: e5973008 ldr r3, [r7, #8] 17d08: e5843018 str r3, [r4, #24]
map->bpos.block = *block;
17d0c: e5953000 ldr r3, [r5] 17d10: e3a00000 mov r0, #0 17d14: e5843018 str r3, [r4, #24] 17d18: ea000000 b 17d20 <rtems_rfs_block_map_find+0x158>
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
return ENXIO;
17d1c: e3a00006 mov r0, #6
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
map->bpos.block = *block;
}
return rc;
}
17d20: e8bd8ffe pop {r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
00017dc0 <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)
{
17dc0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
17dc4: e1a05000 mov r5, r0
17dc8: e24dd014 sub sp, sp, #20
17dcc: e1a04001 mov r4, r1
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
17dd0: e3a00a02 mov r0, #8192 ; 0x2000 17dd4: e3a01000 mov r1, #0
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)
{
17dd8: e1a0b002 mov fp, r2 17ddc: e58d3008 str r3, [sp, #8]
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
17de0: ebffe521 bl 1126c <rtems_rfs_trace> 17de4: e3500000 cmp r0, #0
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
17de8: 159f0368 ldrne r0, [pc, #872] ; 18158 <rtems_rfs_block_map_grow+0x398> 17dec: 11a0100b movne r1, fp 17df0: 15942008 ldrne r2, [r4, #8] 17df4: 1b001b0c blne 1ea2c <printf>
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
17df8: e5942008 ldr r2, [r4, #8] 17dfc: e595303c ldr r3, [r5, #60] ; 0x3c 17e00: e08b2002 add r2, fp, r2 17e04: e1520003 cmp r2, r3
map->last_map_block = new_block;
return 0;
}
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
17e08: 33a09000 movcc r9, #0
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))
17e0c: 2a0000cd bcs 18148 <rtems_rfs_block_map_grow+0x388>
17e10: ea0000c8 b 18138 <rtems_rfs_block_map_grow+0x378>
/*
* 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,
17e14: e1a00005 mov r0, r5 17e18: e5941020 ldr r1, [r4, #32] 17e1c: e3a02000 mov r2, #0 17e20: e28d300c add r3, sp, #12 17e24: ebffddce bl f564 <rtems_rfs_group_bitmap_alloc>
false, &block);
if (rc > 0)
17e28: e250a000 subs sl, r0, #0
17e2c: ca0000c6 bgt 1814c <rtems_rfs_block_map_grow+0x38c>
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
17e30: e5948008 ldr r8, [r4, #8] 17e34: e3580004 cmp r8, #4
map->blocks[map->size.count] = block;
17e38: 959d300c ldrls r3, [sp, #12] 17e3c: 92888009 addls r8, r8, #9 17e40: 97843108 strls r3, [r4, r8, lsl #2]
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)
17e44: 9a0000ae bls 18104 <rtems_rfs_block_map_grow+0x344>
* 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;
17e48: e5957034 ldr r7, [r5, #52] ; 0x34 17e4c: e1a00008 mov r0, r8 17e50: e1a01007 mov r1, r7 17e54: eb004c67 bl 2aff8 <__umodsi3>
singly = map->size.count / fs->blocks_per_block;
17e58: e1a01007 mov r1, r7
* 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;
17e5c: e1a06000 mov r6, r0
singly = map->size.count / fs->blocks_per_block;
17e60: e1a00008 mov r0, r8 17e64: ebffa6b5 bl 1940 <__aeabi_uidiv>
if (map->size.count < fs->block_map_singly_blocks)
17e68: e5953038 ldr r3, [r5, #56] ; 0x38 17e6c: e1580003 cmp r8, r3
*/
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;
17e70: e1a0a000 mov sl, r0
if (map->size.count < fs->block_map_singly_blocks)
17e74: 2a000018 bcs 17edc <rtems_rfs_block_map_grow+0x11c>
* 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) ||
17e78: e3560000 cmp r6, #0
17e7c: 0a000002 beq 17e8c <rtems_rfs_block_map_grow+0xcc>
17e80: e3560005 cmp r6, #5 17e84: 03500000 cmpeq r0, #0
17e88: 1a00000a bne 17eb8 <rtems_rfs_block_map_grow+0xf8>
/*
* 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,
17e8c: e2480005 sub r0, r8, #5 17e90: e2708000 rsbs r8, r0, #0 17e94: e28a3009 add r3, sl, #9 17e98: e0a88000 adc r8, r8, r0 17e9c: e1a01004 mov r1, r4 17ea0: e1a00005 mov r0, r5 17ea4: e2842038 add r2, r4, #56 ; 0x38 17ea8: e0843103 add r3, r4, r3, lsl #2 17eac: e58d8000 str r8, [sp] 17eb0: ebfffdc2 bl 175c0 <rtems_rfs_block_map_indirect_alloc> 17eb4: ea000005 b 17ed0 <rtems_rfs_block_map_grow+0x110>
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
17eb8: e280a009 add sl, r0, #9 17ebc: e2841038 add r1, r4, #56 ; 0x38 17ec0: e1a00005 mov r0, r5 17ec4: e794210a ldr r2, [r4, sl, lsl #2] 17ec8: e3a03001 mov r3, #1 17ecc: eb000226 bl 1876c <rtems_rfs_buffer_handle_request> 17ed0: e1a0a000 mov sl, r0
map->blocks[singly], true);
}
if (rc > 0)
17ed4: e3500000 cmp r0, #0 17ed8: ea00006c b 18090 <rtems_rfs_block_map_grow+0x2d0>
* Doubly indirect tables are being used.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
17edc: e1a01007 mov r1, r7 <== NOT EXECUTED 17ee0: ebffa696 bl 1940 <__aeabi_uidiv> <== NOT EXECUTED
singly %= fs->blocks_per_block;
17ee4: e1a01007 mov r1, r7 <== 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;
17ee8: e1a08000 mov r8, r0 <== NOT EXECUTED
singly %= fs->blocks_per_block;
17eec: e1a0000a mov r0, sl <== NOT EXECUTED 17ef0: eb004c40 bl 2aff8 <__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)
17ef4: e3560000 cmp r6, #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;
17ef8: e1a07000 mov r7, 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)
17efc: 1a00004b bne 18030 <rtems_rfs_block_map_grow+0x270> <== NOT EXECUTED
{
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
17f00: e1a00005 mov r0, r5 <== NOT EXECUTED 17f04: e1a01004 mov r1, r4 <== NOT EXECUTED 17f08: e2842038 add r2, r4, #56 ; 0x38 <== NOT EXECUTED 17f0c: e28d3010 add r3, sp, #16 <== NOT EXECUTED 17f10: e58d6000 str r6, [sp] <== NOT EXECUTED 17f14: ebfffda9 bl 175c0 <rtems_rfs_block_map_indirect_alloc> <== NOT EXECUTED
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
17f18: e250a000 subs sl, r0, #0 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
17f1c: c1a00005 movgt r0, r5 <== NOT EXECUTED 17f20: c1a01006 movgt r1, r6 <== NOT EXECUTED 17f24: ca00005c bgt 1809c <rtems_rfs_block_map_grow+0x2dc> <== 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) ||
17f28: e3570000 cmp r7, #0 <== NOT EXECUTED 17f2c: 0a000005 beq 17f48 <rtems_rfs_block_map_grow+0x188> <== NOT EXECUTED 17f30: e3570005 cmp r7, #5 <== NOT EXECUTED 17f34: 03580000 cmpeq r8, #0 <== NOT EXECUTED 17f38: 13a02000 movne r2, #0 <== NOT EXECUTED 17f3c: 03a02001 moveq r2, #1 <== NOT EXECUTED 17f40: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 17f44: 1a000012 bne 17f94 <rtems_rfs_block_map_grow+0x1d4> <== 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,
17f48: e5952038 ldr r2, [r5, #56] ; 0x38 <== NOT EXECUTED 17f4c: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED 17f50: e0621001 rsb r1, r2, r1 <== NOT EXECUTED 17f54: e2712000 rsbs r2, r1, #0 <== NOT EXECUTED 17f58: e0a22001 adc r2, r2, r1 <== NOT EXECUTED 17f5c: e2883009 add r3, r8, #9 <== NOT EXECUTED 17f60: e58d2000 str r2, [sp] <== NOT EXECUTED 17f64: e1a00005 mov r0, r5 <== NOT EXECUTED 17f68: e1a01004 mov r1, r4 <== NOT EXECUTED 17f6c: e2842044 add r2, r4, #68 ; 0x44 <== NOT EXECUTED 17f70: e0843103 add r3, r4, r3, lsl #2 <== NOT EXECUTED 17f74: ebfffd91 bl 175c0 <rtems_rfs_block_map_indirect_alloc> <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
upping);
if (rc > 0)
17f78: e250a000 subs sl, r0, #0 <== NOT EXECUTED 17f7c: da000013 ble 17fd0 <rtems_rfs_block_map_grow+0x210> <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
17f80: e1a00005 mov r0, r5 <== NOT EXECUTED 17f84: e3a01000 mov r1, #0 <== NOT EXECUTED 17f88: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 17f8c: ebffdde7 bl f730 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED 17f90: ea00003f b 18094 <rtems_rfs_block_map_grow+0x2d4> <== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
17f94: e2888009 add r8, r8, #9 <== NOT EXECUTED 17f98: e1a00005 mov r0, r5 <== NOT EXECUTED 17f9c: e2841044 add r1, r4, #68 ; 0x44 <== NOT EXECUTED 17fa0: e7942108 ldr r2, [r4, r8, lsl #2] <== NOT EXECUTED 17fa4: e3a03001 mov r3, #1 <== NOT EXECUTED 17fa8: eb0001ef bl 1876c <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
17fac: e250a000 subs sl, r0, #0 <== NOT EXECUTED 17fb0: da000006 ble 17fd0 <rtems_rfs_block_map_grow+0x210> <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
17fb4: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 17fb8: e1a00005 mov r0, r5 <== NOT EXECUTED 17fbc: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 17fc0: ebffddda bl f730 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
17fc4: e1a00005 mov r0, r5 <== NOT EXECUTED 17fc8: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 17fcc: ea000032 b 1809c <rtems_rfs_block_map_grow+0x2dc> <== NOT EXECUTED
return rc;
}
}
rtems_rfs_block_set_number (&map->doubly_buffer,
17fd0: e594204c ldr r2, [r4, #76] ; 0x4c <== NOT EXECUTED 17fd4: e5dd1013 ldrb r1, [sp, #19] <== NOT EXECUTED 17fd8: e592201c ldr r2, [r2, #28] <== NOT EXECUTED 17fdc: e7c21107 strb r1, [r2, r7, lsl #2] <== NOT EXECUTED 17fe0: e594204c ldr r2, [r4, #76] ; 0x4c <== NOT EXECUTED 17fe4: e592201c ldr r2, [r2, #28] <== NOT EXECUTED 17fe8: e1dd11b2 ldrh r1, [sp, #18] <== NOT EXECUTED 17fec: e1a03107 lsl r3, r7, #2 <== NOT EXECUTED 17ff0: e0822003 add r2, r2, r3 <== NOT EXECUTED 17ff4: e5c21001 strb r1, [r2, #1] <== NOT EXECUTED 17ff8: e594204c ldr r2, [r4, #76] ; 0x4c <== NOT EXECUTED 17ffc: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 18000: e592201c ldr r2, [r2, #28] <== NOT EXECUTED 18004: e1a01421 lsr r1, r1, #8 <== NOT EXECUTED 18008: e0822003 add r2, r2, r3 <== NOT EXECUTED 1800c: e5c21002 strb r1, [r2, #2] <== NOT EXECUTED 18010: e594204c ldr r2, [r4, #76] ; 0x4c <== NOT EXECUTED 18014: e592201c ldr r2, [r2, #28] <== NOT EXECUTED 18018: e0823003 add r3, r2, r3 <== NOT EXECUTED 1801c: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 18020: e5c32003 strb r2, [r3, #3] <== NOT EXECUTED 18024: e3a03001 mov r3, #1 <== NOT EXECUTED 18028: e5c43044 strb r3, [r4, #68] ; 0x44 <== NOT EXECUTED 1802c: ea00001d b 180a8 <rtems_rfs_block_map_grow+0x2e8> <== NOT EXECUTED
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
18030: e2888009 add r8, r8, #9 <== NOT EXECUTED 18034: e1a00005 mov r0, r5 <== NOT EXECUTED 18038: e2841044 add r1, r4, #68 ; 0x44 <== NOT EXECUTED 1803c: e7942108 ldr r2, [r4, r8, lsl #2] <== NOT EXECUTED 18040: e3a03001 mov r3, #1 <== NOT EXECUTED 18044: eb0001c8 bl 1876c <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
true);
if (rc > 0)
18048: e250a000 subs sl, r0, #0 <== NOT EXECUTED 1804c: ca000010 bgt 18094 <rtems_rfs_block_map_grow+0x2d4> <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
18050: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED 18054: e593101c ldr r1, [r3, #28] <== NOT EXECUTED 18058: e0813107 add r3, r1, r7, lsl #2 <== NOT EXECUTED 1805c: e5d32003 ldrb r2, [r3, #3] <== NOT EXECUTED 18060: e7d11107 ldrb r1, [r1, r7, lsl #2] <== NOT EXECUTED 18064: e1822c01 orr r2, r2, r1, lsl #24 <== NOT EXECUTED 18068: e5d31001 ldrb r1, [r3, #1] <== NOT EXECUTED 1806c: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED 18070: e1822801 orr r2, r2, r1, lsl #16 <== NOT EXECUTED 18074: e1822403 orr r2, r2, r3, lsl #8 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
18078: e1a00005 mov r0, r5 <== NOT EXECUTED 1807c: e2841038 add r1, r4, #56 ; 0x38 <== NOT EXECUTED 18080: 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,
18084: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
18088: eb0001b7 bl 1876c <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
singly_block, true);
if (rc > 0)
1808c: e250a000 subs sl, r0, #0 <== NOT EXECUTED
18090: da000004 ble 180a8 <rtems_rfs_block_map_grow+0x2e8>
{
rtems_rfs_group_bitmap_free (fs, false, block);
18094: e1a00005 mov r0, r5 <== NOT EXECUTED 18098: e3a01000 mov r1, #0 <== NOT EXECUTED 1809c: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 180a0: ebffdda2 bl f730 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
180a4: ea000028 b 1814c <rtems_rfs_block_map_grow+0x38c> <== NOT EXECUTED
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
180a8: e5942040 ldr r2, [r4, #64] ; 0x40 180ac: e5dd100f ldrb r1, [sp, #15] 180b0: e592201c ldr r2, [r2, #28] 180b4: e7c21106 strb r1, [r2, r6, lsl #2] 180b8: e5942040 ldr r2, [r4, #64] ; 0x40 180bc: e592201c ldr r2, [r2, #28] 180c0: e1dd10be ldrh r1, [sp, #14] 180c4: e1a03106 lsl r3, r6, #2 180c8: e0822003 add r2, r2, r3 180cc: e5c21001 strb r1, [r2, #1] 180d0: e5942040 ldr r2, [r4, #64] ; 0x40 180d4: e59d100c ldr r1, [sp, #12] 180d8: e592201c ldr r2, [r2, #28] 180dc: e1a01421 lsr r1, r1, #8 180e0: e0822003 add r2, r2, r3 180e4: e5c21002 strb r1, [r2, #2] 180e8: e5942040 ldr r2, [r4, #64] ; 0x40 180ec: e592201c ldr r2, [r2, #28] 180f0: e0823003 add r3, r2, r3 180f4: e59d200c ldr r2, [sp, #12] 180f8: e5c32003 strb r2, [r3, #3] 180fc: e3a02001 mov r2, #1 18100: e5c42038 strb r2, [r4, #56] ; 0x38
}
map->size.count++;
18104: e5943008 ldr r3, [r4, #8] 18108: e2833001 add r3, r3, #1 1810c: e5843008 str r3, [r4, #8]
map->size.offset = 0;
18110: e3a03000 mov r3, #0
if (b == 0)
18114: e1590003 cmp r9, r3
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
map->size.offset = 0;
18118: e584300c str r3, [r4, #12]
if (b == 0)
*new_block = block;
1811c: 059d2008 ldreq r2, [sp, #8] 18120: e59d300c ldr r3, [sp, #12] 18124: 05823000 streq r3, [r2]
map->last_data_block = block;
18128: e5843020 str r3, [r4, #32]
map->dirty = true;
1812c: e3a03001 mov r3, #1 18130: e5c43000 strb r3, [r4]
/*
* 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++)
18134: e2899001 add r9, r9, #1 18138: e159000b cmp r9, fp
1813c: 1affff34 bne 17e14 <rtems_rfs_block_map_grow+0x54>
*new_block = block;
map->last_data_block = block;
map->dirty = true;
}
return 0;
18140: e3a0a000 mov sl, #0 18144: ea000000 b 1814c <rtems_rfs_block_map_grow+0x38c>
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))
return EFBIG;
18148: e3a0a01b mov sl, #27 <== NOT EXECUTED
map->last_data_block = block;
map->dirty = true;
}
return 0;
}
1814c: e1a0000a mov r0, sl
18150: e28dd014 add sp, sp, #20
18154: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
000175c0 <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)
{
175c0: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr}
175c4: e1a05001 mov r5, r1
175c8: e1a04002 mov r4, r2
175cc: e1a08003 mov r8, r3
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);
175d0: e591101c ldr r1, [r1, #28] 175d4: e3a02000 mov r2, #0 175d8: e1a0300d mov r3, sp
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)
{
175dc: e1a06000 mov r6, r0 175e0: e5dd7020 ldrb r7, [sp, #32]
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);
175e4: ebffdfde bl f564 <rtems_rfs_group_bitmap_alloc>
if (rc > 0)
175e8: e250a000 subs sl, r0, #0
175ec: ca00003e bgt 176ec <rtems_rfs_block_map_indirect_alloc+0x12c>
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
175f0: e1a00006 mov r0, r6 175f4: e1a01004 mov r1, r4 175f8: e59d2000 ldr r2, [sp] 175fc: e3a03000 mov r3, #0 17600: eb000459 bl 1876c <rtems_rfs_buffer_handle_request>
if (rc > 0)
17604: e250a000 subs sl, r0, #0
17608: da000004 ble 17620 <rtems_rfs_block_map_indirect_alloc+0x60>
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
1760c: e1a00006 mov r0, r6 <== NOT EXECUTED 17610: e3a01000 mov r1, #0 <== NOT EXECUTED 17614: e59d2000 ldr r2, [sp] <== NOT EXECUTED 17618: ebffe044 bl f730 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
1761c: ea000032 b 176ec <rtems_rfs_block_map_indirect_alloc+0x12c><== NOT EXECUTED
} memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
17620: e5943008 ldr r3, [r4, #8] 17624: e3a010ff mov r1, #255 ; 0xff 17628: e593001c ldr r0, [r3, #28] 1762c: e5962008 ldr r2, [r6, #8] 17630: eb001c8c bl 1e868 <memset>
if (upping)
17634: e3570000 cmp r7, #0
17638: 0a000025 beq 176d4 <rtems_rfs_block_map_indirect_alloc+0x114>
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
1763c: e3a00a02 mov r0, #8192 ; 0x2000 17640: e3a01000 mov r1, #0 17644: ebffe708 bl 1126c <rtems_rfs_trace> 17648: e3500000 cmp r0, #0
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
1764c: 159f00a0 ldrne r0, [pc, #160] ; 176f4 <rtems_rfs_block_map_indirect_alloc+0x134> 17650: 15951008 ldrne r1, [r5, #8] 17654: 1b001cf4 blne 1ea2c <printf> 17658: e1a03005 mov r3, r5
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)
{
1765c: e3a02000 mov r2, #0
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]);
17660: e3a01001 mov r1, #1 17664: e5940008 ldr r0, [r4, #8] 17668: e5d3c027 ldrb ip, [r3, #39] ; 0x27 1766c: e590001c ldr r0, [r0, #28] 17670: e7c0c002 strb ip, [r0, r2] 17674: e5940008 ldr r0, [r4, #8] 17678: e590001c ldr r0, [r0, #28] 1767c: e1d3c2b6 ldrh ip, [r3, #38] ; 0x26 17680: e0800002 add r0, r0, r2 17684: e5c0c001 strb ip, [r0, #1] 17688: e5940008 ldr r0, [r4, #8] 1768c: e593c024 ldr ip, [r3, #36] ; 0x24 17690: e590001c ldr r0, [r0, #28] 17694: e1a0c42c lsr ip, ip, #8 17698: e0800002 add r0, r0, r2 1769c: e5c0c002 strb ip, [r0, #2] 176a0: e5940008 ldr r0, [r4, #8] 176a4: e590001c ldr r0, [r0, #28] 176a8: e593c024 ldr ip, [r3, #36] ; 0x24 176ac: e0800002 add r0, r0, r2 176b0: e2822004 add r2, r2, #4
{
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++)
176b4: e3520014 cmp r2, #20
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
176b8: e5c0c003 strb ip, [r0, #3] 176bc: e2833004 add r3, r3, #4 176c0: e5c41000 strb r1, [r4]
{
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++)
176c4: 1affffe6 bne 17664 <rtems_rfs_block_map_indirect_alloc+0xa4>
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
176c8: e2850024 add r0, r5, #36 ; 0x24 176cc: e3a01000 mov r1, #0 176d0: eb001c64 bl 1e868 <memset>
} rtems_rfs_buffer_mark_dirty (buffer);
176d4: e3a03001 mov r3, #1 176d8: e5c43000 strb r3, [r4]
*block = new_block;
176dc: e59d3000 ldr r3, [sp] 176e0: e5883000 str r3, [r8]
map->last_map_block = new_block;
176e4: e585301c str r3, [r5, #28]
return 0;
176e8: e3a0a000 mov sl, #0
}
176ec: e1a0000a mov r0, sl
176f0: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc}
00017898 <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)
{
17898: e92d41f0 push {r4, r5, r6, r7, r8, lr}
* 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;
1789c: e3a07000 mov r7, #0 178a0: e5c27000 strb r7, [r2]
map->inode = NULL;
178a4: e5827004 str r7, [r2, #4]
* @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;
178a8: e5827008 str r7, [r2, #8]
size->offset = 0;
178ac: e582700c str r7, [r2, #12]
* @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;
178b0: e5827010 str r7, [r2, #16]
bpos->boff = 0;
178b4: e5827014 str r7, [r2, #20]
bpos->block = 0;
178b8: e5827018 str r7, [r2, #24]
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
178bc: e5c27038 strb r7, [r2, #56] ; 0x38
handle->bnum = 0;
178c0: e582703c str r7, [r2, #60] ; 0x3c
handle->buffer = NULL;
178c4: e5827040 str r7, [r2, #64] ; 0x40
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
178c8: e5c27044 strb r7, [r2, #68] ; 0x44
handle->bnum = 0;
178cc: e5827048 str r7, [r2, #72] ; 0x48
handle->buffer = NULL;
178d0: e582704c str r7, [r2, #76] ; 0x4c
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* inode,
rtems_rfs_block_map* map)
{
178d4: e1a05000 mov r5, r0 178d8: e1a04001 mov r4, r1 178dc: e1a06002 mov r6, r2
return rc;
rc = rtems_rfs_buffer_handle_open (fs, &map->doubly_buffer);
if (rc > 0)
return rc;
rc = rtems_rfs_inode_load (fs, inode);
178e0: ebffe02a bl f990 <rtems_rfs_inode_load>
if (rc > 0)
178e4: e2508000 subs r8, r0, #0
178e8: da00000d ble 17924 <rtems_rfs_block_map_open+0x8c>
*/
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);
178ec: e2861038 add r1, r6, #56 ; 0x38 <== NOT EXECUTED 178f0: e1a00005 mov r0, r5 <== NOT EXECUTED 178f4: eb000330 bl 185bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
178f8: e5c67038 strb r7, [r6, #56] ; 0x38 <== NOT EXECUTED
handle->bnum = 0;
178fc: e586703c str r7, [r6, #60] ; 0x3c <== NOT EXECUTED
handle->buffer = NULL;
17900: e5867040 str r7, [r6, #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);
17904: e1a00005 mov r0, r5 <== NOT EXECUTED 17908: e2861044 add r1, r6, #68 ; 0x44 <== NOT EXECUTED 1790c: eb00032a bl 185bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
17910: e5c67044 strb r7, [r6, #68] ; 0x44 <== NOT EXECUTED
handle->bnum = 0;
17914: e5867048 str r7, [r6, #72] ; 0x48 <== NOT EXECUTED
handle->buffer = NULL;
17918: e586704c str r7, [r6, #76] ; 0x4c <== NOT EXECUTED
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
rc = rtems_rfs_inode_unload (fs, inode, false);
return rc;
}
1791c: e1a00008 mov r0, r8 <== NOT EXECUTED
17920: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
17924: e594300c ldr r3, [r4, #12]
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
17928: e5864004 str r4, [r6, #4] 1792c: e283201c add r2, r3, #28 17930: e1a01006 mov r1, r6 17934: e287c007 add ip, r7, #7 17938: e5d20003 ldrb r0, [r2, #3] 1793c: e7d3c10c ldrb ip, [r3, ip, lsl #2] 17940: e1800c0c orr r0, r0, ip, lsl #24 17944: e5d2c001 ldrb ip, [r2, #1] 17948: e180080c orr r0, r0, ip, lsl #16 1794c: e5d2c002 ldrb ip, [r2, #2]
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
17950: e2877001 add r7, r7, #1 17954: e180040c orr r0, r0, ip, lsl #8 17958: e3570005 cmp r7, #5
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
1795c: e5810024 str r0, [r1, #36] ; 0x24
/* * 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++)
17960: e2822004 add r2, r2, #4 17964: e2811004 add r1, r1, #4
17968: 1afffff1 bne 17934 <rtems_rfs_block_map_open+0x9c>
* @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);
1796c: e5d3200d ldrb r2, [r3, #13] 17970: e5d3100c ldrb r1, [r3, #12] 17974: e1a02802 lsl r2, r2, #16 17978: e1822c01 orr r2, r2, r1, lsl #24 1797c: e5d3100f ldrb r1, [r3, #15] 17980: e1822001 orr r2, r2, r1 17984: e5d3100e ldrb r1, [r3, #14] 17988: e1822401 orr r2, r2, r1, lsl #8
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
map->size.count = rtems_rfs_inode_get_block_count (inode);
1798c: e5862008 str r2, [r6, #8]
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
17990: e5d3100a ldrb r1, [r3, #10] 17994: e5d3200b ldrb r2, [r3, #11]
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
17998: e1822401 orr r2, r2, r1, lsl #8 1799c: e586200c str r2, [r6, #12]
* @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);
179a0: e5d32031 ldrb r2, [r3, #49] ; 0x31 179a4: e5d31030 ldrb r1, [r3, #48] ; 0x30 179a8: e1a02802 lsl r2, r2, #16 179ac: e1822c01 orr r2, r2, r1, lsl #24 179b0: e5d31033 ldrb r1, [r3, #51] ; 0x33 179b4: e1822001 orr r2, r2, r1 179b8: e5d31032 ldrb r1, [r3, #50] ; 0x32 179bc: e1822401 orr r2, r2, r1, lsl #8
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
179c0: e586201c str r2, [r6, #28]
* @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);
179c4: e5d32035 ldrb r2, [r3, #53] ; 0x35 179c8: e5d31034 ldrb r1, [r3, #52] ; 0x34 179cc: e1a02802 lsl r2, r2, #16 179d0: e1822c01 orr r2, r2, r1, lsl #24 179d4: e5d31037 ldrb r1, [r3, #55] ; 0x37 179d8: e5d33036 ldrb r3, [r3, #54] ; 0x36 179dc: e1822001 orr r2, r2, r1 179e0: e1823403 orr r3, r2, r3, lsl #8
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
rc = rtems_rfs_inode_unload (fs, inode, false);
179e4: e1a00005 mov r0, r5 179e8: e1a01004 mov r1, r4 179ec: e3a02000 mov r2, #0
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);
179f0: e5863020 str r3, [r6, #32]
rc = rtems_rfs_inode_unload (fs, inode, false);
return rc;
}
179f4: e8bd41f0 pop {r4, r5, r6, r7, r8, lr}
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);
179f8: eaffe047 b fb1c <rtems_rfs_inode_unload>
0001815c <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
1815c: e92d4fff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, lr}
18160: e1a05000 mov r5, r0
18164: e1a04001 mov r4, r1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
18168: e3a00901 mov r0, #16384 ; 0x4000 1816c: e3a01000 mov r1, #0
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
18170: e1a06002 mov r6, r2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
18174: ebffe43c bl 1126c <rtems_rfs_trace> 18178: e3500000 cmp r0, #0
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
1817c: 159f02bc ldrne r0, [pc, #700] ; 18440 <rtems_rfs_block_map_shrink+0x2e4> 18180: 11a01006 movne r1, r6 18184: 15942008 ldrne r2, [r4, #8] 18188: 1b001a27 blne 1ea2c <printf>
blocks, map->size.count);
if (map->size.count == 0)
1818c: e5940008 ldr r0, [r4, #8] 18190: e3500000 cmp r0, #0
18194: 0a0000a7 beq 18438 <rtems_rfs_block_map_shrink+0x2dc>
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,
18198: e2842044 add r2, r4, #68 ; 0x44
{
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)
1819c: e1560000 cmp r6, r0 181a0: 31a09006 movcc r9, r6 181a4: 21a09000 movcs r9, r0
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,
181a8: e58d200c str r2, [sp, #12]
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
181ac: e284b038 add fp, r4, #56 ; 0x38 181b0: ea00007f b 183b4 <rtems_rfs_block_map_shrink+0x258>
{
rtems_rfs_block_no block;
rtems_rfs_block_no block_to_free;
int rc;
block = map->size.count - 1;
181b4: e5943008 ldr r3, [r4, #8] 181b8: e243a001 sub sl, r3, #1
if (block < RTEMS_RFS_INODE_BLOCKS)
181bc: e35a0004 cmp sl, #4
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
181c0: 92833008 addls r3, r3, #8
map->blocks[block] = 0;
181c4: 93a02000 movls r2, #0
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
181c8: 97947103 ldrls r7, [r4, r3, lsl #2]
map->blocks[block] = 0;
181cc: 97842103 strls r2, [r4, r3, lsl #2]
181d0: 9a000068 bls 18378 <rtems_rfs_block_map_shrink+0x21c>
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
181d4: e5957034 ldr r7, [r5, #52] ; 0x34 181d8: e1a0000a mov r0, sl 181dc: e1a01007 mov r1, r7 181e0: eb004b84 bl 2aff8 <__umodsi3>
singly = block / fs->blocks_per_block;
181e4: e1a01007 mov r1, r7
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
181e8: e1a06000 mov r6, r0
singly = block / fs->blocks_per_block;
181ec: e1a0000a mov r0, sl 181f0: ebffa5d2 bl 1940 <__aeabi_uidiv>
if (block < fs->block_map_singly_blocks)
181f4: e5953038 ldr r3, [r5, #56] ; 0x38 181f8: e15a0003 cmp sl, r3
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
singly = block / fs->blocks_per_block;
181fc: e1a08000 mov r8, r0
if (block < fs->block_map_singly_blocks)
18200: 2a00001e bcs 18280 <rtems_rfs_block_map_shrink+0x124>
{
/*
* Request the indirect block and then obtain the block number from the
* indirect block.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
18204: e2803009 add r3, r0, #9 18208: e7942103 ldr r2, [r4, r3, lsl #2] 1820c: e1a00005 mov r0, r5 18210: e1a0100b mov r1, fp 18214: e3a03001 mov r3, #1 18218: eb000153 bl 1876c <rtems_rfs_buffer_handle_request>
map->blocks[singly], true);
if (rc > 0)
1821c: e3500000 cmp r0, #0
18220: ca000084 bgt 18438 <rtems_rfs_block_map_shrink+0x2dc>
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
18224: e5943040 ldr r3, [r4, #64] ; 0x40 18228: e593301c ldr r3, [r3, #28] 1822c: e7d37106 ldrb r7, [r3, r6, lsl #2] 18230: e0833106 add r3, r3, r6, lsl #2 18234: e5d32002 ldrb r2, [r3, #2] 18238: e5d3c001 ldrb ip, [r3, #1] 1823c: e5d3a003 ldrb sl, [r3, #3] 18240: e58d2008 str r2, [sp, #8]
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
18244: e1a00005 mov r0, r5 18248: e1a01004 mov r1, r4 1824c: e1a0200b mov r2, fp 18250: e1a03008 mov r3, r8 18254: e58dc004 str ip, [sp, #4] 18258: e58d6000 str r6, [sp] 1825c: ebfffcac bl 17514 <rtems_rfs_block_map_indirect_shrink>
singly, direct);
if (rc)
18260: e3500000 cmp r0, #0 18264: e59dc004 ldr ip, [sp, #4]
18268: 1a000072 bne 18438 <rtems_rfs_block_map_shrink+0x2dc>
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,
1826c: e18a7c07 orr r7, sl, r7, lsl #24 18270: e59d3008 ldr r3, [sp, #8] 18274: e187780c orr r7, r7, ip, lsl #16 18278: e1877403 orr r7, r7, r3, lsl #8 1827c: ea00003d b 18378 <rtems_rfs_block_map_shrink+0x21c>
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)
18280: e595303c ldr r3, [r5, #60] ; 0x3c <== NOT EXECUTED 18284: e15a0003 cmp sl, r3 <== NOT EXECUTED 18288: 2a00004b bcs 183bc <rtems_rfs_block_map_shrink+0x260> <== 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;
1828c: e1a01007 mov r1, r7 <== NOT EXECUTED 18290: ebffa5aa bl 1940 <__aeabi_uidiv> <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
18294: 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;
18298: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
1829c: e7942103 ldr r2, [r4, r3, lsl #2] <== NOT EXECUTED 182a0: e1a00005 mov r0, r5 <== NOT EXECUTED 182a4: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 182a8: e3a03001 mov r3, #1 <== NOT EXECUTED 182ac: eb00012e bl 1876c <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
182b0: e3500000 cmp r0, #0 <== NOT EXECUTED 182b4: ca00005f bgt 18438 <rtems_rfs_block_map_shrink+0x2dc> <== 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;
182b8: e1a00008 mov r0, r8 <== NOT EXECUTED 182bc: e1a01007 mov r1, r7 <== NOT EXECUTED 182c0: eb004b4c bl 2aff8 <__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,
182c4: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED 182c8: e593201c ldr r2, [r3, #28] <== NOT EXECUTED 182cc: e0823100 add r3, r2, r0, lsl #2 <== NOT EXECUTED 182d0: e5d31003 ldrb r1, [r3, #3] <== NOT EXECUTED 182d4: e7d28100 ldrb r8, [r2, r0, lsl #2] <== NOT EXECUTED 182d8: e5d32001 ldrb r2, [r3, #1] <== NOT EXECUTED 182dc: e1818c08 orr r8, r1, r8, lsl #24 <== NOT EXECUTED 182e0: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED 182e4: e1888802 orr r8, r8, r2, lsl #16 <== NOT EXECUTED 182e8: e1888403 orr r8, r8, 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;
182ec: e1a0a000 mov sl, 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,
182f0: e1a0100b mov r1, fp <== NOT EXECUTED 182f4: e1a00005 mov r0, r5 <== NOT EXECUTED 182f8: e1a02008 mov r2, r8 <== NOT EXECUTED 182fc: e3a03001 mov r3, #1 <== NOT EXECUTED 18300: eb000119 bl 1876c <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
singly, true);
if (rc > 0)
18304: e3500000 cmp r0, #0 <== NOT EXECUTED 18308: ca00004a bgt 18438 <rtems_rfs_block_map_shrink+0x2dc> <== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
1830c: e5943040 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED 18310: e593201c ldr r2, [r3, #28] <== NOT EXECUTED 18314: e0823106 add r3, r2, r6, lsl #2 <== NOT EXECUTED 18318: e5d31003 ldrb r1, [r3, #3] <== NOT EXECUTED 1831c: e7d27106 ldrb r7, [r2, r6, lsl #2] <== NOT EXECUTED 18320: e5d32001 ldrb r2, [r3, #1] <== NOT EXECUTED 18324: e1817c07 orr r7, r1, r7, lsl #24 <== NOT EXECUTED 18328: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED 1832c: e1877802 orr r7, r7, r2, lsl #16 <== NOT EXECUTED
direct);
if (direct == 0)
18330: 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,
18334: e1877403 orr r7, r7, r3, lsl #8 <== NOT EXECUTED
direct);
if (direct == 0)
18338: 1a00000e bne 18378 <rtems_rfs_block_map_shrink+0x21c> <== NOT EXECUTED
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
1833c: e1a00005 mov r0, r5 <== NOT EXECUTED 18340: e1a01006 mov r1, r6 <== NOT EXECUTED 18344: e1a02008 mov r2, r8 <== NOT EXECUTED 18348: ebffdcf8 bl f730 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
1834c: e3500000 cmp r0, #0 <== NOT EXECUTED 18350: ca000038 bgt 18438 <rtems_rfs_block_map_shrink+0x2dc> <== NOT EXECUTED
return rc;
map->last_map_block = singly;
18354: e584801c str r8, [r4, #28] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
18358: e1a00005 mov r0, r5 <== NOT EXECUTED 1835c: e1a01004 mov r1, r4 <== NOT EXECUTED 18360: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 18364: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 18368: e58da000 str sl, [sp] <== NOT EXECUTED 1836c: ebfffc68 bl 17514 <rtems_rfs_block_map_indirect_shrink> <== NOT EXECUTED
doubly, doubly_singly);
if (rc)
18370: e3500000 cmp r0, #0 <== NOT EXECUTED 18374: 1a00002f bne 18438 <rtems_rfs_block_map_shrink+0x2dc> <== NOT EXECUTED
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
18378: e1a00005 mov r0, r5 1837c: e3a01000 mov r1, #0 18380: e1a02007 mov r2, r7 18384: ebffdce9 bl f730 <rtems_rfs_group_bitmap_free>
if (rc > 0)
18388: e3500000 cmp r0, #0
1838c: ca000029 bgt 18438 <rtems_rfs_block_map_shrink+0x2dc>
return rc;
map->size.count--;
18390: e5943008 ldr r3, [r4, #8] 18394: e2433001 sub r3, r3, #1 18398: e5843008 str r3, [r4, #8]
map->size.offset = 0;
1839c: e3a02000 mov r2, #0
map->last_data_block = block_to_free;
map->dirty = true;
183a0: e3a03001 mov r3, #1
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->size.count--;
map->size.offset = 0;
183a4: e584200c str r2, [r4, #12]
map->last_data_block = block_to_free;
183a8: e5847020 str r7, [r4, #32]
map->dirty = true;
183ac: e5c43000 strb r3, [r4]
blocks--;
183b0: e2499001 sub r9, r9, #1
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
183b4: e3590000 cmp r9, #0
183b8: 1affff7d bne 181b4 <rtems_rfs_block_map_shrink+0x58>
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
183bc: e5943008 ldr r3, [r4, #8]
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
183c0: e5942010 ldr r2, [r4, #16]
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
183c4: e3530000 cmp r3, #0
{
map->last_map_block = 0;
183c8: 0584301c streq r3, [r4, #28]
map->last_data_block = 0;
183cc: 05843020 streq r3, [r4, #32]
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
183d0: e3520000 cmp r2, #0
183d4: 0a000001 beq 183e0 <rtems_rfs_block_map_shrink+0x284>
183d8: e3530000 cmp r3, #0
183dc: 0a000008 beq 18404 <rtems_rfs_block_map_shrink+0x2a8>
183e0: e1520003 cmp r2, r3
183e4: 2a000006 bcs 18404 <rtems_rfs_block_map_shrink+0x2a8>
183e8: e2431001 sub r1, r3, #1 183ec: e1520001 cmp r2, r1
183f0: 1a00000d bne 1842c <rtems_rfs_block_map_shrink+0x2d0>
183f4: e5941014 ldr r1, [r4, #20] 183f8: e594200c ldr r2, [r4, #12] 183fc: e1510002 cmp r1, r2
18400: 9a000009 bls 1842c <rtems_rfs_block_map_shrink+0x2d0>
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
18404: e594200c ldr r2, [r4, #12] 18408: e3a00000 mov r0, #0 1840c: e1520000 cmp r2, r0 18410: e5843010 str r3, [r4, #16] 18414: 12433001 subne r3, r3, #1 18418: e5842014 str r2, [r4, #20] 1841c: e5840018 str r0, [r4, #24] 18420: 15843010 strne r3, [r4, #16]
18424: 1a000003 bne 18438 <rtems_rfs_block_map_shrink+0x2dc>
18428: ea000001 b 18434 <rtems_rfs_block_map_shrink+0x2d8>
return 0;
1842c: e3a00000 mov r0, #0 <== NOT EXECUTED 18430: ea000000 b 18438 <rtems_rfs_block_map_shrink+0x2dc> <== NOT EXECUTED
18434: e1a00002 mov r0, r2
}
18438: e28dd010 add sp, sp, #16
1843c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0001d29c <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
1d29c: e92d4030 push {r4, r5, lr}
1d2a0: e1a04000 mov r4, r0
1d2a4: e20150ff and r5, r1, #255 ; 0xff
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
1d2a8: e3a00040 mov r0, #64 ; 0x40 1d2ac: e3a01000 mov r1, #0 1d2b0: ebffcfed bl 1126c <rtems_rfs_trace> 1d2b4: e3500000 cmp r0, #0
1d2b8: 0a000007 beq 1d2dc <rtems_rfs_buffer_bdbuf_release+0x40>
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
1d2bc: e59fc040 ldr ip, [pc, #64] ; 1d304 <rtems_rfs_buffer_bdbuf_release+0x68><== NOT EXECUTED 1d2c0: e3550000 cmp r5, #0 <== NOT EXECUTED 1d2c4: e59f303c ldr r3, [pc, #60] ; 1d308 <rtems_rfs_buffer_bdbuf_release+0x6c><== NOT EXECUTED 1d2c8: e59f003c ldr r0, [pc, #60] ; 1d30c <rtems_rfs_buffer_bdbuf_release+0x70><== NOT EXECUTED 1d2cc: e5941034 ldr r1, [r4, #52] ; 0x34 <== NOT EXECUTED 1d2d0: e5942018 ldr r2, [r4, #24] <== NOT EXECUTED 1d2d4: 01a0300c moveq r3, ip <== NOT EXECUTED 1d2d8: eb0005d3 bl 1ea2c <printf> <== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
1d2dc: e3550000 cmp r5, #0
sc = rtems_bdbuf_release_modified (buffer);
1d2e0: e1a00004 mov r0, r4
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)
1d2e4: 0a000001 beq 1d2f0 <rtems_rfs_buffer_bdbuf_release+0x54>
sc = rtems_bdbuf_release_modified (buffer);
1d2e8: ebffd83c bl 133e0 <rtems_bdbuf_release_modified> 1d2ec: ea000000 b 1d2f4 <rtems_rfs_buffer_bdbuf_release+0x58>
else
sc = rtems_bdbuf_release (buffer);
1d2f0: ebffd80c bl 13328 <rtems_bdbuf_release>
#endif
rc = EIO;
}
return rc;
}
1d2f4: e3500000 cmp r0, #0
1d2f8: 13a00005 movne r0, #5
1d2fc: 03a00000 moveq r0, #0
1d300: e8bd8030 pop {r4, r5, pc}
00018cf4 <rtems_rfs_buffer_close>:
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
18cf4: e92d4030 push {r4, r5, lr}
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
18cf8: e3a01000 mov r1, #0
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
18cfc: e1a05000 mov r5, r0
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
18d00: e3a00010 mov r0, #16 18d04: ebffe158 bl 1126c <rtems_rfs_trace> 18d08: e3500000 cmp r0, #0
printf ("rtems-rfs: buffer-close: closing\n");
18d0c: 159f0090 ldrne r0, [pc, #144] ; 18da4 <rtems_rfs_buffer_close+0xb0> 18d10: 1b0017dd blne 1ec8c <puts>
/*
* 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));
18d14: e5953010 ldr r3, [r5, #16] 18d18: e1a00005 mov r0, r5 18d1c: e5931020 ldr r1, [r3, #32] 18d20: ebffffbc bl 18c18 <rtems_rfs_buffer_setblksize>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
18d24: e2504000 subs r4, r0, #0
18d28: da00000a ble 18d58 <rtems_rfs_buffer_close+0x64>
18d2c: e3a00010 mov r0, #16 <== NOT EXECUTED 18d30: e3a01000 mov r1, #0 <== NOT EXECUTED 18d34: ebffe14c bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 18d38: e3500000 cmp r0, #0 <== NOT EXECUTED 18d3c: 0a000005 beq 18d58 <rtems_rfs_buffer_close+0x64> <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
18d40: e1a00004 mov r0, r4 <== NOT EXECUTED 18d44: eb001be6 bl 1fce4 <strerror> <== NOT EXECUTED 18d48: e1a01004 mov r1, r4 <== NOT EXECUTED 18d4c: e1a02000 mov r2, r0 <== NOT EXECUTED 18d50: e59f0050 ldr r0, [pc, #80] ; 18da8 <rtems_rfs_buffer_close+0xb4><== NOT EXECUTED 18d54: eb001734 bl 1ea2c <printf> <== NOT EXECUTED
rc, strerror (rc));
if (close (fs->device) < 0)
18d58: e595000c ldr r0, [r5, #12] 18d5c: ebffb609 bl 6588 <close> 18d60: e3500000 cmp r0, #0
18d64: aa00000c bge 18d9c <rtems_rfs_buffer_close+0xa8>
{
rc = errno;
18d68: eb001219 bl 1d5d4 <__errno> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
18d6c: e3a01000 mov r1, #0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
rc, strerror (rc));
if (close (fs->device) < 0)
{
rc = errno;
18d70: e5904000 ldr r4, [r0] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
18d74: e3a00010 mov r0, #16 <== NOT EXECUTED 18d78: ebffe13b bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 18d7c: e3500000 cmp r0, #0 <== NOT EXECUTED 18d80: 0a000005 beq 18d9c <rtems_rfs_buffer_close+0xa8> <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
18d84: e1a00004 mov r0, r4 <== NOT EXECUTED 18d88: eb001bd5 bl 1fce4 <strerror> <== NOT EXECUTED 18d8c: e1a01004 mov r1, r4 <== NOT EXECUTED 18d90: e1a02000 mov r2, r0 <== NOT EXECUTED 18d94: e59f0010 ldr r0, [pc, #16] ; 18dac <rtems_rfs_buffer_close+0xb8><== NOT EXECUTED 18d98: eb001723 bl 1ea2c <printf> <== NOT EXECUTED
rc, strerror (rc));
}
return rc;
}
18d9c: e1a00004 mov r0, r4
18da0: e8bd8030 pop {r4, r5, pc}
000185bc <rtems_rfs_buffer_handle_release>:
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
185bc: e92d40f1 push {r0, r4, r5, r6, r7, lr}
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
185c0: e5916008 ldr r6, [r1, #8] 185c4: e3560000 cmp r6, #0
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
185c8: e1a04000 mov r4, r0 185cc: e1a05001 mov r5, r1
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
185d0: 0a00005e beq 18750 <rtems_rfs_buffer_handle_release+0x194>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
185d4: e3a00c02 mov r0, #512 ; 0x200 185d8: e3a01000 mov r1, #0 185dc: ebffe322 bl 1126c <rtems_rfs_trace> 185e0: e3500000 cmp r0, #0
185e4: 0a00000d beq 18620 <rtems_rfs_buffer_handle_release+0x64>
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
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" : "");
185e8: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 185ec: e5933030 ldr r3, [r3, #48] ; 0x30 <== NOT EXECUTED
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
185f0: e59fc160 ldr ip, [pc, #352] ; 18758 <rtems_rfs_buffer_handle_release+0x19c><== NOT EXECUTED 185f4: e5d5e000 ldrb lr, [r5] <== NOT EXECUTED 185f8: e59f215c ldr r2, [pc, #348] ; 1875c <rtems_rfs_buffer_handle_release+0x1a0><== NOT EXECUTED 185fc: e3530000 cmp r3, #0 <== NOT EXECUTED 18600: 11a0200c movne r2, ip <== NOT EXECUTED 18604: e35e0000 cmp lr, #0 <== NOT EXECUTED 18608: e58d2000 str r2, [sp] <== NOT EXECUTED 1860c: e5951004 ldr r1, [r5, #4] <== NOT EXECUTED 18610: e59f2148 ldr r2, [pc, #328] ; 18760 <rtems_rfs_buffer_handle_release+0x1a4><== NOT EXECUTED 18614: e59f0148 ldr r0, [pc, #328] ; 18764 <rtems_rfs_buffer_handle_release+0x1a8><== NOT EXECUTED 18618: 01a0200c moveq r2, ip <== NOT EXECUTED 1861c: eb001902 bl 1ea2c <printf> <== 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)
18620: e5950008 ldr r0, [r5, #8] 18624: e5903030 ldr r3, [r0, #48] ; 0x30 18628: e3530000 cmp r3, #0
rtems_rfs_buffer_refs_down (handle);
1862c: c2433001 subgt r3, r3, #1 18630: c5803030 strgt r3, [r0, #48] ; 0x30
if (rtems_rfs_buffer_refs (handle) == 0)
18634: e5907030 ldr r7, [r0, #48] ; 0x30 18638: e3570000 cmp r7, #0
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
int rc = 0;
1863c: 13a06000 movne r6, #0
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
if (rtems_rfs_buffer_refs (handle) > 0)
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
18640: 1a000040 bne 18748 <rtems_rfs_buffer_handle_release+0x18c>
18644: ebfff4c1 bl 15950 <_Chain_Extract>
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
18648: e5943050 ldr r3, [r4, #80] ; 0x50
if (rtems_rfs_fs_no_local_cache (fs))
1864c: e5946000 ldr r6, [r4]
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
18650: e2433001 sub r3, r3, #1
if (rtems_rfs_fs_no_local_cache (fs))
18654: e2166002 ands r6, r6, #2
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
18658: e5843050 str r3, [r4, #80] ; 0x50
if (rtems_rfs_fs_no_local_cache (fs))
1865c: 0a000005 beq 18678 <rtems_rfs_buffer_handle_release+0xbc>
{
handle->buffer->user = (void*) 0;
18660: e5950008 ldr r0, [r5, #8]
rc = rtems_rfs_buffer_io_release (handle->buffer,
18664: e5d51000 ldrb r1, [r5]
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
if (rtems_rfs_fs_no_local_cache (fs))
{
handle->buffer->user = (void*) 0;
18668: e5807034 str r7, [r0, #52] ; 0x34
rc = rtems_rfs_buffer_io_release (handle->buffer,
1866c: eb00130a bl 1d29c <rtems_rfs_buffer_bdbuf_release> 18670: e1a06000 mov r6, r0 18674: ea000033 b 18748 <rtems_rfs_buffer_handle_release+0x18c>
* 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 +
18678: e5943060 ldr r3, [r4, #96] ; 0x60 1867c: e5942070 ldr r2, [r4, #112] ; 0x70 18680: e0822003 add r2, r2, r3 18684: e5943040 ldr r3, [r4, #64] ; 0x40 18688: e1520003 cmp r2, r3
1868c: 3a00001d bcc 18708 <rtems_rfs_buffer_handle_release+0x14c>
fs->release_modified_count) >= fs->max_held_buffers)
{
rtems_rfs_buffer* buffer;
bool modified;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
18690: e3a00c02 mov r0, #512 ; 0x200 18694: e3a01000 mov r1, #0 18698: ebffe2f3 bl 1126c <rtems_rfs_trace> 1869c: e3500000 cmp r0, #0
printf ("rtems-rfs: buffer-release: local cache overflow:"
186a0: 15941070 ldrne r1, [r4, #112] ; 0x70 186a4: 15943060 ldrne r3, [r4, #96] ; 0x60 186a8: 159f00b8 ldrne r0, [pc, #184] ; 18768 <rtems_rfs_buffer_handle_release+0x1ac> 186ac: 10811003 addne r1, r1, r3 186b0: 1b0018dd blne 1ea2c <printf>
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
186b4: e5942060 ldr r2, [r4, #96] ; 0x60 186b8: e5943070 ldr r3, [r4, #112] ; 0x70 186bc: e1520003 cmp r2, r3
186c0: 9a000006 bls 186e0 <rtems_rfs_buffer_handle_release+0x124>
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
186c4: e2840054 add r0, r4, #84 ; 0x54 186c8: ebffcc43 bl b7dc <_Chain_Get>
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
186cc: e5943060 ldr r3, [r4, #96] ; 0x60 186d0: e2433001 sub r3, r3, #1 186d4: e5843060 str r3, [r4, #96] ; 0x60
modified = false;
186d8: e3a01000 mov r1, #0 186dc: ea000005 b 186f8 <rtems_rfs_buffer_handle_release+0x13c> 186e0: e2840064 add r0, r4, #100 ; 0x64 186e4: ebffcc3c bl b7dc <_Chain_Get>
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
186e8: e5943070 ldr r3, [r4, #112] ; 0x70 186ec: e2433001 sub r3, r3, #1 186f0: e5843070 str r3, [r4, #112] ; 0x70
modified = true;
186f4: e3a01001 mov r1, #1
}
buffer->user = (void*) 0;
186f8: e3a03000 mov r3, #0 186fc: e5803034 str r3, [r0, #52] ; 0x34
rc = rtems_rfs_buffer_io_release (buffer, modified);
18700: eb0012e5 bl 1d29c <rtems_rfs_buffer_bdbuf_release> 18704: e1a06000 mov r6, r0
}
if (rtems_rfs_buffer_dirty (handle))
18708: e5d53000 ldrb r3, [r5] 1870c: e3530000 cmp r3, #0
18710: 0a000006 beq 18730 <rtems_rfs_buffer_handle_release+0x174>
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
18714: e2840064 add r0, r4, #100 ; 0x64 18718: e5951008 ldr r1, [r5, #8] 1871c: ebffcc23 bl b7b0 <_Chain_Append>
{
rtems_chain_append (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
18720: e5943070 ldr r3, [r4, #112] ; 0x70 18724: e2833001 add r3, r3, #1 18728: e5843070 str r3, [r4, #112] ; 0x70 1872c: ea000005 b 18748 <rtems_rfs_buffer_handle_release+0x18c> 18730: e2840054 add r0, r4, #84 ; 0x54 18734: e5951008 ldr r1, [r5, #8] 18738: ebffcc1c bl b7b0 <_Chain_Append>
}
else
{
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
1873c: e5943060 ldr r3, [r4, #96] ; 0x60 18740: e2833001 add r3, r3, #1 18744: e5843060 str r3, [r4, #96] ; 0x60
}
}
}
handle->buffer = NULL;
18748: e3a03000 mov r3, #0 1874c: e5853008 str r3, [r5, #8]
}
return rc;
}
18750: e1a00006 mov r0, r6
18754: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
0001876c <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)
{
1876c: e92d45f1 push {r0, r4, r5, r6, r7, r8, sl, lr}
18770: e203a0ff and sl, r3, #255 ; 0xff
/*
* 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))
18774: e5913008 ldr r3, [r1, #8] 18778: e3530000 cmp r3, #0
int
rtems_rfs_buffer_handle_request (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle,
rtems_rfs_buffer_block block,
bool read)
{
1877c: e1a05000 mov r5, r0 18780: e1a04001 mov r4, r1 18784: e1a06002 mov r6, r2
/*
* 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))
18788: 0a000013 beq 187dc <rtems_rfs_buffer_handle_request+0x70>
{
/*
* Treat block 0 as special to handle the loading of the super block.
*/
if (block && (rtems_rfs_buffer_bnum (handle) == block))
1878c: e3520000 cmp r2, #0
18790: 0a000002 beq 187a0 <rtems_rfs_buffer_handle_request+0x34>
18794: e5913004 ldr r3, [r1, #4] 18798: e1530002 cmp r3, r2
1879c: 0a000080 beq 189a4 <rtems_rfs_buffer_handle_request+0x238>
return 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
187a0: e3a00c01 mov r0, #256 ; 0x100 187a4: e3a01000 mov r1, #0 187a8: ebffe2af bl 1126c <rtems_rfs_trace> 187ac: e3500000 cmp r0, #0
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
187b0: 159f01f8 ldrne r0, [pc, #504] ; 189b0 <rtems_rfs_buffer_handle_request+0x244> 187b4: 15941004 ldrne r1, [r4, #4] 187b8: 1b00189b blne 1ea2c <printf>
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
187bc: e1a00005 mov r0, r5 187c0: e1a01004 mov r1, r4 187c4: ebffff7c bl 185bc <rtems_rfs_buffer_handle_release>
if (rc > 0)
187c8: e2508000 subs r8, r0, #0
187cc: ca000075 bgt 189a8 <rtems_rfs_buffer_handle_request+0x23c>
return rc;
handle->dirty = false;
187d0: e3a03000 mov r3, #0 187d4: e5c43000 strb r3, [r4]
handle->bnum = 0;
187d8: e5843004 str r3, [r4, #4]
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
187dc: e3a00c01 mov r0, #256 ; 0x100 187e0: e3a01000 mov r1, #0 187e4: ebffe2a0 bl 1126c <rtems_rfs_trace> 187e8: e3500000 cmp r0, #0
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
187ec: 159f01c0 ldrne r0, [pc, #448] ; 189b4 <rtems_rfs_buffer_handle_request+0x248> 187f0: 11a01006 movne r1, r6 187f4: 1b00188c blne 1ea2c <printf>
* 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)
187f8: e5953050 ldr r3, [r5, #80] ; 0x50 187fc: e3530000 cmp r3, #0
18800: 0a00000f beq 18844 <rtems_rfs_buffer_handle_request+0xd8>
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
18804: e2850044 add r0, r5, #68 ; 0x44 18808: e2851050 add r1, r5, #80 ; 0x50 1880c: e1a02006 mov r2, r6 18810: ebffff31 bl 184dc <rtems_rfs_scan_chain>
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
18814: e3500000 cmp r0, #0
if (fs->buffers_count)
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
18818: e5840008 str r0, [r4, #8]
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
1881c: 0a000008 beq 18844 <rtems_rfs_buffer_handle_request+0xd8>
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
18820: e3a00c01 mov r0, #256 ; 0x100 18824: e3a01000 mov r1, #0 18828: ebffe28f bl 1126c <rtems_rfs_trace>
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
1882c: e3500000 cmp r0, #0
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
rtems_rfs_buffer_refs (handle) + 1);
18830: 15943008 ldrne r3, [r4, #8]
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
18834: 15931030 ldrne r1, [r3, #48] ; 0x30 18838: 159f0178 ldrne r0, [pc, #376] ; 189b8 <rtems_rfs_buffer_handle_request+0x24c> 1883c: 12811001 addne r1, r1, #1 18840: 1b001879 blne 1ea2c <printf>
/* * 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) &&
18844: e5953000 ldr r3, [r5] 18848: e3130002 tst r3, #2
1884c: 1a000018 bne 188b4 <rtems_rfs_buffer_handle_request+0x148>
18850: e5943008 ldr r3, [r4, #8] 18854: e3530000 cmp r3, #0
18858: 1a000015 bne 188b4 <rtems_rfs_buffer_handle_request+0x148>
!rtems_rfs_buffer_handle_has_block (handle))
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
1885c: e5953060 ldr r3, [r5, #96] ; 0x60 18860: e3530000 cmp r3, #0
18864: 0a000004 beq 1887c <rtems_rfs_buffer_handle_request+0x110>
handle->buffer = rtems_rfs_scan_chain (&fs->release,
18868: e2850054 add r0, r5, #84 ; 0x54 1886c: e2851060 add r1, r5, #96 ; 0x60 18870: e1a02006 mov r2, r6 18874: ebffff18 bl 184dc <rtems_rfs_scan_chain> 18878: e5840008 str r0, [r4, #8]
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
1887c: e5943008 ldr r3, [r4, #8] 18880: e3530000 cmp r3, #0
18884: 1a00000a bne 188b4 <rtems_rfs_buffer_handle_request+0x148>
18888: e5953070 ldr r3, [r5, #112] ; 0x70 1888c: e3530000 cmp r3, #0
18890: 0a000007 beq 188b4 <rtems_rfs_buffer_handle_request+0x148>
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
18894: e2850064 add r0, r5, #100 ; 0x64 18898: e2851070 add r1, r5, #112 ; 0x70 1889c: e1a02006 mov r2, r6 188a0: ebffff0d bl 184dc <rtems_rfs_scan_chain>
&fs->release_modified_count,
block);
/*
* If we found a buffer retain the dirty buffer state.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
188a4: e3500000 cmp r0, #0
rtems_rfs_buffer_mark_dirty (handle);
188a8: 13a03001 movne r3, #1
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
188ac: e5840008 str r0, [r4, #8]
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);
188b0: 15c43000 strbne r3, [r4]
}
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
188b4: e5947008 ldr r7, [r4, #8] 188b8: e3570000 cmp r7, #0
188bc: 1a00001c bne 18934 <rtems_rfs_buffer_handle_request+0x1c8>
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
188c0: e1a00005 mov r0, r5 188c4: e1a01006 mov r1, r6 188c8: e1a0200a mov r2, sl 188cc: e2843008 add r3, r4, #8 188d0: eb001265 bl 1d26c <rtems_rfs_buffer_bdbuf_request>
if (rc > 0)
188d4: e2508000 subs r8, r0, #0
188d8: da000012 ble 18928 <rtems_rfs_buffer_handle_request+0x1bc>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
188dc: e3a00c01 mov r0, #256 ; 0x100 <== NOT EXECUTED 188e0: e3a01000 mov r1, #0 <== NOT EXECUTED 188e4: ebffe260 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 188e8: e3500000 cmp r0, #0 <== NOT EXECUTED 188ec: 0a00002d beq 189a8 <rtems_rfs_buffer_handle_request+0x23c> <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
188f0: e59f30c4 ldr r3, [pc, #196] ; 189bc <rtems_rfs_buffer_handle_request+0x250><== NOT EXECUTED 188f4: e59f20c4 ldr r2, [pc, #196] ; 189c0 <rtems_rfs_buffer_handle_request+0x254><== NOT EXECUTED 188f8: e35a0000 cmp sl, #0 <== NOT EXECUTED 188fc: e1a00008 mov r0, r8 <== NOT EXECUTED 18900: 11a0a003 movne sl, r3 <== NOT EXECUTED 18904: 01a0a002 moveq sl, r2 <== NOT EXECUTED 18908: eb001cf5 bl 1fce4 <strerror> <== NOT EXECUTED 1890c: e1a01006 mov r1, r6 <== NOT EXECUTED 18910: e58d0000 str r0, [sp] <== NOT EXECUTED 18914: e1a0200a mov r2, sl <== NOT EXECUTED 18918: e1a03008 mov r3, r8 <== NOT EXECUTED 1891c: e59f00a0 ldr r0, [pc, #160] ; 189c4 <rtems_rfs_buffer_handle_request+0x258><== NOT EXECUTED 18920: eb001841 bl 1ea2c <printf> <== NOT EXECUTED 18924: ea00001f b 189a8 <rtems_rfs_buffer_handle_request+0x23c> <== NOT EXECUTED
block, read ? "read" : "get", rc, strerror (rc));
return rc;
}
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
18928: e5943008 ldr r3, [r4, #8]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
1892c: e5837004 str r7, [r3, #4] 18930: e5837000 str r7, [r3]
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
18934: e5941008 ldr r1, [r4, #8] 18938: e5913030 ldr r3, [r1, #48] ; 0x30 1893c: e2833001 add r3, r3, #1 18940: e5813030 str r3, [r1, #48] ; 0x30 18944: e2850044 add r0, r5, #68 ; 0x44 18948: ebffcb98 bl b7b0 <_Chain_Append>
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle)); fs->buffers_count++;
1894c: e5953050 ldr r3, [r5, #80] ; 0x50 18950: e2833001 add r3, r3, #1 18954: e5853050 str r3, [r5, #80] ; 0x50
handle->buffer->user = (void*) ((intptr_t) block);
18958: e5943008 ldr r3, [r4, #8]
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
1895c: e3a00c01 mov r0, #256 ; 0x100
*/
rtems_rfs_buffer_refs_up (handle);
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
handle->buffer->user = (void*) ((intptr_t) block);
18960: e5836034 str r6, [r3, #52] ; 0x34
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
18964: e3a01000 mov r1, #0
rtems_rfs_buffer_refs_up (handle);
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
18968: e5846004 str r6, [r4, #4]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
1896c: ebffe23e bl 1126c <rtems_rfs_trace> 18970: e2508000 subs r8, r0, #0
18974: 0a00000b beq 189a8 <rtems_rfs_buffer_handle_request+0x23c>
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
block, read ? "read" : "get", handle->buffer->block,
18978: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
1897c: e5932030 ldr r2, [r3, #48] ; 0x30 <== NOT EXECUTED 18980: e59fc038 ldr ip, [pc, #56] ; 189c0 <rtems_rfs_buffer_handle_request+0x254><== NOT EXECUTED 18984: e58d2000 str r2, [sp] <== NOT EXECUTED 18988: e35a0000 cmp sl, #0 <== NOT EXECUTED 1898c: e59f2028 ldr r2, [pc, #40] ; 189bc <rtems_rfs_buffer_handle_request+0x250><== NOT EXECUTED 18990: e59f0030 ldr r0, [pc, #48] ; 189c8 <rtems_rfs_buffer_handle_request+0x25c><== NOT EXECUTED 18994: e1a01006 mov r1, r6 <== NOT EXECUTED 18998: 01a0200c moveq r2, ip <== NOT EXECUTED 1899c: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED 189a0: eb001821 bl 1ea2c <printf> <== NOT EXECUTED
{
/*
* Treat block 0 as special to handle the loading of the super block.
*/
if (block && (rtems_rfs_buffer_bnum (handle) == block))
return 0;
189a4: e3a08000 mov r8, #0
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;
}
189a8: e1a00008 mov r0, r8
189ac: e8bd85f8 pop {r3, r4, r5, r6, r7, r8, sl, pc}
000189cc <rtems_rfs_buffer_open>:
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
189cc: e92d4030 push {r4, r5, lr}
189d0: e1a05000 mov r5, r0
189d4: e24dd048 sub sp, sp, #72 ; 0x48
189d8: e1a04001 mov r4, r1
struct stat st;
#if RTEMS_RFS_USE_LIBBLOCK
int rv;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
189dc: e3a00020 mov r0, #32 189e0: e3a01000 mov r1, #0 189e4: ebffe220 bl 1126c <rtems_rfs_trace> 189e8: e3500000 cmp r0, #0
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
189ec: 159f0124 ldrne r0, [pc, #292] ; 18b18 <rtems_rfs_buffer_open+0x14c> 189f0: 11a01005 movne r1, r5 189f4: 1b00180c blne 1ea2c <printf>
fs->device = open (name, O_RDWR);
189f8: e1a00005 mov r0, r5 189fc: e3a01002 mov r1, #2 18a00: ebffbb1f bl 7684 <open>
if (fs->device < 0)
18a04: e3500000 cmp r0, #0
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
fs->device = open (name, O_RDWR);
18a08: e584000c str r0, [r4, #12]
if (fs->device < 0)
18a0c: aa000006 bge 18a2c <rtems_rfs_buffer_open+0x60>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
18a10: e3a00008 mov r0, #8 <== NOT EXECUTED 18a14: e3a01000 mov r1, #0 <== NOT EXECUTED 18a18: ebffe213 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 18a1c: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
18a20: 159f00f4 ldrne r0, [pc, #244] ; 18b1c <rtems_rfs_buffer_open+0x150><== NOT EXECUTED
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
fs->device = open (name, O_RDWR);
if (fs->device < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
18a24: 0a000038 beq 18b0c <rtems_rfs_buffer_open+0x140> <== NOT EXECUTED 18a28: ea000029 b 18ad4 <rtems_rfs_buffer_open+0x108> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
return ENXIO;
}
if (fstat (fs->device, &st) < 0)
18a2c: e1a0100d mov r1, sp 18a30: ebffb79f bl 68b4 <fstat> 18a34: e3500000 cmp r0, #0
18a38: aa00000c bge 18a70 <rtems_rfs_buffer_open+0xa4>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
18a3c: e3a00008 mov r0, #8 <== NOT EXECUTED 18a40: e3a01000 mov r1, #0 <== NOT EXECUTED 18a44: ebffe208 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 18a48: e3500000 cmp r0, #0 <== NOT EXECUTED 18a4c: 0a00002e beq 18b0c <rtems_rfs_buffer_open+0x140> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
18a50: eb0012df bl 1d5d4 <__errno> <== NOT EXECUTED
}
if (fstat (fs->device, &st) < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
18a54: e5900000 ldr r0, [r0] <== NOT EXECUTED 18a58: eb001ca1 bl 1fce4 <strerror> <== NOT EXECUTED 18a5c: e1a01005 mov r1, r5 <== NOT EXECUTED 18a60: e1a02000 mov r2, r0 <== NOT EXECUTED 18a64: e59f00b4 ldr r0, [pc, #180] ; 18b20 <rtems_rfs_buffer_open+0x154><== NOT EXECUTED 18a68: eb0017ef bl 1ea2c <printf> <== NOT EXECUTED 18a6c: ea000026 b 18b0c <rtems_rfs_buffer_open+0x140> <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
/*
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
18a70: e59d300c ldr r3, [sp, #12] 18a74: e2033a0f and r3, r3, #61440 ; 0xf000 18a78: e3530a06 cmp r3, #24576 ; 0x6000
18a7c: 0a000008 beq 18aa4 <rtems_rfs_buffer_open+0xd8>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
18a80: e3a00008 mov r0, #8 <== NOT EXECUTED 18a84: e3a01000 mov r1, #0 <== NOT EXECUTED 18a88: ebffe1f7 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 18a8c: e3500000 cmp r0, #0 <== NOT EXECUTED 18a90: 0a00001d beq 18b0c <rtems_rfs_buffer_open+0x140> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
18a94: e1a01005 mov r1, r5 <== NOT EXECUTED 18a98: e59f0084 ldr r0, [pc, #132] ; 18b24 <rtems_rfs_buffer_open+0x158><== NOT EXECUTED 18a9c: eb0017e2 bl 1ea2c <printf> <== NOT EXECUTED 18aa0: ea000019 b 18b0c <rtems_rfs_buffer_open+0x140> <== NOT EXECUTED
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
18aa4: e594000c ldr r0, [r4, #12] 18aa8: e59f1078 ldr r1, [pc, #120] ; 18b28 <rtems_rfs_buffer_open+0x15c> 18aac: e2842010 add r2, r4, #16 18ab0: ebffb7c7 bl 69d4 <ioctl>
/*
* Check that device is registred as a block device and lock it.
*/
rv = rtems_disk_fd_get_disk_device (fs->device, &fs->disk);
if (rv != 0)
18ab4: e2505000 subs r5, r0, #0
18ab8: 0a000007 beq 18adc <rtems_rfs_buffer_open+0x110>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
18abc: e3a00008 mov r0, #8 <== NOT EXECUTED 18ac0: e3a01000 mov r1, #0 <== NOT EXECUTED 18ac4: ebffe1e8 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 18ac8: e3500000 cmp r0, #0 <== NOT EXECUTED 18acc: 0a00000e beq 18b0c <rtems_rfs_buffer_open+0x140> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
18ad0: e59f0054 ldr r0, [pc, #84] ; 18b2c <rtems_rfs_buffer_open+0x160><== NOT EXECUTED 18ad4: eb00186c bl 1ec8c <puts> <== NOT EXECUTED 18ad8: ea00000b b 18b0c <rtems_rfs_buffer_open+0x140> <== NOT EXECUTED
#else
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
18adc: e3a00020 mov r0, #32 18ae0: e3a01000 mov r1, #0 18ae4: ebffe1e0 bl 1126c <rtems_rfs_trace> 18ae8: e3500000 cmp r0, #0
18aec: 0a000007 beq 18b10 <rtems_rfs_buffer_open+0x144>
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
18af0: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
18af4: e283101c add r1, r3, #28 <== NOT EXECUTED
18af8: e59f0030 ldr r0, [pc, #48] ; 18b30 <rtems_rfs_buffer_open+0x164><== NOT EXECUTED
18afc: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
18b00: eb0017c9 bl 1ea2c <printf> <== NOT EXECUTED
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
18b04: e1a00005 mov r0, r5 <== NOT EXECUTED 18b08: ea000000 b 18b10 <rtems_rfs_buffer_open+0x144> <== NOT EXECUTED
rv = rtems_disk_fd_get_disk_device (fs->device, &fs->disk);
if (rv != 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
return ENXIO;
18b0c: e3a00006 mov r0, #6 <== 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;
}
18b10: e28dd048 add sp, sp, #72 ; 0x48
18b14: e8bd8030 pop {r4, r5, pc}
00018c18 <rtems_rfs_buffer_setblksize>:
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
18c18: e92d4031 push {r0, r4, r5, lr}
18c1c: e1a04000 mov r4, r0
18c20: e58d1000 str r1, [sp]
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
18c24: e3a00b01 mov r0, #1024 ; 0x400 18c28: e3a01000 mov r1, #0 18c2c: ebffe18e bl 1126c <rtems_rfs_trace> 18c30: e3500000 cmp r0, #0
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
18c34: 159f00a8 ldrne r0, [pc, #168] ; 18ce4 <rtems_rfs_buffer_setblksize+0xcc> 18c38: 159d1000 ldrne r1, [sp] 18c3c: 1b00177a blne 1ea2c <printf>
rc = rtems_rfs_buffers_release (fs);
18c40: e1a00004 mov r0, r4 18c44: ebffffd7 bl 18ba8 <rtems_rfs_buffers_release>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
18c48: e2505000 subs r5, r0, #0
18c4c: da00000a ble 18c7c <rtems_rfs_buffer_setblksize+0x64>
18c50: e3a00b01 mov r0, #1024 ; 0x400 <== NOT EXECUTED 18c54: e3a01000 mov r1, #0 <== NOT EXECUTED 18c58: ebffe183 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 18c5c: e3500000 cmp r0, #0 <== NOT EXECUTED 18c60: 0a000005 beq 18c7c <rtems_rfs_buffer_setblksize+0x64> <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
18c64: e1a00005 mov r0, r5 <== NOT EXECUTED 18c68: eb001c1d bl 1fce4 <strerror> <== NOT EXECUTED 18c6c: e1a01005 mov r1, r5 <== NOT EXECUTED 18c70: e1a02000 mov r2, r0 <== NOT EXECUTED 18c74: e59f006c ldr r0, [pc, #108] ; 18ce8 <rtems_rfs_buffer_setblksize+0xd0><== NOT EXECUTED 18c78: eb00176b bl 1ea2c <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
18c7c: e1a00004 mov r0, r4 18c80: ebffffab bl 18b34 <rtems_rfs_buffer_sync>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
18c84: e2505000 subs r5, r0, #0
18c88: da00000a ble 18cb8 <rtems_rfs_buffer_setblksize+0xa0>
18c8c: e3a00b01 mov r0, #1024 ; 0x400 <== NOT EXECUTED 18c90: e3a01000 mov r1, #0 <== NOT EXECUTED 18c94: ebffe174 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 18c98: e3500000 cmp r0, #0 <== NOT EXECUTED 18c9c: 0a000005 beq 18cb8 <rtems_rfs_buffer_setblksize+0xa0> <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
18ca0: e1a00005 mov r0, r5 <== NOT EXECUTED 18ca4: eb001c0e bl 1fce4 <strerror> <== NOT EXECUTED 18ca8: e1a01005 mov r1, r5 <== NOT EXECUTED 18cac: e1a02000 mov r2, r0 <== NOT EXECUTED 18cb0: e59f0034 ldr r0, [pc, #52] ; 18cec <rtems_rfs_buffer_setblksize+0xd4><== NOT EXECUTED 18cb4: eb00175c bl 1ea2c <printf> <== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
18cb8: e5943010 ldr r3, [r4, #16] 18cbc: e59f102c ldr r1, [pc, #44] ; 18cf0 <rtems_rfs_buffer_setblksize+0xd8> 18cc0: e1a00003 mov r0, r3 18cc4: e1a0200d mov r2, sp 18cc8: e1a0e00f mov lr, pc 18ccc: e593f038 ldr pc, [r3, #56] ; 0x38
if (rc < 0)
18cd0: e3500000 cmp r0, #0
18cd4: aa000001 bge 18ce0 <rtems_rfs_buffer_setblksize+0xc8>
rc = errno;
18cd8: eb00123d bl 1d5d4 <__errno> <== NOT EXECUTED 18cdc: e5900000 ldr r0, [r0] <== NOT EXECUTED
#endif return rc; }
18ce0: e8bd8038 pop {r3, r4, r5, pc}
00018b34 <rtems_rfs_buffer_sync>:
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
18b34: e92d4030 push {r4, r5, lr}
int result = 0;
#if RTEMS_RFS_USE_LIBBLOCK
rtems_status_code sc;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
18b38: e3a01000 mov r1, #0
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
18b3c: e1a04000 mov r4, r0
int result = 0;
#if RTEMS_RFS_USE_LIBBLOCK
rtems_status_code sc;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
18b40: e3a00020 mov r0, #32 18b44: ebffe1c8 bl 1126c <rtems_rfs_trace> 18b48: e3500000 cmp r0, #0
printf ("rtems-rfs: buffer-sync: syncing\n");
18b4c: 159f004c ldrne r0, [pc, #76] ; 18ba0 <rtems_rfs_buffer_sync+0x6c> 18b50: 1b00184d blne 1ec8c <puts>
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
18b54: e5940010 ldr r0, [r4, #16] 18b58: ebffea83 bl 1356c <rtems_bdbuf_syncdev>
if (sc != RTEMS_SUCCESSFUL)
18b5c: e2505000 subs r5, r0, #0
18b60: 0a00000a beq 18b90 <rtems_rfs_buffer_sync+0x5c>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
18b64: e3a00020 mov r0, #32 <== NOT EXECUTED 18b68: e3a01000 mov r1, #0 <== NOT EXECUTED 18b6c: ebffe1be bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 18b70: e3500000 cmp r0, #0 <== NOT EXECUTED 18b74: 0a000004 beq 18b8c <rtems_rfs_buffer_sync+0x58> <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
18b78: e1a00005 mov r0, r5 <== NOT EXECUTED 18b7c: ebffb69f bl 6600 <rtems_status_text> <== NOT EXECUTED 18b80: e1a01000 mov r1, r0 <== NOT EXECUTED 18b84: e59f0018 ldr r0, [pc, #24] ; 18ba4 <rtems_rfs_buffer_sync+0x70><== NOT EXECUTED 18b88: eb0017a7 bl 1ea2c <printf> <== NOT EXECUTED
rtems_status_text (sc));
result = EIO;
18b8c: e3a05005 mov r5, #5 <== NOT EXECUTED
} rtems_disk_release (fs->disk);
18b90: e5940010 ldr r0, [r4, #16] 18b94: ebffa9bc bl 328c <rtems_disk_release>
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
18b98: e1a00005 mov r0, r5
18b9c: e8bd8030 pop {r4, r5, pc}
00019278 <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)
{
19278: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1927c: e1a04000 mov r4, r0
19280: e24dd074 sub sp, sp, #116 ; 0x74
19284: e1a06001 mov r6, r1
rtems_rfs_block_map map;
rtems_rfs_block_pos bpos;
rtems_rfs_buffer_handle buffer;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
19288: e3a00202 mov r0, #536870912 ; 0x20000000 1928c: e3a01000 mov r1, #0
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)
{
19290: e58d2004 str r2, [sp, #4] 19294: e1a07003 mov r7, r3 19298: e59da098 ldr sl, [sp, #152] ; 0x98
rtems_rfs_block_map map;
rtems_rfs_block_pos bpos;
rtems_rfs_buffer_handle buffer;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
1929c: ebffdff2 bl 1126c <rtems_rfs_trace> 192a0: e3500000 cmp r0, #0
192a4: 0a00000d beq 192e0 <rtems_rfs_dir_add_entry+0x68>
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
192a8: e59f0328 ldr r0, [pc, #808] ; 195d8 <rtems_rfs_dir_add_entry+0x360><== NOT EXECUTED 192ac: e5961008 ldr r1, [r6, #8] <== NOT EXECUTED 192b0: eb0015dd bl 1ea2c <printf> <== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
192b4: e3a05000 mov r5, #0 <== NOT EXECUTED 192b8: ea000003 b 192cc <rtems_rfs_dir_add_entry+0x54> <== NOT EXECUTED
printf ("%c", name[c]);
192bc: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 192c0: e7d30005 ldrb r0, [r3, r5] <== NOT EXECUTED 192c4: eb001642 bl 1ebd4 <putchar> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
192c8: e2855001 add r5, r5, #1 <== NOT EXECUTED 192cc: e1550007 cmp r5, r7 <== NOT EXECUTED 192d0: 1afffff9 bne 192bc <rtems_rfs_dir_add_entry+0x44> <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%zd\n", length);
192d4: e59f0300 ldr r0, [pc, #768] ; 195dc <rtems_rfs_dir_add_entry+0x364><== NOT EXECUTED 192d8: e1a01007 mov r1, r7 <== NOT EXECUTED 192dc: eb0015d2 bl 1ea2c <printf> <== NOT EXECUTED
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
192e0: e28d8008 add r8, sp, #8 192e4: e1a00004 mov r0, r4 192e8: e1a01006 mov r1, r6 192ec: e1a02008 mov r2, r8 192f0: ebfff968 bl 17898 <rtems_rfs_block_map_open>
if (rc > 0)
192f4: e2505000 subs r5, r0, #0
192f8: ca0000b3 bgt 195cc <rtems_rfs_dir_add_entry+0x354>
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
192fc: e3a03000 mov r3, #0 19300: e5cd3064 strb r3, [sp, #100] ; 0x64
handle->bnum = 0;
19304: e58d3068 str r3, [sp, #104] ; 0x68
handle->buffer = NULL;
19308: e58d306c str r3, [sp, #108] ; 0x6c
* @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;
1930c: e58d3058 str r3, [sp, #88] ; 0x58
bpos->boff = 0;
19310: e58d305c str r3, [sp, #92] ; 0x5c
bpos->block = 0;
19314: e58d3060 str r3, [sp, #96] ; 0x60
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
19318: e1a0b006 mov fp, r6
/*
* 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);
1931c: e1a00004 mov r0, r4 19320: e28d1008 add r1, sp, #8 19324: e28d2058 add r2, sp, #88 ; 0x58 19328: e28d3070 add r3, sp, #112 ; 0x70 1932c: ebfffa25 bl 17bc8 <rtems_rfs_block_map_find>
if (rc > 0)
19330: e2505000 subs r5, r0, #0
19334: da000023 ble 193c8 <rtems_rfs_dir_add_entry+0x150>
{
if (rc != ENXIO)
19338: e3550006 cmp r5, #6
1933c: 0a00000b beq 19370 <rtems_rfs_dir_add_entry+0xf8>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
19340: e3a00202 mov r0, #536870912 ; 0x20000000 <== NOT EXECUTED 19344: e3a01000 mov r1, #0 <== NOT EXECUTED 19348: ebffdfc7 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1934c: e3500000 cmp r0, #0 <== NOT EXECUTED 19350: e1a0600b mov r6, fp <== NOT EXECUTED 19354: 0a000096 beq 195b4 <rtems_rfs_dir_add_entry+0x33c> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
19358: e1a00005 mov r0, r5 <== NOT EXECUTED 1935c: e59b6008 ldr r6, [fp, #8] <== NOT EXECUTED 19360: eb001a5f bl 1fce4 <strerror> <== NOT EXECUTED 19364: e1a03000 mov r3, r0 <== NOT EXECUTED 19368: e59f0270 ldr r0, [pc, #624] ; 195e0 <rtems_rfs_dir_add_entry+0x368><== NOT EXECUTED 1936c: ea000011 b 193b8 <rtems_rfs_dir_add_entry+0x140> <== NOT EXECUTED
}
/*
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
19370: e1a00004 mov r0, r4 19374: e28d1008 add r1, sp, #8 19378: e3a02001 mov r2, #1 1937c: e28d3070 add r3, sp, #112 ; 0x70 19380: ebfffa8e bl 17dc0 <rtems_rfs_block_map_grow>
if (rc > 0)
19384: e2505000 subs r5, r0, #0
19388: da000010 ble 193d0 <rtems_rfs_dir_add_entry+0x158>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
1938c: e3a00202 mov r0, #536870912 ; 0x20000000 <== NOT EXECUTED 19390: e3a01000 mov r1, #0 <== NOT EXECUTED 19394: ebffdfb4 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 19398: e3500000 cmp r0, #0 <== NOT EXECUTED 1939c: e1a0600b mov r6, fp <== NOT EXECUTED 193a0: 0a000083 beq 195b4 <rtems_rfs_dir_add_entry+0x33c> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
193a4: e1a00005 mov r0, r5 <== NOT EXECUTED 193a8: e59b6008 ldr r6, [fp, #8] <== NOT EXECUTED 193ac: eb001a4c bl 1fce4 <strerror> <== NOT EXECUTED 193b0: e1a03000 mov r3, r0 <== NOT EXECUTED 193b4: e59f0228 ldr r0, [pc, #552] ; 195e4 <rtems_rfs_dir_add_entry+0x36c><== NOT EXECUTED 193b8: e1a01006 mov r1, r6 <== NOT EXECUTED 193bc: e1a02005 mov r2, r5 <== NOT EXECUTED 193c0: eb001599 bl 1ea2c <printf> <== NOT EXECUTED 193c4: ea00007a b 195b4 <rtems_rfs_dir_add_entry+0x33c> <== NOT EXECUTED
while (true)
{
rtems_rfs_block_no block;
uint8_t* entry;
int offset;
bool read = true;
193c8: e3a06001 mov r6, #1 193cc: ea000000 b 193d4 <rtems_rfs_dir_add_entry+0x15c>
"block map grow failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
break;
}
read = false;
193d0: e3a06000 mov r6, #0
}
bpos.bno++;
193d4: e59d3058 ldr r3, [sp, #88] ; 0x58 193d8: e2833001 add r3, r3, #1 193dc: e58d3058 str r3, [sp, #88] ; 0x58
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
193e0: e1a00004 mov r0, r4 193e4: e28d1064 add r1, sp, #100 ; 0x64 193e8: e59d2070 ldr r2, [sp, #112] ; 0x70 193ec: e1a03006 mov r3, r6 193f0: ebfffcdd bl 1876c <rtems_rfs_buffer_handle_request>
if (rc > 0)
193f4: e2505000 subs r5, r0, #0
193f8: da00000b ble 1942c <rtems_rfs_dir_add_entry+0x1b4>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
193fc: e3a00202 mov r0, #536870912 ; 0x20000000 <== NOT EXECUTED 19400: e3a01000 mov r1, #0 <== NOT EXECUTED 19404: ebffdf98 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 19408: e3500000 cmp r0, #0 <== NOT EXECUTED 1940c: e1a0600b mov r6, fp <== NOT EXECUTED 19410: 0a000067 beq 195b4 <rtems_rfs_dir_add_entry+0x33c> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
19414: e1a00005 mov r0, r5 <== NOT EXECUTED 19418: e59b6008 ldr r6, [fp, #8] <== NOT EXECUTED 1941c: eb001a30 bl 1fce4 <strerror> <== NOT EXECUTED 19420: e1a03000 mov r3, r0 <== NOT EXECUTED 19424: e59f01bc ldr r0, [pc, #444] ; 195e8 <rtems_rfs_dir_add_entry+0x370><== NOT EXECUTED 19428: eaffffe2 b 193b8 <rtems_rfs_dir_add_entry+0x140> <== 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);
1942c: e59d306c ldr r3, [sp, #108] ; 0x6c
if (!read)
19430: e3560000 cmp r6, #0
"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);
19434: e593501c ldr r5, [r3, #28]
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
19438: 01a00005 moveq r0, r5 1943c: 03a010ff moveq r1, #255 ; 0xff 19440: 05942008 ldreq r2, [r4, #8] 19444: 0b001507 bleq 1e868 <memset>
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
19448: e5942008 ldr r2, [r4, #8]
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
1944c: e3a03000 mov r3, #0
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
19450: e242100a sub r1, r2, #10 19454: ea000053 b 195a8 <rtems_rfs_dir_add_entry+0x330>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
19458: e5d50009 ldrb r0, [r5, #9] 1945c: e5d59008 ldrb r9, [r5, #8]
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
19460: e59f6184 ldr r6, [pc, #388] ; 195ec <rtems_rfs_dir_add_entry+0x374>
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);
19464: e1809409 orr r9, r0, r9, lsl #8
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
19468: e1590006 cmp r9, r6
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
1946c: e5d5e000 ldrb lr, [r5] 19470: e5d58001 ldrb r8, [r5, #1] 19474: e5d50002 ldrb r0, [r5, #2] 19478: e5d5c003 ldrb ip, [r5, #3]
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1947c: 1a000025 bne 19518 <rtems_rfs_dir_add_entry+0x2a0>
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
19480: e287800a add r8, r7, #10
(rtems_rfs_fs_block_size (fs) - offset))
19484: e0633002 rsb r3, r3, r2
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) <
19488: e1580003 cmp r8, r3
1948c: 2affffa2 bcs 1931c <rtems_rfs_dir_add_entry+0xa4>
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
19490: e1a01007 mov r1, r7 19494: e59d0004 ldr r0, [sp, #4] 19498: eb000f9c bl 1d310 <rtems_rfs_dir_hash>
rtems_rfs_dir_set_entry_hash (entry, hash);
1949c: e1a03c20 lsr r3, r0, #24 194a0: e5c53004 strb r3, [r5, #4] 194a4: e1a03820 lsr r3, r0, #16 194a8: e5c53005 strb r3, [r5, #5] 194ac: e1a03420 lsr r3, r0, #8 194b0: e5c53006 strb r3, [r5, #6]
rtems_rfs_dir_set_entry_ino (entry, ino);
194b4: e1a03c2a lsr r3, sl, #24 194b8: e5c53000 strb r3, [r5] 194bc: e1a0382a lsr r3, sl, #16 194c0: e5c53001 strb r3, [r5, #1] 194c4: e1a0342a lsr r3, sl, #8 194c8: e5c53002 strb r3, [r5, #2]
rtems_rfs_dir_set_entry_length (entry,
194cc: e1a03428 lsr r3, r8, #8
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);
194d0: e5c50007 strb r0, [r5, #7]
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
194d4: e5c53008 strb r3, [r5, #8]
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
194d8: e1a02007 mov r2, r7
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
194dc: e5c5a003 strb sl, [r5, #3]
rtems_rfs_dir_set_entry_length (entry,
194e0: e5c58009 strb r8, [r5, #9]
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
194e4: e285000a add r0, r5, #10 194e8: e59d1004 ldr r1, [sp, #4] 194ec: eb00145a bl 1e65c <memcpy>
rtems_rfs_buffer_mark_dirty (&buffer);
194f0: e28d1074 add r1, sp, #116 ; 0x74 194f4: e3a03001 mov r3, #1 194f8: e5613010 strb r3, [r1, #-16]!
rtems_rfs_buffer_handle_close (fs, &buffer);
194fc: e1a00004 mov r0, r4 19500: ebfffe2a bl 18db0 <rtems_rfs_buffer_handle_close>
rtems_rfs_block_map_close (fs, &map);
19504: e1a00004 mov r0, r4 19508: e28d1008 add r1, sp, #8 1950c: ebfff93a bl 179fc <rtems_rfs_block_map_close>
return 0;
19510: e3a05000 mov r5, #0 19514: ea00002c b 195cc <rtems_rfs_dir_add_entry+0x354>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
19518: e1a08808 lsl r8, r8, #16 1951c: e1888c0e orr r8, r8, lr, lsl #24 19520: e188800c orr r8, r8, ip
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
19524: e359000a cmp r9, #10
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
19528: e1888400 orr r8, r8, r0, lsl #8
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
1952c: da000006 ble 1954c <rtems_rfs_dir_add_entry+0x2d4>
19530: e594001c ldr r0, [r4, #28] 19534: e3580000 cmp r8, #0 19538: 11590000 cmpne r9, r0
1953c: 2a000002 bcs 1954c <rtems_rfs_dir_add_entry+0x2d4>
19540: e5940014 ldr r0, [r4, #20] 19544: e1580000 cmp r8, r0
19548: 9a000014 bls 195a0 <rtems_rfs_dir_add_entry+0x328>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
1954c: e3a00202 mov r0, #536870912 ; 0x20000000 <== NOT EXECUTED 19550: e3a01000 mov r1, #0 <== NOT EXECUTED 19554: e1a0600b mov r6, fp <== NOT EXECUTED 19558: e1a0b003 mov fp, r3 <== NOT EXECUTED 1955c: ebffdf42 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 19560: e3500000 cmp r0, #0 <== NOT EXECUTED 19564: 0a000005 beq 19580 <rtems_rfs_dir_add_entry+0x308> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
19568: e58db000 str fp, [sp] <== NOT EXECUTED 1956c: e59f007c ldr r0, [pc, #124] ; 195f0 <rtems_rfs_dir_add_entry+0x378><== NOT EXECUTED 19570: e5961008 ldr r1, [r6, #8] <== NOT EXECUTED 19574: e1a02009 mov r2, r9 <== NOT EXECUTED 19578: e1a03008 mov r3, r8 <== NOT EXECUTED 1957c: eb00152a bl 1ea2c <printf> <== NOT EXECUTED
"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);
19580: e28d1064 add r1, sp, #100 ; 0x64 <== NOT EXECUTED 19584: e1a00004 mov r0, r4 <== NOT EXECUTED 19588: ebfffe08 bl 18db0 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
1958c: e1a00004 mov r0, r4 <== NOT EXECUTED 19590: e28d1008 add r1, sp, #8 <== NOT EXECUTED 19594: ebfff918 bl 179fc <rtems_rfs_block_map_close> <== NOT EXECUTED
return EIO;
19598: e3a05005 mov r5, #5 <== NOT EXECUTED 1959c: ea00000a b 195cc <rtems_rfs_dir_add_entry+0x354> <== NOT EXECUTED
}
entry += elength;
195a0: e0855009 add r5, r5, r9
offset += elength;
195a4: e0833009 add r3, r3, r9
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))
195a8: e1530001 cmp r3, r1
195ac: 3affffa9 bcc 19458 <rtems_rfs_dir_add_entry+0x1e0>
195b0: eaffff59 b 1931c <rtems_rfs_dir_add_entry+0xa4> <== NOT EXECUTED
entry += elength;
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
195b4: e28d1064 add r1, sp, #100 ; 0x64 <== NOT EXECUTED 195b8: e1a00004 mov r0, r4 <== NOT EXECUTED 195bc: ebfffdfb bl 18db0 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
195c0: e1a00004 mov r0, r4 <== NOT EXECUTED 195c4: e28d1008 add r1, sp, #8 <== NOT EXECUTED 195c8: ebfff90b bl 179fc <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc; }
195cc: e1a00005 mov r0, r5
195d0: e28dd074 add sp, sp, #116 ; 0x74
195d4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
000195f4 <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)
{
195f4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
195f8: e1a05000 mov r5, r0
195fc: e24dd074 sub sp, sp, #116 ; 0x74
19600: e1a09001 mov r9, r1
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
19604: e3a00101 mov r0, #1073741824 ; 0x40000000 19608: e3a01000 mov r1, #0
int
rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_ino ino,
uint32_t offset)
{
1960c: e58d2010 str r2, [sp, #16] 19610: e58d300c str r3, [sp, #12]
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
19614: ebffdf14 bl 1126c <rtems_rfs_trace> 19618: e3500000 cmp r0, #0
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
1961c: 159f0374 ldrne r0, [pc, #884] ; 19998 <rtems_rfs_dir_del_entry+0x3a4> 19620: 15991008 ldrne r1, [r9, #8] 19624: 159d2010 ldrne r2, [sp, #16] 19628: 159d300c ldrne r3, [sp, #12] 1962c: 1b0014fe blne 1ea2c <printf>
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
19630: e1a00005 mov r0, r5 19634: e1a01009 mov r1, r9 19638: e28d2014 add r2, sp, #20 1963c: ebfff895 bl 17898 <rtems_rfs_block_map_open>
if (rc > 0)
19640: e2504000 subs r4, r0, #0
19644: ca0000ce bgt 19984 <rtems_rfs_dir_del_entry+0x390>
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
19648: e28d3070 add r3, sp, #112 ; 0x70 1964c: e3a06000 mov r6, #0 19650: e58d3000 str r3, [sp] 19654: e1a00005 mov r0, r5 19658: e28d1014 add r1, sp, #20 1965c: e59d200c ldr r2, [sp, #12] 19660: e1a03006 mov r3, r6 19664: ebfff9ae bl 17d24 <rtems_rfs_block_map_seek>
if (rc > 0)
19668: e2504000 subs r4, r0, #0
1966c: da000002 ble 1967c <rtems_rfs_dir_del_entry+0x88>
{
if (rc == ENXIO)
rc = ENOENT;
19670: e3540006 cmp r4, #6 <== NOT EXECUTED 19674: 03a04002 moveq r4, #2 <== NOT EXECUTED 19678: ea0000a1 b 19904 <rtems_rfs_dir_del_entry+0x310> <== NOT EXECUTED
}
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
1967c: e59d200c ldr r2, [sp, #12] 19680: e2723001 rsbs r3, r2, #1 19684: 33a03000 movcc r3, #0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
19688: e5cd6064 strb r6, [sp, #100] ; 0x64
handle->bnum = 0;
1968c: e58d6068 str r6, [sp, #104] ; 0x68
handle->buffer = NULL;
19690: e58d606c str r6, [sp, #108] ; 0x6c
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
19694: e1a04006 mov r4, r6 19698: e1a0b003 mov fp, r3
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
1969c: ea0000ae b 1995c <rtems_rfs_dir_del_entry+0x368>
{
uint8_t* entry;
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
196a0: e1a00005 mov r0, r5 196a4: e28d1064 add r1, sp, #100 ; 0x64 196a8: e59d2070 ldr r2, [sp, #112] ; 0x70 196ac: e3a03001 mov r3, #1 196b0: ebfffc2d bl 1876c <rtems_rfs_buffer_handle_request>
if (rc > 0)
196b4: e2508000 subs r8, r0, #0
196b8: da00000e ble 196f8 <rtems_rfs_dir_del_entry+0x104>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
196bc: e3a00101 mov r0, #1073741824 ; 0x40000000 <== NOT EXECUTED 196c0: e3a01000 mov r1, #0 <== NOT EXECUTED 196c4: ebffdee8 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 196c8: e3500000 cmp r0, #0 <== NOT EXECUTED 196cc: e1a07008 mov r7, r8 <== NOT EXECUTED 196d0: 0a0000a4 beq 19968 <rtems_rfs_dir_del_entry+0x374> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
196d4: e1a00008 mov r0, r8 <== NOT EXECUTED 196d8: e5994008 ldr r4, [r9, #8] <== NOT EXECUTED 196dc: eb001980 bl 1fce4 <strerror> <== NOT EXECUTED 196e0: e1a01004 mov r1, r4 <== NOT EXECUTED 196e4: e1a03000 mov r3, r0 <== NOT EXECUTED 196e8: e1a02008 mov r2, r8 <== NOT EXECUTED 196ec: e59f02a8 ldr r0, [pc, #680] ; 1999c <rtems_rfs_dir_del_entry+0x3a8><== NOT EXECUTED 196f0: eb0014cd bl 1ea2c <printf> <== NOT EXECUTED 196f4: ea00009b b 19968 <rtems_rfs_dir_del_entry+0x374> <== 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)
196f8: e35b0000 cmp fp, #0
eoffset = 0;
196fc: 11a07004 movne r7, r4
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
19700: 1a000003 bne 19714 <rtems_rfs_dir_del_entry+0x120>
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
19704: e59d000c ldr r0, [sp, #12] 19708: e5951008 ldr r1, [r5, #8] 1970c: eb004639 bl 2aff8 <__umodsi3> 19710: e1a07000 mov r7, r0
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
19714: e59d306c ldr r3, [sp, #108] ; 0x6c 19718: e593201c ldr r2, [r3, #28]
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1971c: e5953008 ldr r3, [r5, #8]
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
19720: e0822007 add r2, r2, r7
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
19724: e243100a sub r1, r3, #10 19728: e58d3008 str r3, [sp, #8] 1972c: ea00007c b 19924 <rtems_rfs_dir_del_entry+0x330>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
19730: e5d20009 ldrb r0, [r2, #9] 19734: e5d2a008 ldrb sl, [r2, #8]
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
19738: e59f3260 ldr r3, [pc, #608] ; 199a0 <rtems_rfs_dir_del_entry+0x3ac>
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);
1973c: e180a40a orr sl, r0, sl, lsl #8
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
19740: e15a0003 cmp sl, r3
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
19744: e5d26000 ldrb r6, [r2] 19748: e5d2e001 ldrb lr, [r2, #1] 1974c: e5d20002 ldrb r0, [r2, #2] 19750: e5d2c003 ldrb ip, [r2, #3]
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
19754: 0a000074 beq 1992c <rtems_rfs_dir_del_entry+0x338>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
19758: e1a0e80e lsl lr, lr, #16 1975c: e18eec06 orr lr, lr, r6, lsl #24 19760: e18ee00c orr lr, lr, ip
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
19764: e35a000a cmp sl, #10
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
19768: e18e6400 orr r6, lr, r0, lsl #8
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
1976c: da000006 ble 1978c <rtems_rfs_dir_del_entry+0x198>
19770: e595001c ldr r0, [r5, #28] 19774: e3560000 cmp r6, #0 19778: 115a0000 cmpne sl, r0
1977c: 2a000002 bcs 1978c <rtems_rfs_dir_del_entry+0x198>
19780: e5950014 ldr r0, [r5, #20] 19784: e1560000 cmp r6, r0
19788: 9a00000c bls 197c0 <rtems_rfs_dir_del_entry+0x1cc>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
1978c: e3a00101 mov r0, #1073741824 ; 0x40000000 <== NOT EXECUTED 19790: e3a01000 mov r1, #0 <== NOT EXECUTED 19794: ebffdeb4 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 19798: e3500000 cmp r0, #0 <== NOT EXECUTED 1979c: 0a00007b beq 19990 <rtems_rfs_dir_del_entry+0x39c> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
197a0: e59d3070 ldr r3, [sp, #112] ; 0x70 <== NOT EXECUTED
197a4: e5991008 ldr r1, [r9, #8] <== NOT EXECUTED
197a8: e88d0088 stm sp, {r3, r7} <== NOT EXECUTED
197ac: e1a0200a mov r2, sl <== NOT EXECUTED
197b0: e1a03006 mov r3, r6 <== NOT EXECUTED
197b4: e59f01e8 ldr r0, [pc, #488] ; 199a4 <rtems_rfs_dir_del_entry+0x3b0><== NOT EXECUTED
197b8: eb00149b bl 1ea2c <printf> <== NOT EXECUTED
197bc: ea000073 b 19990 <rtems_rfs_dir_del_entry+0x39c> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
rc = EIO;
break;
}
if (ino == rtems_rfs_dir_entry_ino (entry))
197c0: e59d3010 ldr r3, [sp, #16] 197c4: e1530006 cmp r3, r6
197c8: 1a000051 bne 19914 <rtems_rfs_dir_del_entry+0x320>
197cc: e59d3008 ldr r3, [sp, #8] 197d0: e1a06007 mov r6, r7
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
197d4: e087700a add r7, r7, sl 197d8: e0677003 rsb r7, r7, r3 197dc: e1a08002 mov r8, r2
memmove (entry, entry + elength, remaining);
197e0: e082100a add r1, r2, sl 197e4: e1a00002 mov r0, r2 197e8: e1a02007 mov r2, r7 197ec: eb0013d0 bl 1e734 <memmove>
memset (entry + remaining, 0xff, elength);
197f0: e0880007 add r0, r8, r7 197f4: e3a010ff mov r1, #255 ; 0xff 197f8: e1a0200a mov r2, sl 197fc: eb001419 bl 1e868 <memset>
* 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);
19800: e5d87008 ldrb r7, [r8, #8] 19804: e5d83009 ldrb r3, [r8, #9]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
19808: e3a00101 mov r0, #1073741824 ; 0x40000000 1980c: e3a01000 mov r1, #0
* 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);
19810: e1837407 orr r7, r3, r7, lsl #8
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
19814: ebffde94 bl 1126c <rtems_rfs_trace> 19818: e3500000 cmp r0, #0
1981c: 0a000013 beq 19870 <rtems_rfs_dir_del_entry+0x27c>
printf ("rtems-rfs: dir-del-entry: "
"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");
19820: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
19824: e3510000 cmp r1, #0 <== NOT EXECUTED 19828: e59d3070 ldr r3, [sp, #112] ; 0x70 <== NOT EXECUTED 1982c: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED 19830: 1a000002 bne 19840 <rtems_rfs_dir_del_entry+0x24c> <== 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");
19834: e3520000 cmp r2, #0 <== NOT EXECUTED
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
19838: 059f2168 ldreq r2, [pc, #360] ; 199a8 <rtems_rfs_dir_del_entry+0x3b4><== 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");
1983c: 0a000005 beq 19858 <rtems_rfs_dir_del_entry+0x264> <== NOT EXECUTED 19840: e2422001 sub r2, r2, #1 <== NOT EXECUTED
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
19844: e59f015c ldr r0, [pc, #348] ; 199a8 <rtems_rfs_dir_del_entry+0x3b4><== NOT EXECUTED 19848: e59fc15c ldr ip, [pc, #348] ; 199ac <rtems_rfs_dir_del_entry+0x3b8><== NOT EXECUTED 1984c: e1510002 cmp r1, r2 <== NOT EXECUTED 19850: 11a0200c movne r2, ip <== NOT EXECUTED 19854: 01a02000 moveq r2, r0 <== NOT EXECUTED 19858: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 1985c: e59f014c ldr r0, [pc, #332] ; 199b0 <rtems_rfs_dir_del_entry+0x3bc><== NOT EXECUTED 19860: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 19864: e1a02007 mov r2, r7 <== NOT EXECUTED 19868: e58d6000 str r6, [sp] <== NOT EXECUTED 1986c: eb00146e bl 1ea2c <printf> <== 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) &&
19870: e59f3128 ldr r3, [pc, #296] ; 199a0 <rtems_rfs_dir_del_entry+0x3ac> 19874: e1570003 cmp r7, r3 19878: 03560000 cmpeq r6, #0
1987c: 1a00001b bne 198f0 <rtems_rfs_dir_del_entry+0x2fc>
(eoffset == 0) && rtems_rfs_block_map_last (&map))
19880: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 19884: e3530000 cmp r3, #0 <== NOT EXECUTED 19888: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED 1988c: 1a000001 bne 19898 <rtems_rfs_dir_del_entry+0x2a4> <== NOT EXECUTED 19890: e3520000 cmp r2, #0 <== NOT EXECUTED 19894: 0a000002 beq 198a4 <rtems_rfs_dir_del_entry+0x2b0> <== NOT EXECUTED 19898: e2422001 sub r2, r2, #1 <== NOT EXECUTED 1989c: e1530002 cmp r3, r2 <== NOT EXECUTED 198a0: 1a000012 bne 198f0 <rtems_rfs_dir_del_entry+0x2fc> <== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
198a4: e1a00005 mov r0, r5 <== NOT EXECUTED 198a8: e28d1014 add r1, sp, #20 <== NOT EXECUTED 198ac: e3a02001 mov r2, #1 <== NOT EXECUTED 198b0: ebfffa29 bl 1815c <rtems_rfs_block_map_shrink> <== NOT EXECUTED
if (rc > 0)
198b4: e2506000 subs r6, r0, #0 <== NOT EXECUTED 198b8: da00000c ble 198f0 <rtems_rfs_dir_del_entry+0x2fc> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
198bc: e3a00101 mov r0, #1073741824 ; 0x40000000 <== NOT EXECUTED 198c0: e3a01000 mov r1, #0 <== NOT EXECUTED 198c4: ebffde68 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 198c8: e3500000 cmp r0, #0 <== NOT EXECUTED 198cc: 0a000007 beq 198f0 <rtems_rfs_dir_del_entry+0x2fc> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
198d0: e1a00006 mov r0, r6 <== NOT EXECUTED 198d4: e5997008 ldr r7, [r9, #8] <== NOT EXECUTED 198d8: eb001901 bl 1fce4 <strerror> <== NOT EXECUTED 198dc: e1a01007 mov r1, r7 <== NOT EXECUTED 198e0: e1a03000 mov r3, r0 <== NOT EXECUTED 198e4: e1a02006 mov r2, r6 <== NOT EXECUTED 198e8: e59f00c4 ldr r0, [pc, #196] ; 199b4 <rtems_rfs_dir_del_entry+0x3c0><== NOT EXECUTED 198ec: eb00144e bl 1ea2c <printf> <== 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);
198f0: e28d1074 add r1, sp, #116 ; 0x74 198f4: e3a03001 mov r3, #1 198f8: e5613010 strb r3, [r1, #-16]!
rtems_rfs_buffer_handle_close (fs, &buffer);
198fc: e1a00005 mov r0, r5 19900: ebfffd2a bl 18db0 <rtems_rfs_buffer_handle_close>
rtems_rfs_block_map_close (fs, &map);
19904: e1a00005 mov r0, r5 19908: e28d1014 add r1, sp, #20 1990c: ebfff83a bl 179fc <rtems_rfs_block_map_close>
return 0;
19910: ea00001b b 19984 <rtems_rfs_dir_del_entry+0x390>
}
if (!search)
19914: e35b0000 cmp fp, #0 <== NOT EXECUTED 19918: 0a00001c beq 19990 <rtems_rfs_dir_del_entry+0x39c> <== NOT EXECUTED
{
rc = EIO;
break;
}
entry += elength;
1991c: e082200a add r2, r2, sl <== NOT EXECUTED
eoffset += elength;
19920: e087700a add r7, r7, sl <== 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))
19924: e1570001 cmp r7, r1
19928: 3affff80 bcc 19730 <rtems_rfs_dir_del_entry+0x13c>
entry += elength;
eoffset += elength;
}
if (rc == 0)
1992c: e3580000 cmp r8, #0 <== NOT EXECUTED 19930: 1a000008 bne 19958 <rtems_rfs_dir_del_entry+0x364> <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
19934: e1a00005 mov r0, r5 <== NOT EXECUTED 19938: e28d1014 add r1, sp, #20 <== NOT EXECUTED 1993c: e28d2070 add r2, sp, #112 ; 0x70 <== NOT EXECUTED 19940: ebfff913 bl 17d94 <rtems_rfs_block_map_next_block> <== NOT EXECUTED
if (rc == ENXIO)
19944: e3500006 cmp r0, #6 <== NOT EXECUTED
eoffset += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
19948: e1a04000 mov r4, r0 <== NOT EXECUTED
if (rc == ENXIO)
1994c: 1a000002 bne 1995c <rtems_rfs_dir_del_entry+0x368> <== NOT EXECUTED
rc = ENOENT;
19950: e3a04002 mov r4, #2 <== NOT EXECUTED 19954: ea000002 b 19964 <rtems_rfs_dir_del_entry+0x370> <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
19958: e1a04008 mov r4, r8 <== NOT EXECUTED
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
1995c: e3540000 cmp r4, #0
19960: 0affff4e beq 196a0 <rtems_rfs_dir_del_entry+0xac>
19964: e1a07004 mov r7, r4 <== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
19968: e28d1064 add r1, sp, #100 ; 0x64 <== NOT EXECUTED 1996c: e1a00005 mov r0, r5 <== NOT EXECUTED 19970: ebfffd0e bl 18db0 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
19974: e1a00005 mov r0, r5 <== NOT EXECUTED 19978: e28d1014 add r1, sp, #20 <== NOT EXECUTED 1997c: ebfff81e bl 179fc <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
19980: e1a04007 mov r4, r7 <== NOT EXECUTED
}
19984: e1a00004 mov r0, r4
19988: e28dd074 add sp, sp, #116 ; 0x74
1998c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
19990: e3a08005 mov r8, #5 <== NOT EXECUTED 19994: eaffffef b 19958 <rtems_rfs_dir_del_entry+0x364> <== NOT EXECUTED
00019cec <rtems_rfs_dir_empty>:
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
19cec: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
19cf0: e1a04000 mov r4, r0
19cf4: e24dd064 sub sp, sp, #100 ; 0x64
19cf8: e1a05001 mov r5, r1
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
19cfc: e3a00102 mov r0, #-2147483648 ; 0x80000000 19d00: e3a01000 mov r1, #0 19d04: ebffdd58 bl 1126c <rtems_rfs_trace> 19d08: e3500000 cmp r0, #0
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
19d0c: 159f019c ldrne r0, [pc, #412] ; 19eb0 <rtems_rfs_dir_empty+0x1c4> 19d10: 15951008 ldrne r1, [r5, #8] 19d14: 1b001344 blne 1ea2c <printf>
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
19d18: e1a00004 mov r0, r4 19d1c: e1a01005 mov r1, r5 19d20: e28d2004 add r2, sp, #4 19d24: ebfff6db bl 17898 <rtems_rfs_block_map_open>
if (rc > 0)
19d28: e2508000 subs r8, r0, #0
19d2c: ca00005c bgt 19ea4 <rtems_rfs_dir_empty+0x1b8>
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
19d30: e28d3060 add r3, sp, #96 ; 0x60 19d34: e58d3000 str r3, [sp] 19d38: e1a00004 mov r0, r4 19d3c: e28d1004 add r1, sp, #4 19d40: e3a02000 mov r2, #0 19d44: e3a03000 mov r3, #0 19d48: ebfff7f5 bl 17d24 <rtems_rfs_block_map_seek>
if (rc > 0)
19d4c: e2508000 subs r8, r0, #0
19d50: ca000050 bgt 19e98 <rtems_rfs_dir_empty+0x1ac>
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
19d54: e3a03000 mov r3, #0 19d58: e5cd3054 strb r3, [sp, #84] ; 0x54
handle->bnum = 0;
19d5c: e58d3058 str r3, [sp, #88] ; 0x58
handle->buffer = NULL;
19d60: e58d305c str r3, [sp, #92] ; 0x5c
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
19d64: e59f6148 ldr r6, [pc, #328] ; 19eb4 <rtems_rfs_dir_empty+0x1c8>
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
19d68: e1a00004 mov r0, r4 19d6c: e28d1054 add r1, sp, #84 ; 0x54 19d70: e59d2060 ldr r2, [sp, #96] ; 0x60 19d74: e3a03001 mov r3, #1 19d78: ebfffa7b bl 1876c <rtems_rfs_buffer_handle_request>
if (rc > 0)
19d7c: e2508000 subs r8, r0, #0
19d80: ca000041 bgt 19e8c <rtems_rfs_dir_empty+0x1a0>
break;
entry = rtems_rfs_buffer_data (&buffer);
19d84: e59d305c ldr r3, [sp, #92] ; 0x5c
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
19d88: e5942008 ldr r2, [r4, #8]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
19d8c: e593301c ldr r3, [r3, #28]
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
19d90: e242200a sub r2, r2, #10
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
19d94: e3a09000 mov r9, #0
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
19d98: ea00002e b 19e58 <rtems_rfs_dir_empty+0x16c>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
19d9c: e5d31009 ldrb r1, [r3, #9] 19da0: e5d3a008 ldrb sl, [r3, #8] 19da4: e181a40a orr sl, r1, sl, lsl #8
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
19da8: e15a0006 cmp sl, r6
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
19dac: e5d3c000 ldrb ip, [r3] 19db0: e5d37001 ldrb r7, [r3, #1] 19db4: e5d31002 ldrb r1, [r3, #2] 19db8: e5d30003 ldrb r0, [r3, #3]
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
19dbc: 0a000027 beq 19e60 <rtems_rfs_dir_empty+0x174>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
19dc0: e1a07807 lsl r7, r7, #16 19dc4: e1877c0c orr r7, r7, ip, lsl #24 19dc8: e1877000 orr r7, r7, r0
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
19dcc: e35a000a cmp sl, #10
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
19dd0: e1877401 orr r7, r7, r1, lsl #8
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
19dd4: da000006 ble 19df4 <rtems_rfs_dir_empty+0x108>
19dd8: e594101c ldr r1, [r4, #28] 19ddc: e3570000 cmp r7, #0 19de0: 115a0001 cmpne sl, r1
19de4: 2a000002 bcs 19df4 <rtems_rfs_dir_empty+0x108>
19de8: e5941014 ldr r1, [r4, #20] 19dec: e1570001 cmp r7, r1
19df0: 9a00000b bls 19e24 <rtems_rfs_dir_empty+0x138>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
19df4: e3a00000 mov r0, #0 <== NOT EXECUTED 19df8: e3a01001 mov r1, #1 <== NOT EXECUTED 19dfc: ebffdd1a bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 19e00: e3500000 cmp r0, #0 <== NOT EXECUTED 19e04: 0a000015 beq 19e60 <rtems_rfs_dir_empty+0x174> <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
19e08: e5951008 ldr r1, [r5, #8] <== NOT EXECUTED 19e0c: e1a0200a mov r2, sl <== NOT EXECUTED 19e10: e1a03007 mov r3, r7 <== NOT EXECUTED 19e14: e59f009c ldr r0, [pc, #156] ; 19eb8 <rtems_rfs_dir_empty+0x1cc><== NOT EXECUTED 19e18: e58d9000 str r9, [sp] <== NOT EXECUTED 19e1c: eb001302 bl 1ea2c <printf> <== NOT EXECUTED 19e20: ea00000e b 19e60 <rtems_rfs_dir_empty+0x174> <== NOT EXECUTED
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
19e24: e35a000b cmp sl, #11 19e28: 05d3100a ldrbeq r1, [r3, #10]
19e2c: 0a000005 beq 19e48 <rtems_rfs_dir_empty+0x15c>
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
19e30: e35a000c cmp sl, #12
19e34: 1a000012 bne 19e84 <rtems_rfs_dir_empty+0x198>
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
19e38: e5d3100a ldrb r1, [r3, #10] 19e3c: e351002e cmp r1, #46 ; 0x2e
19e40: 1a00000f bne 19e84 <rtems_rfs_dir_empty+0x198>
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
19e44: e5d3100b ldrb r1, [r3, #11] 19e48: e351002e cmp r1, #46 ; 0x2e
19e4c: 1a00000c bne 19e84 <rtems_rfs_dir_empty+0x198>
{
empty = false;
break;
}
entry += elength;
19e50: e083300a add r3, r3, sl
offset += elength;
19e54: e089900a add r9, r9, sl
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
19e58: e1590002 cmp r9, r2
19e5c: 3affffce bcc 19d9c <rtems_rfs_dir_empty+0xb0>
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
19e60: e1a00004 mov r0, r4 19e64: e28d1004 add r1, sp, #4 19e68: e28d2060 add r2, sp, #96 ; 0x60 19e6c: ebfff7c8 bl 17d94 <rtems_rfs_block_map_next_block>
if (rc > 0)
19e70: e2508000 subs r8, r0, #0
19e74: daffffbb ble 19d68 <rtems_rfs_dir_empty+0x7c>
{
if (rc == ENXIO)
19e78: e3580006 cmp r8, #6 19e7c: 03a08000 moveq r8, #0 19e80: ea000001 b 19e8c <rtems_rfs_dir_empty+0x1a0>
}
}
}
if ((rc == 0) && !empty)
rc = ENOTEMPTY;
19e84: e3580000 cmp r8, #0 19e88: 03a0805a moveq r8, #90 ; 0x5a
rtems_rfs_buffer_handle_close (fs, &buffer);
19e8c: e1a00004 mov r0, r4 19e90: e28d1054 add r1, sp, #84 ; 0x54 19e94: ebfffbc5 bl 18db0 <rtems_rfs_buffer_handle_close>
rtems_rfs_block_map_close (fs, &map);
19e98: e1a00004 mov r0, r4 19e9c: e28d1004 add r1, sp, #4 19ea0: ebfff6d5 bl 179fc <rtems_rfs_block_map_close>
return rc; }
19ea4: e1a00008 mov r0, r8
19ea8: e28dd064 add sp, sp, #100 ; 0x64
19eac: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
0001d310 <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;
1d310: e59f31a8 ldr r3, [pc, #424] ; 1d4c0 <rtems_rfs_dir_hash+0x1b0> 1d314: e0813003 add r3, r1, r3
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
1d318: e92d4010 push {r4, lr}
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;
1d31c: e1a02003 mov r2, r3 1d320: e1a0c003 mov ip, r3
} 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)
1d324: ea00002b b 1d3d8 <rtems_rfs_dir_hash+0xc8>
{
a += k[0];
1d328: e5d04000 ldrb r4, [r0] 1d32c: e084c00c add ip, r4, ip
a += ((uint32_t)k[1])<<8;
1d330: e5d04001 ldrb r4, [r0, #1] 1d334: e08cc404 add ip, ip, r4, lsl #8
a += ((uint32_t)k[2])<<16;
1d338: e5d04002 ldrb r4, [r0, #2] 1d33c: e08cc804 add ip, ip, r4, lsl #16
a += ((uint32_t)k[3])<<24;
1d340: e5d04003 ldrb r4, [r0, #3] 1d344: e08ccc04 add ip, ip, r4, lsl #24
b += k[4];
1d348: e5d04004 ldrb r4, [r0, #4] 1d34c: e0842002 add r2, r4, r2
b += ((uint32_t)k[5])<<8;
1d350: e5d04005 ldrb r4, [r0, #5] 1d354: e0822404 add r2, r2, r4, lsl #8
b += ((uint32_t)k[6])<<16;
1d358: e5d04006 ldrb r4, [r0, #6] 1d35c: e0822804 add r2, r2, r4, lsl #16
b += ((uint32_t)k[7])<<24;
1d360: e5d04007 ldrb r4, [r0, #7] 1d364: e0822c04 add r2, r2, r4, lsl #24
c += k[8];
1d368: e5d04008 ldrb r4, [r0, #8] 1d36c: e0843003 add r3, r4, r3
c += ((uint32_t)k[9])<<8;
1d370: e5d04009 ldrb r4, [r0, #9] 1d374: e0833404 add r3, r3, r4, lsl #8
c += ((uint32_t)k[10])<<16;
1d378: e5d0400a ldrb r4, [r0, #10] 1d37c: e0833804 add r3, r3, r4, lsl #16
c += ((uint32_t)k[11])<<24;
1d380: e5d0400b ldrb r4, [r0, #11] 1d384: e0833c04 add r3, r3, r4, lsl #24
mix(a,b,c);
1d388: e063c00c rsb ip, r3, ip 1d38c: e02cce63 eor ip, ip, r3, ror #28 1d390: e0833002 add r3, r3, r2 1d394: e06c2002 rsb r2, ip, r2 1d398: e0222d6c eor r2, r2, ip, ror #26 1d39c: e08cc003 add ip, ip, r3 1d3a0: e0623003 rsb r3, r2, r3 1d3a4: e0233c62 eor r3, r3, r2, ror #24 1d3a8: e082200c add r2, r2, ip 1d3ac: e063c00c rsb ip, r3, ip 1d3b0: e02cc863 eor ip, ip, r3, ror #16 1d3b4: e0833002 add r3, r3, r2 1d3b8: e06c2002 rsb r2, ip, r2 1d3bc: e02226ec eor r2, r2, ip, ror #13 1d3c0: e08cc003 add ip, ip, r3 1d3c4: e0623003 rsb r3, r2, r3 1d3c8: e0233e62 eor r3, r3, r2, ror #28
length -= 12;
1d3cc: e241100c sub r1, r1, #12
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);
1d3d0: e082200c add r2, r2, ip
length -= 12;
k += 12;
1d3d4: e280000c add r0, r0, #12
} 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)
1d3d8: e351000c cmp r1, #12
1d3dc: 8affffd1 bhi 1d328 <rtems_rfs_dir_hash+0x18>
length -= 12;
k += 12;
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
1d3e0: e2411001 sub r1, r1, #1 1d3e4: e351000b cmp r1, #11 1d3e8: 979ff101 ldrls pc, [pc, r1, lsl #2]
1d3ec: ea000031 b 1d4b8 <rtems_rfs_dir_hash+0x1a8> <== NOT EXECUTED 1d3f0: 0001d478 .word 0x0001d478 <== NOT EXECUTED 1d3f4: 0001d470 .word 0x0001d470 <== NOT EXECUTED 1d3f8: 0001d468 .word 0x0001d468 <== NOT EXECUTED 1d3fc: 0001d460 .word 0x0001d460 <== NOT EXECUTED 1d400: 0001d458 .word 0x0001d458 <== NOT EXECUTED 1d404: 0001d450 .word 0x0001d450 <== NOT EXECUTED 1d408: 0001d448 .word 0x0001d448 <== NOT EXECUTED 1d40c: 0001d440 .word 0x0001d440 <== NOT EXECUTED 1d410: 0001d438 .word 0x0001d438 <== NOT EXECUTED 1d414: 0001d430 .word 0x0001d430 <== NOT EXECUTED 1d418: 0001d428 .word 0x0001d428 <== NOT EXECUTED 1d41c: 0001d420 .word 0x0001d420 <== NOT EXECUTED
{
case 12: c+=((uint32_t)k[11])<<24;
1d420: e5d0100b ldrb r1, [r0, #11] 1d424: e0833c01 add r3, r3, r1, lsl #24
case 11: c+=((uint32_t)k[10])<<16;
1d428: e5d0100a ldrb r1, [r0, #10] 1d42c: e0833801 add r3, r3, r1, lsl #16
case 10: c+=((uint32_t)k[9])<<8;
1d430: e5d01009 ldrb r1, [r0, #9] 1d434: e0833401 add r3, r3, r1, lsl #8
case 9 : c+=k[8];
1d438: e5d01008 ldrb r1, [r0, #8] 1d43c: e0833001 add r3, r3, r1
case 8 : b+=((uint32_t)k[7])<<24;
1d440: e5d01007 ldrb r1, [r0, #7] 1d444: e0822c01 add r2, r2, r1, lsl #24
case 7 : b+=((uint32_t)k[6])<<16;
1d448: e5d01006 ldrb r1, [r0, #6] 1d44c: e0822801 add r2, r2, r1, lsl #16
case 6 : b+=((uint32_t)k[5])<<8;
1d450: e5d01005 ldrb r1, [r0, #5] 1d454: e0822401 add r2, r2, r1, lsl #8
case 5 : b+=k[4];
1d458: e5d01004 ldrb r1, [r0, #4] 1d45c: e0822001 add r2, r2, r1
case 4 : a+=((uint32_t)k[3])<<24;
1d460: e5d01003 ldrb r1, [r0, #3] 1d464: e08ccc01 add ip, ip, r1, lsl #24
case 3 : a+=((uint32_t)k[2])<<16;
1d468: e5d01002 ldrb r1, [r0, #2] 1d46c: e08cc801 add ip, ip, r1, lsl #16
case 2 : a+=((uint32_t)k[1])<<8;
1d470: e5d01001 ldrb r1, [r0, #1] 1d474: e08cc401 add ip, ip, r1, lsl #8
case 1 : a+=k[0];
1d478: e5d01000 ldrb r1, [r0]
break;
case 0 : return c;
}
}
final(a,b,c);
1d47c: e0233002 eor r3, r3, r2
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];
1d480: e08cc001 add ip, ip, r1
break;
case 0 : return c;
}
}
final(a,b,c);
1d484: e0431962 sub r1, r3, r2, ror #18 1d488: e021c00c eor ip, r1, ip 1d48c: e04ccae1 sub ip, ip, r1, ror #21 1d490: e02c2002 eor r2, ip, r2 1d494: e04223ec sub r2, r2, ip, ror #7 1d498: e0221001 eor r1, r2, r1 1d49c: e0411862 sub r1, r1, r2, ror #16 1d4a0: e021c00c eor ip, r1, ip 1d4a4: e04cce61 sub ip, ip, r1, ror #28 1d4a8: e02c2002 eor r2, ip, r2 1d4ac: e042296c sub r2, r2, ip, ror #18 1d4b0: e0223001 eor r3, r2, r1 1d4b4: e0433462 sub r3, r3, r2, ror #8
return c; }
1d4b8: e1a00003 mov r0, r3
1d4bc: e8bd8010 pop {r4, pc}
00018dd0 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
18dd0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
18dd4: e1a06000 mov r6, r0
18dd8: e24dd070 sub sp, sp, #112 ; 0x70
18ddc: e1a07001 mov r7, r1
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
18de0: e3a00301 mov r0, #67108864 ; 0x4000000 18de4: e3a01000 mov r1, #0
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
18de8: e58d2008 str r2, [sp, #8] 18dec: e1a09003 mov r9, r3 18df0: e59db094 ldr fp, [sp, #148] ; 0x94
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
18df4: ebffe11c bl 1126c <rtems_rfs_trace> 18df8: e3500000 cmp r0, #0
18dfc: 0a00000d beq 18e38 <rtems_rfs_dir_lookup_ino+0x68>
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
18e00: e59f0440 ldr r0, [pc, #1088] ; 19248 <rtems_rfs_dir_lookup_ino+0x478><== NOT EXECUTED 18e04: e5971008 ldr r1, [r7, #8] <== NOT EXECUTED 18e08: eb001707 bl 1ea2c <printf> <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
18e0c: e3a04000 mov r4, #0 <== NOT EXECUTED 18e10: ea000003 b 18e24 <rtems_rfs_dir_lookup_ino+0x54> <== NOT EXECUTED
printf ("%c", name[c]);
18e14: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED 18e18: e7dc0004 ldrb r0, [ip, r4] <== NOT EXECUTED 18e1c: eb00176c bl 1ebd4 <putchar> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
inode->ino);
for (c = 0; c < length; c++)
18e20: e2844001 add r4, r4, #1 <== NOT EXECUTED 18e24: e1540009 cmp r4, r9 <== NOT EXECUTED 18e28: bafffff9 blt 18e14 <rtems_rfs_dir_lookup_ino+0x44> <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
18e2c: e59f0418 ldr r0, [pc, #1048] ; 1924c <rtems_rfs_dir_lookup_ino+0x47c><== NOT EXECUTED 18e30: e1a01009 mov r1, r9 <== NOT EXECUTED 18e34: eb0016fc bl 1ea2c <printf> <== NOT EXECUTED
}
*ino = RTEMS_RFS_EMPTY_INO;
*offset = 0;
18e38: e59dc098 ldr ip, [sp, #152] ; 0x98
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
18e3c: e3a05000 mov r5, #0 18e40: e58b5000 str r5, [fp]
*offset = 0;
rc = rtems_rfs_block_map_open (fs, inode, &map);
18e44: e1a00006 mov r0, r6
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
*offset = 0;
18e48: e58c5000 str r5, [ip]
rc = rtems_rfs_block_map_open (fs, inode, &map);
18e4c: e1a01007 mov r1, r7 18e50: e28d2010 add r2, sp, #16 18e54: ebfffa8f bl 17898 <rtems_rfs_block_map_open>
if (rc > 0)
18e58: e2504000 subs r4, r0, #0
18e5c: da00000d ble 18e98 <rtems_rfs_dir_lookup_ino+0xc8>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
18e60: e3a00301 mov r0, #67108864 ; 0x4000000 <== NOT EXECUTED 18e64: e3a01000 mov r1, #0 <== NOT EXECUTED 18e68: ebffe0ff bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 18e6c: e1500005 cmp r0, r5 <== NOT EXECUTED 18e70: 0a0000e8 beq 19218 <rtems_rfs_dir_lookup_ino+0x448> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
18e74: e1a00004 mov r0, r4 <== NOT EXECUTED 18e78: e5975008 ldr r5, [r7, #8] <== NOT EXECUTED 18e7c: eb001b98 bl 1fce4 <strerror> <== NOT EXECUTED 18e80: e1a01005 mov r1, r5 <== NOT EXECUTED 18e84: e1a03000 mov r3, r0 <== NOT EXECUTED 18e88: e1a02004 mov r2, r4 <== NOT EXECUTED 18e8c: e59f03bc ldr r0, [pc, #956] ; 19250 <rtems_rfs_dir_lookup_ino+0x480><== NOT EXECUTED 18e90: eb0016e5 bl 1ea2c <printf> <== NOT EXECUTED 18e94: ea0000df b 19218 <rtems_rfs_dir_lookup_ino+0x448> <== NOT EXECUTED
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
18e98: e1a01009 mov r1, r9 18e9c: e59d0008 ldr r0, [sp, #8]
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
18ea0: e5cd5060 strb r5, [sp, #96] ; 0x60
handle->bnum = 0;
18ea4: e58d5064 str r5, [sp, #100] ; 0x64
handle->buffer = NULL;
18ea8: e58d5068 str r5, [sp, #104] ; 0x68 18eac: eb001117 bl 1d310 <rtems_rfs_dir_hash>
/*
* 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);
18eb0: e28d306c add r3, sp, #108 ; 0x6c
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
18eb4: e58d000c str r0, [sp, #12]
/*
* 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);
18eb8: e58d3000 str r3, [sp] 18ebc: e1a00006 mov r0, r6 18ec0: e28d1010 add r1, sp, #16 18ec4: e3a02000 mov r2, #0 18ec8: e3a03000 mov r3, #0 18ecc: ebfffb94 bl 17d24 <rtems_rfs_block_map_seek>
if (rc > 0)
18ed0: e2504000 subs r4, r0, #0
18ed4: da0000b6 ble 191b4 <rtems_rfs_dir_lookup_ino+0x3e4>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
18ed8: e3a00301 mov r0, #67108864 ; 0x4000000 <== NOT EXECUTED 18edc: e3a01000 mov r1, #0 <== NOT EXECUTED 18ee0: ebffe0e1 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 18ee4: e3500000 cmp r0, #0 <== NOT EXECUTED 18ee8: 0a000005 beq 18f04 <rtems_rfs_dir_lookup_ino+0x134> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
18eec: e1a00004 mov r0, r4 <== NOT EXECUTED 18ef0: eb001b7b bl 1fce4 <strerror> <== NOT EXECUTED 18ef4: e1a01004 mov r1, r4 <== NOT EXECUTED 18ef8: e1a02000 mov r2, r0 <== NOT EXECUTED 18efc: e59f0350 ldr r0, [pc, #848] ; 19254 <rtems_rfs_dir_lookup_ino+0x484><== NOT EXECUTED 18f00: eb0016c9 bl 1ea2c <printf> <== NOT EXECUTED
rc, strerror (rc));
if (rc == ENXIO)
rc = ENOENT;
18f04: e3540006 cmp r4, #6 <== NOT EXECUTED 18f08: 03a04002 moveq r4, #2 <== NOT EXECUTED 18f0c: ea0000bb b 19200 <rtems_rfs_dir_lookup_ino+0x430> <== NOT EXECUTED
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
18f10: e3a00301 mov r0, #67108864 ; 0x4000000 18f14: e3a01000 mov r1, #0 18f18: ebffe0d3 bl 1126c <rtems_rfs_trace> 18f1c: e3500000 cmp r0, #0
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
18f20: 159f0330 ldrne r0, [pc, #816] ; 19258 <rtems_rfs_dir_lookup_ino+0x488> 18f24: 15981008 ldrne r1, [r8, #8] 18f28: 159d2020 ldrne r2, [sp, #32] 18f2c: 1b0016be blne 1ea2c <printf>
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
18f30: e1a00006 mov r0, r6 18f34: e28d1060 add r1, sp, #96 ; 0x60 18f38: e59d206c ldr r2, [sp, #108] ; 0x6c 18f3c: e3a03001 mov r3, #1 18f40: ebfffe09 bl 1876c <rtems_rfs_buffer_handle_request>
if (rc > 0)
18f44: e250a000 subs sl, r0, #0
18f48: da000010 ble 18f90 <rtems_rfs_dir_lookup_ino+0x1c0>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
18f4c: e3a00301 mov r0, #67108864 ; 0x4000000 <== NOT EXECUTED 18f50: e3a01000 mov r1, #0 <== NOT EXECUTED 18f54: ebffe0c4 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 18f58: e3500000 cmp r0, #0 <== NOT EXECUTED 18f5c: e1a07008 mov r7, r8 <== NOT EXECUTED 18f60: 0a00009b beq 191d4 <rtems_rfs_dir_lookup_ino+0x404> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
18f64: e1a0000a mov r0, sl <== NOT EXECUTED 18f68: e5985008 ldr r5, [r8, #8] <== NOT EXECUTED 18f6c: e59d406c ldr r4, [sp, #108] ; 0x6c <== NOT EXECUTED 18f70: eb001b5b bl 1fce4 <strerror> <== NOT EXECUTED 18f74: e1a01005 mov r1, r5 <== NOT EXECUTED 18f78: e58d0000 str r0, [sp] <== NOT EXECUTED 18f7c: e1a02004 mov r2, r4 <== NOT EXECUTED 18f80: e1a0300a mov r3, sl <== NOT EXECUTED 18f84: e59f02d0 ldr r0, [pc, #720] ; 1925c <rtems_rfs_dir_lookup_ino+0x48c><== NOT EXECUTED 18f88: eb0016a7 bl 1ea2c <printf> <== NOT EXECUTED 18f8c: ea000090 b 191d4 <rtems_rfs_dir_lookup_ino+0x404> <== 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);
18f90: e59d3068 ldr r3, [sp, #104] ; 0x68 18f94: e593501c ldr r5, [r3, #28]
map.bpos.boff = 0;
18f98: e3a03000 mov r3, #0 18f9c: e58d3024 str r3, [sp, #36] ; 0x24
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
18fa0: ea000060 b 19128 <rtems_rfs_dir_lookup_ino+0x358>
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
18fa4: e5d53009 ldrb r3, [r5, #9] 18fa8: e5d57008 ldrb r7, [r5, #8] 18fac: e1837407 orr r7, r3, r7, lsl #8
*ino = rtems_rfs_dir_entry_ino (entry);
18fb0: e5d53001 ldrb r3, [r5, #1] 18fb4: e5d5e000 ldrb lr, [r5] 18fb8: e1a03803 lsl r3, r3, #16 18fbc: e1833c0e orr r3, r3, lr, lsl #24 18fc0: e5d5e003 ldrb lr, [r5, #3] 18fc4: e183300e orr r3, r3, lr 18fc8: e5d5e002 ldrb lr, [r5, #2] 18fcc: e183340e orr r3, r3, lr, lsl #8
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
18fd0: e59fe288 ldr lr, [pc, #648] ; 19260 <rtems_rfs_dir_lookup_ino+0x490> 18fd4: e157000e cmp r7, lr
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);
18fd8: e5d50004 ldrb r0, [r5, #4] 18fdc: e5d5c005 ldrb ip, [r5, #5] 18fe0: e5d52006 ldrb r2, [r5, #6] 18fe4: e5d51007 ldrb r1, [r5, #7]
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
18fe8: e58b3000 str r3, [fp]
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
18fec: 0a000052 beq 1913c <rtems_rfs_dir_lookup_ino+0x36c>
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
18ff0: e357000a cmp r7, #10
18ff4: da000007 ble 19018 <rtems_rfs_dir_lookup_ino+0x248>
18ff8: e596e01c ldr lr, [r6, #28] 18ffc: e157000e cmp r7, lr
19000: 2a000004 bcs 19018 <rtems_rfs_dir_lookup_ino+0x248>
19004: e3530000 cmp r3, #0
19008: 0a000002 beq 19018 <rtems_rfs_dir_lookup_ino+0x248>
1900c: e596e014 ldr lr, [r6, #20] 19010: e153000e cmp r3, lr
19014: 9a00000c bls 1904c <rtems_rfs_dir_lookup_ino+0x27c>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
19018: e3a00301 mov r0, #67108864 ; 0x4000000 <== NOT EXECUTED 1901c: e3a01000 mov r1, #0 <== NOT EXECUTED 19020: ebffe091 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 19024: e3500000 cmp r0, #0 <== NOT EXECUTED 19028: 0a00007d beq 19224 <rtems_rfs_dir_lookup_ino+0x454> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
1902c: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 19030: e58d3000 str r3, [sp] <== NOT EXECUTED 19034: e1a02007 mov r2, r7 <== NOT EXECUTED 19038: e5981008 ldr r1, [r8, #8] <== NOT EXECUTED 1903c: e59b3000 ldr r3, [fp] <== NOT EXECUTED 19040: e59f021c ldr r0, [pc, #540] ; 19264 <rtems_rfs_dir_lookup_ino+0x494><== NOT EXECUTED 19044: eb001678 bl 1ea2c <printf> <== NOT EXECUTED 19048: ea000075 b 19224 <rtems_rfs_dir_lookup_ino+0x454> <== 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);
1904c: e1a0c80c lsl ip, ip, #16 19050: e18ccc00 orr ip, ip, r0, lsl #24 19054: e18c1001 orr r1, ip, r1
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
19058: e59dc00c ldr ip, [sp, #12]
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);
1905c: e1812402 orr r2, r1, r2, lsl #8
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
19060: e152000c cmp r2, ip
19064: 1a00002b bne 19118 <rtems_rfs_dir_lookup_ino+0x348>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
19068: e3a00302 mov r0, #134217728 ; 0x8000000 1906c: e3a01000 mov r1, #0 19070: ebffe07d bl 1126c <rtems_rfs_trace> 19074: e3500000 cmp r0, #0
19078: 0a00000e beq 190b8 <rtems_rfs_dir_lookup_ino+0x2e8>
printf ("rtems-rfs: dir-lookup-ino: "
1907c: e58d7000 str r7, [sp] <== 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));
19080: e5d53001 ldrb r3, [r5, #1] <== NOT EXECUTED 19084: e5d52000 ldrb r2, [r5] <== NOT EXECUTED 19088: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED 1908c: e1833c02 orr r3, r3, r2, lsl #24 <== NOT EXECUTED 19090: e5d52003 ldrb r2, [r5, #3] <== NOT EXECUTED 19094: e1833002 orr r3, r3, r2 <== NOT EXECUTED 19098: e5d52002 ldrb r2, [r5, #2] <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
1909c: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
190a0: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
190a4: e28d2020 add r2, sp, #32 <== NOT EXECUTED
190a8: e59f01b8 ldr r0, [pc, #440] ; 19268 <rtems_rfs_dir_lookup_ino+0x498><== NOT EXECUTED
190ac: e5981008 ldr r1, [r8, #8] <== NOT EXECUTED
190b0: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
190b4: eb00165c bl 1ea2c <printf> <== 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)
190b8: e285000a add r0, r5, #10 190bc: e59d1008 ldr r1, [sp, #8] 190c0: e1a02009 mov r2, r9 190c4: eb001537 bl 1e5a8 <memcmp> 190c8: e3500000 cmp r0, #0
190cc: 1a000011 bne 19118 <rtems_rfs_dir_lookup_ino+0x348>
{
*offset = rtems_rfs_block_map_pos (fs, &map);
190d0: e1a00006 mov r0, r6 190d4: e28d1020 add r1, sp, #32 190d8: ebfff9c2 bl 177e8 <rtems_rfs_block_get_pos> 190dc: e59dc098 ldr ip, [sp, #152] ; 0x98
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
190e0: e3a01000 mov r1, #0
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);
190e4: e58c0000 str r0, [ip]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
190e8: e3a00201 mov r0, #268435456 ; 0x10000000 190ec: ebffe05e bl 1126c <rtems_rfs_trace> 190f0: e3500000 cmp r0, #0 190f4: e1a07008 mov r7, r8
190f8: 0a000040 beq 19200 <rtems_rfs_dir_lookup_ino+0x430>
printf ("rtems-rfs: dir-lookup-ino: "
190fc: e59dc098 ldr ip, [sp, #152] ; 0x98 <== NOT EXECUTED 19100: e5981008 ldr r1, [r8, #8] <== NOT EXECUTED 19104: e59b2000 ldr r2, [fp] <== NOT EXECUTED 19108: e59c3000 ldr r3, [ip] <== NOT EXECUTED 1910c: e59f0158 ldr r0, [pc, #344] ; 1926c <rtems_rfs_dir_lookup_ino+0x49c><== NOT EXECUTED 19110: eb001645 bl 1ea2c <printf> <== NOT EXECUTED 19114: ea000039 b 19200 <rtems_rfs_dir_lookup_ino+0x430> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
19118: e59d3024 ldr r3, [sp, #36] ; 0x24 1911c: e0833007 add r3, r3, r7 19120: e58d3024 str r3, [sp, #36] ; 0x24
entry += elength;
19124: e0855007 add r5, r5, r7
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))
19128: e5963008 ldr r3, [r6, #8] 1912c: e59d2024 ldr r2, [sp, #36] ; 0x24 19130: e243300a sub r3, r3, #10 19134: e1520003 cmp r2, r3
19138: 3affff99 bcc 18fa4 <rtems_rfs_dir_lookup_ino+0x1d4>
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
1913c: e35a0000 cmp sl, #0
19140: 1a000019 bne 191ac <rtems_rfs_dir_lookup_ino+0x3dc>
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
19144: e1a00006 mov r0, r6 19148: e28d1010 add r1, sp, #16 1914c: e28d206c add r2, sp, #108 ; 0x6c 19150: ebfffb0f bl 17d94 <rtems_rfs_block_map_next_block>
if ((rc > 0) && (rc != ENXIO))
19154: e3500006 cmp r0, #6 19158: 13500000 cmpne r0, #0
entry += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
1915c: e1a04000 mov r4, r0
if ((rc > 0) && (rc != ENXIO))
19160: da00000d ble 1919c <rtems_rfs_dir_lookup_ino+0x3cc>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
19164: e3a00301 mov r0, #67108864 ; 0x4000000 <== NOT EXECUTED 19168: e3a01000 mov r1, #0 <== NOT EXECUTED 1916c: ebffe03e bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 19170: e3500000 cmp r0, #0 <== NOT EXECUTED 19174: 0a00000f beq 191b8 <rtems_rfs_dir_lookup_ino+0x3e8> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
19178: e1a00004 mov r0, r4 <== NOT EXECUTED 1917c: e5985008 ldr r5, [r8, #8] <== NOT EXECUTED 19180: eb001ad7 bl 1fce4 <strerror> <== NOT EXECUTED 19184: e1a01005 mov r1, r5 <== NOT EXECUTED 19188: e1a03000 mov r3, r0 <== NOT EXECUTED 1918c: e1a02004 mov r2, r4 <== NOT EXECUTED 19190: e59f00d8 ldr r0, [pc, #216] ; 19270 <rtems_rfs_dir_lookup_ino+0x4a0><== NOT EXECUTED 19194: eb001624 bl 1ea2c <printf> <== NOT EXECUTED 19198: ea000006 b 191b8 <rtems_rfs_dir_lookup_ino+0x3e8> <== NOT EXECUTED
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
1919c: e3500006 cmp r0, #6
191a0: 1a000004 bne 191b8 <rtems_rfs_dir_lookup_ino+0x3e8>
rc = ENOENT;
191a4: e3a04002 mov r4, #2 191a8: ea000008 b 191d0 <rtems_rfs_dir_lookup_ino+0x400>
191ac: e1a0400a mov r4, sl <== NOT EXECUTED 191b0: ea000000 b 191b8 <rtems_rfs_dir_lookup_ino+0x3e8> <== 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)
191b4: e1a08007 mov r8, r7
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
191b8: e3540000 cmp r4, #0
191bc: 1a000003 bne 191d0 <rtems_rfs_dir_lookup_ino+0x400>
191c0: e59d306c ldr r3, [sp, #108] ; 0x6c 191c4: e3530000 cmp r3, #0
191c8: 1affff50 bne 18f10 <rtems_rfs_dir_lookup_ino+0x140>
191cc: ea000016 b 1922c <rtems_rfs_dir_lookup_ino+0x45c> <== NOT EXECUTED
191d0: e1a0a004 mov sl, r4 191d4: e1a0400a mov r4, sl 191d8: ea000008 b 19200 <rtems_rfs_dir_lookup_ino+0x430>
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
191dc: e3a00005 mov r0, #5 <== NOT EXECUTED 191e0: e5974008 ldr r4, [r7, #8] <== NOT EXECUTED 191e4: eb001abe bl 1fce4 <strerror> <== NOT EXECUTED 191e8: e1a01004 mov r1, r4 <== NOT EXECUTED 191ec: e1a03000 mov r3, r0 <== NOT EXECUTED 191f0: e3a02005 mov r2, #5 <== NOT EXECUTED 191f4: e59f0078 ldr r0, [pc, #120] ; 19274 <rtems_rfs_dir_lookup_ino+0x4a4><== NOT EXECUTED 191f8: eb00160b bl 1ea2c <printf> <== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
191fc: e3a04005 mov r4, #5 <== 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);
19200: e28d1060 add r1, sp, #96 ; 0x60 19204: e1a00006 mov r0, r6 19208: ebfffee8 bl 18db0 <rtems_rfs_buffer_handle_close>
rtems_rfs_block_map_close (fs, &map);
1920c: e1a00006 mov r0, r6 19210: e28d1010 add r1, sp, #16 19214: ebfff9f8 bl 179fc <rtems_rfs_block_map_close>
return rc; }
19218: e1a00004 mov r0, r4
1921c: e28dd070 add sp, sp, #112 ; 0x70
19220: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
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)
rc = ENOENT;
19224: e3a0a005 mov sl, #5 <== NOT EXECUTED 19228: eaffffdf b 191ac <rtems_rfs_dir_lookup_ino+0x3dc> <== NOT EXECUTED
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
1922c: e3a00301 mov r0, #67108864 ; 0x4000000 <== NOT EXECUTED 19230: e3a01000 mov r1, #0 <== NOT EXECUTED 19234: ebffe00c bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 19238: e3500000 cmp r0, #0 <== NOT EXECUTED 1923c: e1a07008 mov r7, r8 <== NOT EXECUTED 19240: 0affffed beq 191fc <rtems_rfs_dir_lookup_ino+0x42c> <== NOT EXECUTED 19244: eaffffe4 b 191dc <rtems_rfs_dir_lookup_ino+0x40c> <== NOT EXECUTED
000199b8 <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)
{
199b8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
199bc: e24dd070 sub sp, sp, #112 ; 0x70
199c0: e58d100c str r1, [sp, #12]
199c4: e1a05000 mov r5, r0
rtems_rfs_block_map map;
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
199c8: e3a01000 mov r1, #0 199cc: e3a00102 mov r0, #-2147483648 ; 0x80000000
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)
{
199d0: e98d000c stmib sp, {r2, r3}
199d4: e59da094 ldr sl, [sp, #148] ; 0x94
199d8: e59d8098 ldr r8, [sp, #152] ; 0x98
rtems_rfs_block_map map;
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
199dc: ebffde22 bl 1126c <rtems_rfs_trace> 199e0: e3500000 cmp r0, #0
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
199e4: 159d200c ldrne r2, [sp, #12]
199e8: 159f02e8 ldrne r0, [pc, #744] ; 19cd8 <rtems_rfs_dir_read+0x320>
199ec: 15921008 ldrne r1, [r2, #8]
199f0: 199d000c ldmibne sp, {r2, r3}
199f4: 1b00140c blne 1ea2c <printf>
rtems_rfs_inode_ino (dir), offset);
*length = 0;
199f8: e3a03000 mov r3, #0 199fc: e5883000 str r3, [r8]
rc = rtems_rfs_block_map_open (fs, dir, &map);
19a00: e1a00005 mov r0, r5 19a04: e59d100c ldr r1, [sp, #12] 19a08: e28d2010 add r2, sp, #16 19a0c: ebfff7a1 bl 17898 <rtems_rfs_block_map_open>
if (rc > 0)
19a10: e2504000 subs r4, r0, #0
19a14: ca0000ac bgt 19ccc <rtems_rfs_dir_read+0x314>
return rc;
if (((rtems_rfs_fs_block_size (fs) -
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
19a18: e5953008 ldr r3, [r5, #8]
19a1c: e3a07000 mov r7, #0
19a20: e1a02003 mov r2, r3
19a24: e1a06003 mov r6, r3
19a28: e99d0003 ldmib sp, {r0, r1}
19a2c: e1a03007 mov r3, r7
19a30: eb004997 bl 2c094 <__moddi3>
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
19a34: e1a02006 mov r2, r6 19a38: e1a03007 mov r3, r7 19a3c: e0522000 subs r2, r2, r0 19a40: e0c33001 sbc r3, r3, r1 19a44: e352000b cmp r2, #11 19a48: e2d30000 sbcs r0, r3, #0
19a4c: aa00000b bge 19a80 <rtems_rfs_dir_read+0xc8>
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
19a50: e99d0003 ldmib sp, {r0, r1} <== NOT EXECUTED
19a54: e1a02006 mov r2, r6 <== NOT EXECUTED
19a58: e1a03007 mov r3, r7 <== NOT EXECUTED
19a5c: eb004851 bl 2bba8 <__divdi3> <== NOT EXECUTED
19a60: e3a02001 mov r2, #1 <== NOT EXECUTED
19a64: e0922000 adds r2, r2, r0 <== NOT EXECUTED
19a68: e3a03000 mov r3, #0 <== NOT EXECUTED
19a6c: e0a33001 adc r3, r3, r1 <== NOT EXECUTED
19a70: e0810692 umull r0, r1, r2, r6 <== NOT EXECUTED
19a74: e98d0003 stmib sp, {r0, r1} <== NOT EXECUTED
19a78: e0201396 mla r0, r6, r3, r1 <== NOT EXECUTED
19a7c: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
19a80: e28d306c add r3, sp, #108 ; 0x6c
19a84: e28d6010 add r6, sp, #16
19a88: e58d3000 str r3, [sp]
19a8c: e1a00005 mov r0, r5
19a90: e1a01006 mov r1, r6
19a94: e99d000c ldmib sp, {r2, r3}
19a98: ebfff8a1 bl 17d24 <rtems_rfs_block_map_seek>
if (rc > 0)
19a9c: e2504000 subs r4, r0, #0
19aa0: da000004 ble 19ab8 <rtems_rfs_dir_read+0x100>
{
if (rc == ENXIO)
rc = ENOENT;
19aa4: e3540006 cmp r4, #6 <== NOT EXECUTED 19aa8: 03a04002 moveq r4, #2 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
19aac: e1a00005 mov r0, r5 <== NOT EXECUTED 19ab0: e1a01006 mov r1, r6 <== NOT EXECUTED 19ab4: ea000083 b 19cc8 <rtems_rfs_dir_read+0x310> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
19ab8: e3a03000 mov r3, #0 19abc: e5cd3060 strb r3, [sp, #96] ; 0x60
handle->bnum = 0;
19ac0: e58d3064 str r3, [sp, #100] ; 0x64
handle->buffer = NULL;
19ac4: e58d3068 str r3, [sp, #104] ; 0x68
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);
19ac8: e1a04006 mov r4, r6
uint8_t* entry;
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
19acc: e1a00005 mov r0, r5 19ad0: e28d1060 add r1, sp, #96 ; 0x60 19ad4: e59d206c ldr r2, [sp, #108] ; 0x6c 19ad8: e3a03001 mov r3, #1 19adc: ebfffb22 bl 1876c <rtems_rfs_buffer_handle_request>
if (rc > 0)
19ae0: e3500000 cmp r0, #0
19ae4: ca00006d bgt 19ca0 <rtems_rfs_dir_read+0x2e8>
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
19ae8: e59d3068 ldr r3, [sp, #104] ; 0x68
entry += map.bpos.boff;
19aec: e59d9024 ldr r9, [sp, #36] ; 0x24
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
19af0: e593301c ldr r3, [r3, #28]
entry += map.bpos.boff;
19af4: e0836009 add r6, r3, r9
elength = rtems_rfs_dir_entry_length (entry);
19af8: e5d62009 ldrb r2, [r6, #9] 19afc: e5d67008 ldrb r7, [r6, #8] 19b00: e1827407 orr r7, r2, r7, lsl #8
eino = rtems_rfs_dir_entry_ino (entry);
19b04: e7d32009 ldrb r2, [r3, r9] 19b08: e5d63001 ldrb r3, [r6, #1] 19b0c: e1a03803 lsl r3, r3, #16 19b10: e1833c02 orr r3, r3, r2, lsl #24
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
19b14: e59f11c0 ldr r1, [pc, #448] ; 19cdc <rtems_rfs_dir_read+0x324>
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
19b18: e5d62003 ldrb r2, [r6, #3] 19b1c: e5d6b002 ldrb fp, [r6, #2] 19b20: e1833002 orr r3, r3, r2
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
19b24: e1570001 cmp r7, r1
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
19b28: e183b40b orr fp, r3, fp, lsl #8
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
19b2c: 0a000046 beq 19c4c <rtems_rfs_dir_read+0x294>
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
19b30: e357000a cmp r7, #10 19b34: e1a04000 mov r4, r0
19b38: da000008 ble 19b60 <rtems_rfs_dir_read+0x1a8>
19b3c: e595101c ldr r1, [r5, #28] 19b40: e35b0000 cmp fp, #0 19b44: 11570001 cmpne r7, r1 19b48: 33a01000 movcc r1, #0 19b4c: 23a01001 movcs r1, #1
19b50: 2a000002 bcs 19b60 <rtems_rfs_dir_read+0x1a8>
19b54: e5953014 ldr r3, [r5, #20] 19b58: e15b0003 cmp fp, r3
19b5c: 9a00000d bls 19b98 <rtems_rfs_dir_read+0x1e0>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
19b60: e3a00102 mov r0, #-2147483648 ; 0x80000000 <== NOT EXECUTED 19b64: e3a01000 mov r1, #0 <== NOT EXECUTED 19b68: ebffddbf bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 19b6c: e3500000 cmp r0, #0 <== NOT EXECUTED 19b70: 0a00004c beq 19ca8 <rtems_rfs_dir_read+0x2f0> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
19b74: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 19b78: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 19b7c: e58d3000 str r3, [sp] <== NOT EXECUTED 19b80: e59f0158 ldr r0, [pc, #344] ; 19ce0 <rtems_rfs_dir_read+0x328><== NOT EXECUTED 19b84: e5921008 ldr r1, [r2, #8] <== NOT EXECUTED 19b88: e1a0300b mov r3, fp <== NOT EXECUTED 19b8c: e1a02007 mov r2, r7 <== NOT EXECUTED 19b90: eb0013a5 bl 1ea2c <printf> <== NOT EXECUTED 19b94: ea000043 b 19ca8 <rtems_rfs_dir_read+0x2f0> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
19b98: e3a0be11 mov fp, #272 ; 0x110 19b9c: e1a0200b mov r2, fp 19ba0: e1a0000a mov r0, sl 19ba4: eb00132f bl 1e868 <memset>
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
*length += elength;
19ba8: e5983000 ldr r3, [r8]
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
19bac: e99d0003 ldmib sp, {r0, r1}
dirent->d_reclen = sizeof (struct dirent);
*length += elength;
19bb0: e0873003 add r3, r7, r3
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
19bb4: e98a0003 stmib sl, {r0, r1}
dirent->d_reclen = sizeof (struct dirent);
19bb8: e1cab0bc strh fp, [sl, #12]
*length += elength;
19bbc: e5883000 str r3, [r8]
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
19bc0: e5952008 ldr r2, [r5, #8] 19bc4: e0699002 rsb r9, r9, r2 19bc8: e0679009 rsb r9, r7, r9
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
19bcc: e359000a cmp r9, #10
*length += remaining;
19bd0: d0893003 addle r3, r9, r3
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
19bd4: e247700a sub r7, r7, #10
*length += elength;
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
*length += remaining;
19bd8: d5883000 strle r3, [r8]
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
19bdc: e35700ff cmp r7, #255 ; 0xff 19be0: a3a070ff movge r7, #255 ; 0xff
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
19be4: e28a8010 add r8, sl, #16 19be8: e286100a add r1, r6, #10 19bec: e1a02007 mov r2, r7 19bf0: e1a00008 mov r0, r8 19bf4: eb001298 bl 1e65c <memcpy>
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
19bf8: e5d63001 ldrb r3, [r6, #1] 19bfc: e5d62000 ldrb r2, [r6] 19c00: e1a03803 lsl r3, r3, #16 19c04: e1833c02 orr r3, r3, r2, lsl #24 19c08: e5d62003 ldrb r2, [r6, #3] 19c0c: e1833002 orr r3, r3, r2 19c10: e5d62002 ldrb r2, [r6, #2] 19c14: e1833402 orr r3, r3, r2, lsl #8 19c18: e58a3000 str r3, [sl]
dirent->d_namlen = elength;
19c1c: e1ca70be strh r7, [sl, #14]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
19c20: e3a00102 mov r0, #-2147483648 ; 0x80000000 19c24: e3a01000 mov r1, #0 19c28: ebffdd8f bl 1126c <rtems_rfs_trace> 19c2c: e3500000 cmp r0, #0
19c30: 0a00001f beq 19cb4 <rtems_rfs_dir_read+0x2fc>
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
19c34: e99a0006 ldmib sl, {r1, r2} <== NOT EXECUTED
19c38: e58d8000 str r8, [sp] <== NOT EXECUTED
19c3c: e59f00a0 ldr r0, [pc, #160] ; 19ce4 <rtems_rfs_dir_read+0x32c><== NOT EXECUTED
19c40: e59a3000 ldr r3, [sl] <== NOT EXECUTED
19c44: eb001378 bl 1ea2c <printf> <== NOT EXECUTED
19c48: ea000019 b 19cb4 <rtems_rfs_dir_read+0x2fc> <== NOT EXECUTED
dirent->d_off, dirent->d_ino, dirent->d_name);
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
19c4c: e5953008 ldr r3, [r5, #8] 19c50: e0699003 rsb r9, r9, r3 19c54: e5983000 ldr r3, [r8] 19c58: e0839009 add r9, r3, r9 19c5c: e5889000 str r9, [r8]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
19c60: e3a00102 mov r0, #-2147483648 ; 0x80000000 19c64: e3a01000 mov r1, #0 19c68: ebffdd7f bl 1126c <rtems_rfs_trace> 19c6c: e3500000 cmp r0, #0
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
19c70: 159f0070 ldrne r0, [pc, #112] ; 19ce8 <rtems_rfs_dir_read+0x330>
19c74: 199d0006 ldmibne sp, {r1, r2}
19c78: 15983000 ldrne r3, [r8]
19c7c: 1b00136a blne 1ea2c <printf>
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
19c80: e1a00005 mov r0, r5 19c84: e1a01004 mov r1, r4 19c88: e28d206c add r2, sp, #108 ; 0x6c 19c8c: ebfff840 bl 17d94 <rtems_rfs_block_map_next_block>
if (rc == ENXIO)
19c90: e3500006 cmp r0, #6
19c94: 0a000005 beq 19cb0 <rtems_rfs_dir_read+0x2f8>
/*
* Look for an empty entry and if this is the last block that is the end of
* the directory.
*/
while (rc == 0)
19c98: e3500000 cmp r0, #0 <== NOT EXECUTED 19c9c: 0affff8a beq 19acc <rtems_rfs_dir_read+0x114> <== NOT EXECUTED 19ca0: e1a04000 mov r4, r0 <== NOT EXECUTED 19ca4: ea000002 b 19cb4 <rtems_rfs_dir_read+0x2fc> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: "
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04" PRIx32 "\n",
rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
rc = EIO;
19ca8: e3a04005 mov r4, #5 <== NOT EXECUTED 19cac: ea000000 b 19cb4 <rtems_rfs_dir_read+0x2fc> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
19cb0: e3a04002 mov r4, #2
}
rtems_rfs_buffer_handle_close (fs, &buffer);
19cb4: e28d1060 add r1, sp, #96 ; 0x60 19cb8: e1a00005 mov r0, r5 19cbc: ebfffc3b bl 18db0 <rtems_rfs_buffer_handle_close>
rtems_rfs_block_map_close (fs, &map);
19cc0: e1a00005 mov r0, r5 19cc4: e28d1010 add r1, sp, #16 19cc8: ebfff74b bl 179fc <rtems_rfs_block_map_close>
return rc; }
19ccc: e1a00004 mov r0, r4
19cd0: e28dd070 add sp, sp, #112 ; 0x70
19cd4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00019ebc <rtems_rfs_file_close>:
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
19ebc: e92d41f0 push {r4, r5, r6, r7, r8, lr}
19ec0: e1a06000 mov r6, r0
19ec4: e1a04001 mov r4, r1
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
19ec8: e3a00000 mov r0, #0 19ecc: e3a01010 mov r1, #16 19ed0: ebffdce5 bl 1126c <rtems_rfs_trace> 19ed4: e3500000 cmp r0, #0
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
handle->shared->inode.ino);
19ed8: 1594301c ldrne r3, [r4, #28]
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
19edc: 159f0250 ldrne r0, [pc, #592] ; 1a134 <rtems_rfs_file_close+0x278> 19ee0: 15931014 ldrne r1, [r3, #20] 19ee4: 1b0012d0 blne 1ea2c <printf>
handle->shared->inode.ino);
if (handle->shared->references > 0)
19ee8: e594101c ldr r1, [r4, #28] 19eec: e5913008 ldr r3, [r1, #8] 19ef0: e3530000 cmp r3, #0
handle->shared->references--;
19ef4: c2433001 subgt r3, r3, #1 19ef8: c5813008 strgt r3, [r1, #8]
if (handle->shared->references == 0)
19efc: e5913008 ldr r3, [r1, #8] 19f00: e3530000 cmp r3, #0
rtems_rfs_file_handle* handle)
{
int rrc;
int rc;
rrc = 0;
19f04: 13a05000 movne r5, #0
handle->shared->inode.ino);
if (handle->shared->references > 0)
handle->shared->references--;
if (handle->shared->references == 0)
19f08: 1a000071 bne 1a0d4 <rtems_rfs_file_close+0x218>
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
19f0c: e5913018 ldr r3, [r1, #24] 19f10: e3530000 cmp r3, #0
19f14: 1a000004 bne 19f2c <rtems_rfs_file_close+0x70>
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
19f18: e1a00006 mov r0, r6 19f1c: e281100c add r1, r1, #12 19f20: ebffd69a bl f990 <rtems_rfs_inode_load>
if (rrc == 0)
19f24: e2505000 subs r5, r0, #0
19f28: 1a000039 bne 1a014 <rtems_rfs_file_close+0x158>
{
/*
* @todo This could be clever and only update if different.
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
19f2c: e594301c ldr r3, [r4, #28] 19f30: e593208c ldr r2, [r3, #140] ; 0x8c
*/
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);
19f34: e5931018 ldr r1, [r3, #24] 19f38: e1a00c22 lsr r0, r2, #24 19f3c: e5c10010 strb r0, [r1, #16] 19f40: e5931018 ldr r1, [r3, #24] 19f44: e1a00822 lsr r0, r2, #16 19f48: e5c10011 strb r0, [r1, #17] 19f4c: e5931018 ldr r1, [r3, #24] 19f50: e1a00422 lsr r0, r2, #8 19f54: e5c10012 strb r0, [r1, #18] 19f58: e5931018 ldr r1, [r3, #24] 19f5c: e5c12013 strb r2, [r1, #19]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
19f60: e3a01001 mov r1, #1 19f64: e5c3101c strb r1, [r3, #28]
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
19f68: e594301c ldr r3, [r4, #28] 19f6c: e5932090 ldr r2, [r3, #144] ; 0x90
*/
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);
19f70: e5930018 ldr r0, [r3, #24] 19f74: e1a0cc22 lsr ip, r2, #24 19f78: e5c0c014 strb ip, [r0, #20] 19f7c: e5930018 ldr r0, [r3, #24] 19f80: e1a0c822 lsr ip, r2, #16 19f84: e5c0c015 strb ip, [r0, #21] 19f88: e5930018 ldr r0, [r3, #24] 19f8c: e1a0c422 lsr ip, r2, #8 19f90: e5c0c016 strb ip, [r0, #22] 19f94: e5930018 ldr r0, [r3, #24] 19f98: e5c02017 strb r2, [r0, #23]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
19f9c: e5c3101c strb r1, [r3, #28]
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
19fa0: e594301c ldr r3, [r4, #28] 19fa4: e5932094 ldr r2, [r3, #148] ; 0x94
*/
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);
19fa8: e5930018 ldr r0, [r3, #24] 19fac: e1a0cc22 lsr ip, r2, #24 19fb0: e5c0c018 strb ip, [r0, #24] 19fb4: e5930018 ldr r0, [r3, #24] 19fb8: e1a0c822 lsr ip, r2, #16 19fbc: e5c0c019 strb ip, [r0, #25] 19fc0: e5930018 ldr r0, [r3, #24] 19fc4: e1a0c422 lsr ip, r2, #8 19fc8: e5c0c01a strb ip, [r0, #26] 19fcc: e5930018 ldr r0, [r3, #24] 19fd0: e5c0201b strb r2, [r0, #27]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
19fd4: e5c3101c strb r1, [r3, #28]
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
19fd8: e594301c ldr r3, [r4, #28] 19fdc: e5932084 ldr r2, [r3, #132] ; 0x84 19fe0: e593103c ldr r1, [r3, #60] ; 0x3c 19fe4: e1520001 cmp r2, r1
19fe8: 1a000003 bne 19ffc <rtems_rfs_file_close+0x140>
19fec: e5930088 ldr r0, [r3, #136] ; 0x88 19ff0: e5931040 ldr r1, [r3, #64] ; 0x40 19ff4: e1500001 cmp r0, r1
19ff8: 0a000004 beq 1a010 <rtems_rfs_file_close+0x154>
*/
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);
19ffc: e583203c str r2, [r3, #60] ; 0x3c <== NOT EXECUTED 1a000: e5932088 ldr r2, [r3, #136] ; 0x88 <== NOT EXECUTED 1a004: e5832040 str r2, [r3, #64] ; 0x40 <== NOT EXECUTED
map->dirty = true;
1a008: e3a02001 mov r2, #1 <== NOT EXECUTED 1a00c: e5c32034 strb r2, [r3, #52] ; 0x34 <== NOT EXECUTED
1a010: e3a05000 mov r5, #0
&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);
1a014: e594101c ldr r1, [r4, #28] 1a018: e1a00006 mov r0, r6 1a01c: e2811034 add r1, r1, #52 ; 0x34 1a020: ebfff675 bl 179fc <rtems_rfs_block_map_close>
if (rc > 0)
1a024: e2507000 subs r7, r0, #0
1a028: da00000f ble 1a06c <rtems_rfs_file_close+0x1b0>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
1a02c: e3a00000 mov r0, #0 <== NOT EXECUTED 1a030: e3a01010 mov r1, #16 <== NOT EXECUTED 1a034: ebffdc8c bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1a038: e3500000 cmp r0, #0 <== NOT EXECUTED 1a03c: 0a000008 beq 1a064 <rtems_rfs_file_close+0x1a8> <== NOT EXECUTED
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
1a040: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
1a044: e1a00007 mov r0, r7 <== NOT EXECUTED 1a048: e5938014 ldr r8, [r3, #20] <== NOT EXECUTED 1a04c: eb001724 bl 1fce4 <strerror> <== NOT EXECUTED 1a050: e1a01008 mov r1, r8 <== NOT EXECUTED 1a054: e1a03000 mov r3, r0 <== NOT EXECUTED 1a058: e1a02007 mov r2, r7 <== NOT EXECUTED 1a05c: e59f00d4 ldr r0, [pc, #212] ; 1a138 <rtems_rfs_file_close+0x27c><== NOT EXECUTED 1a060: eb001271 bl 1ea2c <printf> <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
1a064: e3550000 cmp r5, #0 <== NOT EXECUTED 1a068: 01a05007 moveq r5, r7 <== NOT EXECUTED
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
1a06c: e594101c ldr r1, [r4, #28] 1a070: e1a00006 mov r0, r6 1a074: e281100c add r1, r1, #12 1a078: ebffd6e2 bl fc08 <rtems_rfs_inode_close>
if (rc > 0)
1a07c: e2507000 subs r7, r0, #0
1a080: da00000f ble 1a0c4 <rtems_rfs_file_close+0x208>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
1a084: e3a00000 mov r0, #0 <== NOT EXECUTED 1a088: e3a01010 mov r1, #16 <== NOT EXECUTED 1a08c: ebffdc76 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1a090: e3500000 cmp r0, #0 <== NOT EXECUTED 1a094: 0a000008 beq 1a0bc <rtems_rfs_file_close+0x200> <== NOT EXECUTED
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
1a098: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
1a09c: e1a00007 mov r0, r7 <== NOT EXECUTED 1a0a0: e5938014 ldr r8, [r3, #20] <== NOT EXECUTED 1a0a4: eb00170e bl 1fce4 <strerror> <== NOT EXECUTED 1a0a8: e1a01008 mov r1, r8 <== NOT EXECUTED 1a0ac: e1a03000 mov r3, r0 <== NOT EXECUTED 1a0b0: e1a02007 mov r2, r7 <== NOT EXECUTED 1a0b4: e59f0080 ldr r0, [pc, #128] ; 1a13c <rtems_rfs_file_close+0x280><== NOT EXECUTED 1a0b8: eb00125b bl 1ea2c <printf> <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
1a0bc: e3550000 cmp r5, #0 <== NOT EXECUTED 1a0c0: 01a05007 moveq r5, r7 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
1a0c4: e594001c ldr r0, [r4, #28] 1a0c8: ebffee20 bl 15950 <_Chain_Extract>
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
1a0cc: e594001c ldr r0, [r4, #28] 1a0d0: ebffb1ce bl 6810 <free>
*/
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);
1a0d4: e1a00006 mov r0, r6 1a0d8: e2841004 add r1, r4, #4 1a0dc: ebfff936 bl 185bc <rtems_rfs_buffer_handle_release>
handle->dirty = false;
1a0e0: e3a03000 mov r3, #0
rc = rtems_rfs_buffer_handle_close (fs, &handle->buffer);
if ((rrc == 0) && (rc > 0))
rrc = rc;
if (rrc > 0)
1a0e4: e1550003 cmp r5, r3 1a0e8: e5c43004 strb r3, [r4, #4]
handle->bnum = 0;
1a0ec: e5843008 str r3, [r4, #8]
handle->buffer = NULL;
1a0f0: e584300c str r3, [r4, #12]
1a0f4: da00000a ble 1a124 <rtems_rfs_file_close+0x268>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
1a0f8: e3a00000 mov r0, #0 <== NOT EXECUTED 1a0fc: e3a01010 mov r1, #16 <== NOT EXECUTED 1a100: ebffdc59 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1a104: e3500000 cmp r0, #0 <== NOT EXECUTED 1a108: 0a000005 beq 1a124 <rtems_rfs_file_close+0x268> <== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
1a10c: e1a00005 mov r0, r5 <== NOT EXECUTED 1a110: eb0016f3 bl 1fce4 <strerror> <== NOT EXECUTED 1a114: e1a01005 mov r1, r5 <== NOT EXECUTED 1a118: e1a02000 mov r2, r0 <== NOT EXECUTED 1a11c: e59f001c ldr r0, [pc, #28] ; 1a140 <rtems_rfs_file_close+0x284><== NOT EXECUTED 1a120: eb001241 bl 1ea2c <printf> <== NOT EXECUTED
}
free (handle);
1a124: e1a00004 mov r0, r4 1a128: ebffb1b8 bl 6810 <free>
return rrc;
}
1a12c: e1a00005 mov r0, r5
1a130: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
0001a33c <rtems_rfs_file_io_end>:
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
1a33c: e92d45f3 push {r0, r1, r4, r5, r6, r7, r8, sl, lr}
1a340: e1a04000 mov r4, r0
1a344: e1a06001 mov r6, r1
bool atime;
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1a348: e3a00000 mov r0, #0 1a34c: e3a01020 mov r1, #32
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
1a350: e20250ff and r5, r2, #255 ; 0xff
bool atime;
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1a354: ebffdbc4 bl 1126c <rtems_rfs_trace> 1a358: e3500000 cmp r0, #0
1a35c: 0a000006 beq 1a37c <rtems_rfs_file_io_end+0x40>
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
1a360: e59f31d0 ldr r3, [pc, #464] ; 1a538 <rtems_rfs_file_io_end+0x1fc><== NOT EXECUTED 1a364: e3550000 cmp r5, #0 <== NOT EXECUTED 1a368: e59f11cc ldr r1, [pc, #460] ; 1a53c <rtems_rfs_file_io_end+0x200><== NOT EXECUTED 1a36c: e59f01cc ldr r0, [pc, #460] ; 1a540 <rtems_rfs_file_io_end+0x204><== NOT EXECUTED 1a370: 11a01003 movne r1, r3 <== NOT EXECUTED 1a374: e1a02006 mov r2, r6 <== NOT EXECUTED 1a378: eb0011ab bl 1ea2c <printf> <== NOT EXECUTED
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
1a37c: e594800c ldr r8, [r4, #12] 1a380: e3580000 cmp r8, #0
1a384: 0a000015 beq 1a3e0 <rtems_rfs_file_io_end+0xa4>
{
if (!read)
1a388: e3550000 cmp r5, #0
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
1a38c: 03a03001 moveq r3, #1 1a390: 05c43004 strbeq r3, [r4, #4]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
1a394: e594301c ldr r3, [r4, #28] 1a398: e2841004 add r1, r4, #4 1a39c: e5930098 ldr r0, [r3, #152] ; 0x98 1a3a0: ebfff885 bl 185bc <rtems_rfs_buffer_handle_release>
rtems_rfs_file_buffer (handle));
if (rc > 0)
1a3a4: e2508000 subs r8, r0, #0
1a3a8: da00000c ble 1a3e0 <rtems_rfs_file_io_end+0xa4>
{
printf (
1a3ac: e59f3184 ldr r3, [pc, #388] ; 1a538 <rtems_rfs_file_io_end+0x1fc><== NOT EXECUTED 1a3b0: e59f2184 ldr r2, [pc, #388] ; 1a53c <rtems_rfs_file_io_end+0x200><== NOT EXECUTED 1a3b4: e3550000 cmp r5, #0 <== NOT EXECUTED 1a3b8: 01a05002 moveq r5, r2 <== NOT EXECUTED 1a3bc: 11a05003 movne r5, r3 <== NOT EXECUTED 1a3c0: eb001647 bl 1fce4 <strerror> <== NOT EXECUTED 1a3c4: e1a01005 mov r1, r5 <== NOT EXECUTED 1a3c8: e58d0000 str r0, [sp] <== NOT EXECUTED 1a3cc: e1a02006 mov r2, r6 <== NOT EXECUTED 1a3d0: e1a03008 mov r3, r8 <== NOT EXECUTED 1a3d4: e59f0168 ldr r0, [pc, #360] ; 1a544 <rtems_rfs_file_io_end+0x208><== NOT EXECUTED 1a3d8: eb001193 bl 1ea2c <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;
1a3dc: ea000053 b 1a530 <rtems_rfs_file_io_end+0x1f4> <== 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;
1a3e0: e5943014 ldr r3, [r4, #20] 1a3e4: e0866003 add r6, r6, r3
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
1a3e8: e594301c ldr r3, [r4, #28] 1a3ec: e5932098 ldr r2, [r3, #152] ; 0x98 1a3f0: e5922008 ldr r2, [r2, #8]
* 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;
if (handle->bpos.boff >=
1a3f4: e1560002 cmp r6, r2
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
1a3f8: 25941010 ldrcs r1, [r4, #16]
* 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;
1a3fc: e5846014 str r6, [r4, #20]
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
1a400: 22811001 addcs r1, r1, #1
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
1a404: 20626006 rsbcs r6, r2, r6
handle->bpos.boff += size;
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
1a408: 25841010 strcs r1, [r4, #16]
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
1a40c: 25846014 strcs r6, [r4, #20]
}
length = false;
mtime = false;
if (!read &&
1a410: e3550000 cmp r5, #0
1a414: 1a000013 bne 1a468 <rtems_rfs_file_io_end+0x12c>
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
1a418: e5942010 ldr r2, [r4, #16]
}
length = false;
mtime = false;
if (!read &&
1a41c: e3520000 cmp r2, #0 1a420: e593103c ldr r1, [r3, #60] ; 0x3c
1a424: 0a000001 beq 1a430 <rtems_rfs_file_io_end+0xf4>
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
1a428: e3510000 cmp r1, #0
1a42c: 0a000008 beq 1a454 <rtems_rfs_file_io_end+0x118>
1a430: e1520001 cmp r2, r1
1a434: 2a000006 bcs 1a454 <rtems_rfs_file_io_end+0x118>
1a438: e2411001 sub r1, r1, #1 1a43c: e1520001 cmp r2, r1
1a440: 1a000008 bne 1a468 <rtems_rfs_file_io_end+0x12c>
1a444: e5941014 ldr r1, [r4, #20] 1a448: e5932040 ldr r2, [r3, #64] ; 0x40 1a44c: e1510002 cmp r1, r2
1a450: 9a000004 bls 1a468 <rtems_rfs_file_io_end+0x12c>
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
1a454: e5942014 ldr r2, [r4, #20]
map->dirty = true;
1a458: e3a0a001 mov sl, #1
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
1a45c: e5832040 str r2, [r3, #64] ; 0x40
map->dirty = true;
1a460: e5c3a034 strb sl, [r3, #52] ; 0x34 1a464: ea000000 b 1a46c <rtems_rfs_file_io_end+0x130>
handle->bpos.bno++;
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
}
length = false;
mtime = false;
1a468: e3a0a000 mov sl, #0
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
1a46c: e5943000 ldr r3, [r4] 1a470: e3130001 tst r3, #1 1a474: 13a07000 movne r7, #0 1a478: 03a07001 moveq r7, #1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
1a47c: e3130002 tst r3, #2 1a480: 01a0600a moveq r6, sl 1a484: 13a06000 movne r6, #0
length = rtems_rfs_file_update_length (handle) && length;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1a488: e3a00000 mov r0, #0
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
length = rtems_rfs_file_update_length (handle) && length;
1a48c: e3130004 tst r3, #4
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1a490: e3a01020 mov r1, #32
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
length = rtems_rfs_file_update_length (handle) && length;
1a494: 13a0a000 movne sl, #0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1a498: ebffdb73 bl 1126c <rtems_rfs_trace> 1a49c: e3500000 cmp r0, #0
1a4a0: 0a00000d beq 1a4dc <rtems_rfs_file_io_end+0x1a0>
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
1a4a4: e3560000 cmp r6, #0 <== NOT EXECUTED
1a4a8: 03a0002d moveq r0, #45 ; 0x2d <== NOT EXECUTED
1a4ac: 13a0004d movne r0, #77 ; 0x4d <== NOT EXECUTED
1a4b0: e35a0000 cmp sl, #0 <== NOT EXECUTED
1a4b4: 03a0302d moveq r3, #45 ; 0x2d <== NOT EXECUTED
1a4b8: 13a0304c movne r3, #76 ; 0x4c <== NOT EXECUTED
1a4bc: e2841010 add r1, r4, #16 <== NOT EXECUTED
1a4c0: e3570000 cmp r7, #0 <== NOT EXECUTED
1a4c4: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
1a4c8: e88d0009 stm sp, {r0, r3} <== NOT EXECUTED
1a4cc: e59f0074 ldr r0, [pc, #116] ; 1a548 <rtems_rfs_file_io_end+0x20c><== NOT EXECUTED
1a4d0: 03a0302d moveq r3, #45 ; 0x2d <== NOT EXECUTED
1a4d4: 13a03041 movne r3, #65 ; 0x41 <== NOT EXECUTED
1a4d8: eb001153 bl 1ea2c <printf> <== NOT EXECUTED
handle->bpos.bno, handle->bpos.boff,
atime ? 'A' : '-', mtime ? 'M' : '-', length ? 'L' : '-');
if (atime || mtime)
1a4dc: e3570000 cmp r7, #0
1a4e0: 1a000001 bne 1a4ec <rtems_rfs_file_io_end+0x1b0>
1a4e4: e3560000 cmp r6, #0 <== NOT EXECUTED 1a4e8: 0a00000a beq 1a518 <rtems_rfs_file_io_end+0x1dc> <== NOT EXECUTED
{
time_t now = time (NULL);
1a4ec: e3a00000 mov r0, #0 1a4f0: eb002188 bl 22b18 <time>
if (read && atime)
1a4f4: e3550000 cmp r5, #0
1a4f8: 0a000003 beq 1a50c <rtems_rfs_file_io_end+0x1d0>
1a4fc: e3570000 cmp r7, #0
handle->shared->atime = now;
1a500: 1594301c ldrne r3, [r4, #28] 1a504: 1583008c strne r0, [r3, #140] ; 0x8c 1a508: ea000002 b 1a518 <rtems_rfs_file_io_end+0x1dc>
if (!read && mtime)
1a50c: e3560000 cmp r6, #0
handle->shared->mtime = now;
1a510: 1594301c ldrne r3, [r4, #28] 1a514: 15830090 strne r0, [r3, #144] ; 0x90
} if (length)
1a518: e35a0000 cmp sl, #0
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
1a51c: 1594301c ldrne r3, [r4, #28]
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
1a520: 1593203c ldrne r2, [r3, #60] ; 0x3c 1a524: 15832084 strne r2, [r3, #132] ; 0x84
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
1a528: 15932040 ldrne r2, [r3, #64] ; 0x40 1a52c: 15832088 strne r2, [r3, #136] ; 0x88
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
1a530: e1a00008 mov r0, r8
1a534: e8bd85fc pop {r2, r3, r4, r5, r6, r7, r8, sl, pc}
0001a54c <rtems_rfs_file_io_release>:
int
rtems_rfs_file_io_release (rtems_rfs_file_handle* handle)
{
1a54c: e1a01000 mov r1, r0
int rc = 0; if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
1a550: e590000c ldr r0, [r0, #12] 1a554: e3500000 cmp r0, #0 1a558: 012fff1e bxeq lr
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
1a55c: e591301c ldr r3, [r1, #28] <== NOT EXECUTED 1a560: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 1a564: e2811004 add r1, r1, #4 <== NOT EXECUTED 1a568: eafff813 b 185bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
0001a144 <rtems_rfs_file_io_start>:
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
1a144: e92d40f1 push {r0, r4, r5, r6, r7, lr}
1a148: e1a04000 mov r4, r0
1a14c: e1a06001 mov r6, r1
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1a150: e3a00000 mov r0, #0 1a154: e3a01020 mov r1, #32
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
1a158: e20250ff and r5, r2, #255 ; 0xff
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1a15c: ebffdc42 bl 1126c <rtems_rfs_trace> 1a160: e3500000 cmp r0, #0
1a164: 0a000007 beq 1a188 <rtems_rfs_file_io_start+0x44>
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
1a168: e59f31ac ldr r3, [pc, #428] ; 1a31c <rtems_rfs_file_io_start+0x1d8><== NOT EXECUTED
1a16c: e3550000 cmp r5, #0 <== NOT EXECUTED
1a170: e2842010 add r2, r4, #16 <== NOT EXECUTED
1a174: e59f11a4 ldr r1, [pc, #420] ; 1a320 <rtems_rfs_file_io_start+0x1dc><== NOT EXECUTED
1a178: e59f01a4 ldr r0, [pc, #420] ; 1a324 <rtems_rfs_file_io_start+0x1e0><== NOT EXECUTED
1a17c: 11a01003 movne r1, r3 <== NOT EXECUTED
1a180: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
1a184: eb001228 bl 1ea2c <printf> <== NOT EXECUTED
read ? "read" : "write", handle->bpos.bno, handle->bpos.boff);
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
1a188: e594700c ldr r7, [r4, #12] 1a18c: e3570000 cmp r7, #0
1a190: 1a000041 bne 1a29c <rtems_rfs_file_io_start+0x158>
bool request_read;
int rc;
request_read = read;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
1a194: e594101c ldr r1, [r4, #28] 1a198: e2842010 add r2, r4, #16 1a19c: e5910098 ldr r0, [r1, #152] ; 0x98 1a1a0: e1a0300d mov r3, sp 1a1a4: e2811034 add r1, r1, #52 ; 0x34 1a1a8: ebfff686 bl 17bc8 <rtems_rfs_block_map_find>
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
1a1ac: e3500000 cmp r0, #0
1a1b0: da000017 ble 1a214 <rtems_rfs_file_io_start+0xd0>
{
/*
* Has the read reached the EOF ?
*/
if (read && (rc == ENXIO))
1a1b4: e3550000 cmp r5, #0
1a1b8: 0a000003 beq 1a1cc <rtems_rfs_file_io_start+0x88>
1a1bc: e3500006 cmp r0, #6 <== NOT EXECUTED
{
*available = 0;
1a1c0: 05867000 streq r7, [r6] <== NOT EXECUTED
return 0;
1a1c4: 01a00007 moveq r0, r7 <== NOT EXECUTED 1a1c8: ea000052 b 1a318 <rtems_rfs_file_io_start+0x1d4> <== NOT EXECUTED
}
if (rc != ENXIO)
1a1cc: e3500006 cmp r0, #6
1a1d0: 1a000050 bne 1a318 <rtems_rfs_file_io_start+0x1d4>
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1a1d4: e3a00000 mov r0, #0 1a1d8: e3a01020 mov r1, #32 1a1dc: ebffdc22 bl 1126c <rtems_rfs_trace> 1a1e0: e3500000 cmp r0, #0
printf ("rtems-rfs: file-io: start: grow\n");
1a1e4: 159f013c ldrne r0, [pc, #316] ; 1a328 <rtems_rfs_file_io_start+0x1e4> 1a1e8: 1b0012a7 blne 1ec8c <puts>
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
1a1ec: e594101c ldr r1, [r4, #28] 1a1f0: e3a02001 mov r2, #1 1a1f4: e5910098 ldr r0, [r1, #152] ; 0x98 1a1f8: e1a0300d mov r3, sp 1a1fc: e2811034 add r1, r1, #52 ; 0x34 1a200: ebfff6ee bl 17dc0 <rtems_rfs_block_map_grow>
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
1a204: e3500000 cmp r0, #0
return rc;
request_read = false;
1a208: d3a07000 movle r7, #0
printf ("rtems-rfs: file-io: start: grow\n");
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
1a20c: ca000041 bgt 1a318 <rtems_rfs_file_io_start+0x1d4>
1a210: ea00000d b 1a24c <rtems_rfs_file_io_start+0x108>
/*
* 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 &&
1a214: e3550000 cmp r5, #0 1a218: 11a07005 movne r7, r5
1a21c: 1a00000a bne 1a24c <rtems_rfs_file_io_start+0x108>
1a220: e5943014 ldr r3, [r4, #20] 1a224: e3530000 cmp r3, #0
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
request_read = true;
1a228: 13a07001 movne r7, #1
/*
* 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 &&
1a22c: 1a000006 bne 1a24c <rtems_rfs_file_io_start+0x108>
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
1a230: e594301c ldr r3, [r4, #28] 1a234: e5933098 ldr r3, [r3, #152] ; 0x98
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
(rtems_rfs_file_block_offset (handle) ||
1a238: e5967000 ldr r7, [r6] 1a23c: e5933008 ldr r3, [r3, #8] 1a240: e1570003 cmp r7, r3 1a244: 23a07000 movcs r7, #0 1a248: 33a07001 movcc r7, #1
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
request_read = true;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1a24c: e3a00000 mov r0, #0 1a250: e3a01020 mov r1, #32 1a254: ebffdc04 bl 1126c <rtems_rfs_trace> 1a258: e3500000 cmp r0, #0
1a25c: 0a000006 beq 1a27c <rtems_rfs_file_io_start+0x138>
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
1a260: e59f30c4 ldr r3, [pc, #196] ; 1a32c <rtems_rfs_file_io_start+0x1e8><== NOT EXECUTED 1a264: e3570000 cmp r7, #0 <== NOT EXECUTED 1a268: e59f20c0 ldr r2, [pc, #192] ; 1a330 <rtems_rfs_file_io_start+0x1ec><== NOT EXECUTED 1a26c: e59f00c0 ldr r0, [pc, #192] ; 1a334 <rtems_rfs_file_io_start+0x1f0><== NOT EXECUTED 1a270: e59d1000 ldr r1, [sp] <== NOT EXECUTED 1a274: 11a02003 movne r2, r3 <== NOT EXECUTED 1a278: eb0011eb bl 1ea2c <printf> <== NOT EXECUTED
block, request_read ? "yes" : "no");
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
1a27c: e594301c ldr r3, [r4, #28] 1a280: e2841004 add r1, r4, #4 1a284: e5930098 ldr r0, [r3, #152] ; 0x98 1a288: e59d2000 ldr r2, [sp] 1a28c: e1a03007 mov r3, r7 1a290: ebfff935 bl 1876c <rtems_rfs_buffer_handle_request>
rtems_rfs_file_buffer (handle),
block, request_read);
if (rc > 0)
1a294: e3500000 cmp r0, #0
1a298: ca00001e bgt 1a318 <rtems_rfs_file_io_start+0x1d4>
return rc;
}
if (read
1a29c: e3550000 cmp r5, #0
1a2a0: 0a00000c beq 1a2d8 <rtems_rfs_file_io_start+0x194>
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
1a2a4: e594301c ldr r3, [r4, #28] 1a2a8: e5932044 ldr r2, [r3, #68] ; 0x44 1a2ac: e3520000 cmp r2, #0 1a2b0: e593103c ldr r1, [r3, #60] ; 0x3c
1a2b4: 1a000001 bne 1a2c0 <rtems_rfs_file_io_start+0x17c>
1a2b8: e3510000 cmp r1, #0
1a2bc: 0a000002 beq 1a2cc <rtems_rfs_file_io_start+0x188>
1a2c0: e2411001 sub r1, r1, #1 1a2c4: e1520001 cmp r2, r1
1a2c8: 1a000002 bne 1a2d8 <rtems_rfs_file_io_start+0x194>
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
1a2cc: e5935040 ldr r5, [r3, #64] ; 0x40 1a2d0: e3550000 cmp r5, #0
1a2d4: 1a000002 bne 1a2e4 <rtems_rfs_file_io_start+0x1a0>
size = rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
else
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
1a2d8: e594301c ldr r3, [r4, #28] 1a2dc: e5933098 ldr r3, [r3, #152] ; 0x98 1a2e0: e5935008 ldr r5, [r3, #8]
*available = size - rtems_rfs_file_block_offset (handle);
1a2e4: e5943014 ldr r3, [r4, #20] 1a2e8: e0633005 rsb r3, r3, r5 1a2ec: e5863000 str r3, [r6]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1a2f0: e3a00000 mov r0, #0 1a2f4: e3a01020 mov r1, #32 1a2f8: ebffdbdb bl 1126c <rtems_rfs_trace> 1a2fc: e3500000 cmp r0, #0
1a300: 0a000004 beq 1a318 <rtems_rfs_file_io_start+0x1d4>
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
1a304: e59f002c ldr r0, [pc, #44] ; 1a338 <rtems_rfs_file_io_start+0x1f4><== NOT EXECUTED 1a308: e5961000 ldr r1, [r6] <== NOT EXECUTED 1a30c: e1a02005 mov r2, r5 <== NOT EXECUTED 1a310: eb0011c5 bl 1ea2c <printf> <== NOT EXECUTED
*available, size);
return 0;
1a314: e3a00000 mov r0, #0 <== NOT EXECUTED
}
1a318: e8bd80f8 pop {r3, r4, r5, r6, r7, pc}
0001a958 <rtems_rfs_file_open>:
int
rtems_rfs_file_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
int oflag,
rtems_rfs_file_handle** file)
{
1a958: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
1a95c: e1a06000 mov r6, r0
1a960: e1a08001 mov r8, r1
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
1a964: e3a00000 mov r0, #0 1a968: e3a01008 mov r1, #8
int
rtems_rfs_file_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
int oflag,
rtems_rfs_file_handle** file)
{
1a96c: e58d2000 str r2, [sp] 1a970: e1a0b003 mov fp, r3
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
1a974: ebffda3c bl 1126c <rtems_rfs_trace> 1a978: e3500000 cmp r0, #0
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
1a97c: 159f0290 ldrne r0, [pc, #656] ; 1ac14 <rtems_rfs_file_open+0x2bc> 1a980: 11a01008 movne r1, r8 1a984: 1b001028 blne 1ea2c <printf>
*file = NULL;
1a988: e3a07000 mov r7, #0 1a98c: e58b7000 str r7, [fp]
/* * 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));
1a990: e3a00020 mov r0, #32 1a994: ebffb10d bl 6dd0 <malloc>
if (!handle)
1a998: e2504000 subs r4, r0, #0
1a99c: 0a000099 beq 1ac08 <rtems_rfs_file_open+0x2b0>
return ENOMEM;
memset (handle, 0, sizeof (rtems_rfs_file_handle));
1a9a0: e1a01007 mov r1, r7 1a9a4: e3a02020 mov r2, #32 1a9a8: eb000fae bl 1e868 <memset>
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
1a9ac: e5c47004 strb r7, [r4, #4]
handle->bnum = 0;
1a9b0: e5847008 str r7, [r4, #8]
handle->buffer = NULL;
1a9b4: e584700c str r7, [r4, #12]
/*
* Scan the file system data list of open files for this ino. If found up
* the reference count and return the pointer to the data.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
1a9b8: e1a00006 mov r0, r6 1a9bc: e1a01008 mov r1, r8 1a9c0: ebffffd7 bl 1a924 <rtems_rfs_file_get_shared>
if (shared)
1a9c4: e2505000 subs r5, r0, #0
1a9c8: 0a000009 beq 1a9f4 <rtems_rfs_file_open+0x9c>
{
shared->references++;
1a9cc: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 1a9d0: e2833001 add r3, r3, #1 <== NOT EXECUTED 1a9d4: e5853008 str r3, [r5, #8] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
1a9d8: e3a00000 mov r0, #0 <== NOT EXECUTED 1a9dc: e3a01008 mov r1, #8 <== NOT EXECUTED 1a9e0: ebffda21 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1a9e4: e1500007 cmp r0, r7 <== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
1a9e8: 159f0228 ldrne r0, [pc, #552] ; 1ac18 <rtems_rfs_file_open+0x2c0><== NOT EXECUTED
*/
shared = rtems_rfs_file_get_shared (fs, ino);
if (shared)
{
shared->references++;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
1a9ec: 0a00007f beq 1abf0 <rtems_rfs_file_open+0x298> <== NOT EXECUTED 1a9f0: ea00007c b 1abe8 <rtems_rfs_file_open+0x290> <== 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));
1a9f4: e3a0009c mov r0, #156 ; 0x9c 1a9f8: ebffb0f4 bl 6dd0 <malloc>
if (!shared)
1a9fc: e2505000 subs r5, r0, #0
1aa00: 1a000008 bne 1aa28 <rtems_rfs_file_open+0xd0>
*/
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);
1aa04: e1a00006 mov r0, r6 <== NOT EXECUTED 1aa08: e2841004 add r1, r4, #4 <== NOT EXECUTED 1aa0c: ebfff6ea bl 185bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
1aa10: e5c45004 strb r5, [r4, #4] <== NOT EXECUTED
handle->bnum = 0;
1aa14: e5845008 str r5, [r4, #8] <== NOT EXECUTED
handle->buffer = NULL;
1aa18: e584500c str r5, [r4, #12] <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
1aa1c: e1a00004 mov r0, r4 <== NOT EXECUTED 1aa20: ebffaf7a bl 6810 <free> <== NOT EXECUTED 1aa24: ea000077 b 1ac08 <rtems_rfs_file_open+0x2b0> <== NOT EXECUTED
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
1aa28: e1a01007 mov r1, r7 1aa2c: e3a0209c mov r2, #156 ; 0x9c
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
1aa30: e285900c add r9, r5, #12
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
1aa34: eb000f8b bl 1e868 <memset>
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
1aa38: e1a00006 mov r0, r6 1aa3c: e1a01008 mov r1, r8 1aa40: e1a02009 mov r2, r9 1aa44: e3a03001 mov r3, #1 1aa48: ebffd3f9 bl fa34 <rtems_rfs_inode_open>
if (rc > 0)
1aa4c: e250a000 subs sl, r0, #0
1aa50: da00000b ble 1aa84 <rtems_rfs_file_open+0x12c>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
1aa54: e3a00000 mov r0, #0 <== NOT EXECUTED 1aa58: e3a01008 mov r1, #8 <== NOT EXECUTED 1aa5c: ebffda02 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1aa60: e3500000 cmp r0, #0 <== NOT EXECUTED 1aa64: 0a00001a beq 1aad4 <rtems_rfs_file_open+0x17c> <== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
1aa68: e1a0000a mov r0, sl <== NOT EXECUTED 1aa6c: eb00149c bl 1fce4 <strerror> <== NOT EXECUTED 1aa70: e1a0100a mov r1, sl <== NOT EXECUTED 1aa74: e1a02000 mov r2, r0 <== NOT EXECUTED 1aa78: e59f019c ldr r0, [pc, #412] ; 1ac1c <rtems_rfs_file_open+0x2c4><== NOT EXECUTED 1aa7c: eb000fea bl 1ea2c <printf> <== NOT EXECUTED 1aa80: ea000013 b 1aad4 <rtems_rfs_file_open+0x17c> <== 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);
1aa84: e1a00006 mov r0, r6 1aa88: e1a01009 mov r1, r9 1aa8c: e2852034 add r2, r5, #52 ; 0x34 1aa90: ebfff380 bl 17898 <rtems_rfs_block_map_open>
if (rc > 0)
1aa94: e250a000 subs sl, r0, #0
1aa98: da000019 ble 1ab04 <rtems_rfs_file_open+0x1ac>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
1aa9c: e3a00000 mov r0, #0 <== NOT EXECUTED 1aaa0: e3a01008 mov r1, #8 <== NOT EXECUTED 1aaa4: ebffd9f0 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1aaa8: e3500000 cmp r0, #0 <== NOT EXECUTED 1aaac: 0a000005 beq 1aac8 <rtems_rfs_file_open+0x170> <== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
1aab0: e1a0000a mov r0, sl <== NOT EXECUTED 1aab4: eb00148a bl 1fce4 <strerror> <== NOT EXECUTED 1aab8: e1a0100a mov r1, sl <== NOT EXECUTED 1aabc: e1a02000 mov r2, r0 <== NOT EXECUTED 1aac0: e59f0158 ldr r0, [pc, #344] ; 1ac20 <rtems_rfs_file_open+0x2c8><== NOT EXECUTED 1aac4: eb000fd8 bl 1ea2c <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
1aac8: e1a00006 mov r0, r6 <== NOT EXECUTED 1aacc: e1a01009 mov r1, r9 <== NOT EXECUTED 1aad0: ebffd44c bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED
free (shared);
1aad4: e1a00005 mov r0, r5 <== NOT EXECUTED 1aad8: ebffaf4c bl 6810 <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);
1aadc: e1a00006 mov r0, r6 <== NOT EXECUTED 1aae0: e2841004 add r1, r4, #4 <== NOT EXECUTED 1aae4: ebfff6b4 bl 185bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
1aae8: e3a03000 mov r3, #0 <== NOT EXECUTED 1aaec: e5c43004 strb r3, [r4, #4] <== NOT EXECUTED
handle->bnum = 0;
1aaf0: e5843008 str r3, [r4, #8] <== NOT EXECUTED
handle->buffer = NULL;
1aaf4: e584300c str r3, [r4, #12] <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
1aaf8: e1a00004 mov r0, r4 <== NOT EXECUTED 1aafc: ebffaf43 bl 6810 <free> <== NOT EXECUTED
return rc;
1ab00: ea000041 b 1ac0c <rtems_rfs_file_open+0x2b4> <== NOT EXECUTED
}
shared->references = 1;
1ab04: e3a03001 mov r3, #1 1ab08: e5853008 str r3, [r5, #8]
* @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);
1ab0c: e5953018 ldr r3, [r5, #24] 1ab10: e5d3200d ldrb r2, [r3, #13] 1ab14: e5d3100c ldrb r1, [r3, #12] 1ab18: e1a02802 lsl r2, r2, #16 1ab1c: e1822c01 orr r2, r2, r1, lsl #24 1ab20: e5d3100f ldrb r1, [r3, #15] 1ab24: e1822001 orr r2, r2, r1 1ab28: e5d3100e ldrb r1, [r3, #14] 1ab2c: e1822401 orr r2, r2, r1, lsl #8
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
1ab30: e5852084 str r2, [r5, #132] ; 0x84
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
1ab34: e5d3100a ldrb r1, [r3, #10] 1ab38: e5d3200b ldrb r2, [r3, #11]
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
1ab3c: e1822401 orr r2, r2, r1, lsl #8 1ab40: e5852088 str r2, [r5, #136] ; 0x88
* @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);
1ab44: e5d32011 ldrb r2, [r3, #17] 1ab48: e5d31010 ldrb r1, [r3, #16] 1ab4c: e1a02802 lsl r2, r2, #16 1ab50: e1822c01 orr r2, r2, r1, lsl #24 1ab54: e5d31013 ldrb r1, [r3, #19] 1ab58: e1822001 orr r2, r2, r1 1ab5c: e5d31012 ldrb r1, [r3, #18] 1ab60: e1822401 orr r2, r2, r1, lsl #8
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
1ab64: e585208c str r2, [r5, #140] ; 0x8c
* @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);
1ab68: e5d32015 ldrb r2, [r3, #21] 1ab6c: e5d31014 ldrb r1, [r3, #20] 1ab70: e1a02802 lsl r2, r2, #16 1ab74: e1822c01 orr r2, r2, r1, lsl #24 1ab78: e5d31017 ldrb r1, [r3, #23] 1ab7c: e1822001 orr r2, r2, r1 1ab80: e5d31016 ldrb r1, [r3, #22] 1ab84: e1822401 orr r2, r2, r1, lsl #8
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
1ab88: e5852090 str r2, [r5, #144] ; 0x90
* @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);
1ab8c: e5d32019 ldrb r2, [r3, #25] 1ab90: e5d31018 ldrb r1, [r3, #24] 1ab94: e1a02802 lsl r2, r2, #16 1ab98: e1822c01 orr r2, r2, r1, lsl #24 1ab9c: e5d3101b ldrb r1, [r3, #27] 1aba0: e5d3301a ldrb r3, [r3, #26] 1aba4: e1822001 orr r2, r2, r1 1aba8: e1823403 orr r3, r2, r3, lsl #8
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
1abac: e5853094 str r3, [r5, #148] ; 0x94
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
1abb0: e2860074 add r0, r6, #116 ; 0x74 1abb4: e1a01005 mov r1, r5
shared->fs = fs;
1abb8: e5856098 str r6, [r5, #152] ; 0x98 1abbc: ebffc2fb bl b7b0 <_Chain_Append>
rtems_chain_append (&fs->file_shares, &shared->link);
rtems_rfs_inode_unload (fs, &shared->inode, false);
1abc0: e1a01009 mov r1, r9 1abc4: e1a02007 mov r2, r7 1abc8: e1a00006 mov r0, r6 1abcc: ebffd3d2 bl fb1c <rtems_rfs_inode_unload>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
1abd0: e3a00000 mov r0, #0 1abd4: e3a01008 mov r1, #8 1abd8: ebffd9a3 bl 1126c <rtems_rfs_trace> 1abdc: e3500000 cmp r0, #0
1abe0: 0a000002 beq 1abf0 <rtems_rfs_file_open+0x298>
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
1abe4: e59f0038 ldr r0, [pc, #56] ; 1ac24 <rtems_rfs_file_open+0x2cc><== NOT EXECUTED 1abe8: e1a01008 mov r1, r8 <== NOT EXECUTED 1abec: eb000f8e bl 1ea2c <printf> <== NOT EXECUTED
}
handle->flags = oflag;
1abf0: e59d3000 ldr r3, [sp]
handle->shared = shared;
1abf4: e584501c str r5, [r4, #28]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
}
handle->flags = oflag;
1abf8: e5843000 str r3, [r4]
handle->shared = shared;
*file = handle;
return 0;
1abfc: e3a0a000 mov sl, #0
}
handle->flags = oflag;
handle->shared = shared;
*file = handle;
1ac00: e58b4000 str r4, [fp]
return 0;
1ac04: ea000000 b 1ac0c <rtems_rfs_file_open+0x2b4>
* shared node data so we do not have to be concerned with reference
* counting.
*/
handle = malloc (sizeof (rtems_rfs_file_handle));
if (!handle)
return ENOMEM;
1ac08: e3a0a00c mov sl, #12 <== NOT EXECUTED
handle->shared = shared;
*file = handle;
return 0;
}
1ac0c: e1a0000a mov r0, sl
1ac10: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
0001a56c <rtems_rfs_file_seek>:
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
1a56c: e92d41f1 push {r0, r4, r5, r6, r7, r8, lr}
1a570: e1a04000 mov r4, r0
1a574: e1a06001 mov r6, r1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1a578: e3a00000 mov r0, #0 1a57c: e3a01020 mov r1, #32
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
1a580: e1a07002 mov r7, r2 1a584: e1a08003 mov r8, r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1a588: ebffdb37 bl 1126c <rtems_rfs_trace> 1a58c: e3500000 cmp r0, #0
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
1a590: 159f00ac ldrne r0, [pc, #172] ; 1a644 <rtems_rfs_file_seek+0xd8> 1a594: 11a01006 movne r1, r6 1a598: 11a02007 movne r2, r7 1a59c: 1b001122 blne 1ea2c <printf>
* 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),
1a5a0: e594101c ldr r1, [r4, #28] 1a5a4: e5910098 ldr r0, [r1, #152] ; 0x98 1a5a8: e2811084 add r1, r1, #132 ; 0x84 1a5ac: ebfff4aa bl 1785c <rtems_rfs_block_get_size> 1a5b0: e1510007 cmp r1, r7 1a5b4: 01500006 cmpeq r0, r6
1a5b8: 3a00001a bcc 1a628 <rtems_rfs_file_seek+0xbc>
handle->shared))
{
rtems_rfs_file_set_bpos (handle, pos);
1a5bc: e594301c ldr r3, [r4, #28] 1a5c0: e2845010 add r5, r4, #16 1a5c4: e5930098 ldr r0, [r3, #152] ; 0x98 1a5c8: e1a01006 mov r1, r6 1a5cc: e1a03005 mov r3, r5 1a5d0: e1a02007 mov r2, r7 1a5d4: ebfff470 bl 1779c <rtems_rfs_block_get_bpos>
/*
* 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))
1a5d8: e594300c ldr r3, [r4, #12] 1a5dc: e3530000 cmp r3, #0
1a5e0: 0a000014 beq 1a638 <rtems_rfs_file_seek+0xcc>
{
rtems_rfs_buffer_block block;
int rc;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
1a5e4: e594101c ldr r1, [r4, #28] 1a5e8: e1a02005 mov r2, r5 1a5ec: e5910098 ldr r0, [r1, #152] ; 0x98 1a5f0: e1a0300d mov r3, sp 1a5f4: e2811034 add r1, r1, #52 ; 0x34 1a5f8: ebfff572 bl 17bc8 <rtems_rfs_block_map_find>
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
1a5fc: e3500000 cmp r0, #0
1a600: ca00000e bgt 1a640 <rtems_rfs_file_seek+0xd4>
return rc;
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
1a604: e5942008 ldr r2, [r4, #8] 1a608: e59d3000 ldr r3, [sp] 1a60c: e1520003 cmp r2, r3
1a610: 0a000008 beq 1a638 <rtems_rfs_file_seek+0xcc>
{
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
1a614: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 1a618: e2841004 add r1, r4, #4 <== NOT EXECUTED 1a61c: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 1a620: ebfff7e5 bl 185bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED 1a624: ea000001 b 1a630 <rtems_rfs_file_seek+0xc4> <== 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);
1a628: e1a00004 mov r0, r4 1a62c: ebffffc6 bl 1a54c <rtems_rfs_file_io_release>
if (rc > 0)
1a630: e3500000 cmp r0, #0
1a634: ca000001 bgt 1a640 <rtems_rfs_file_seek+0xd4>
return rc;
}
*new_pos = pos;
1a638: e88800c0 stm r8, {r6, r7}
return 0;
1a63c: e3a00000 mov r0, #0
}
1a640: e8bd81f8 pop {r3, r4, r5, r6, r7, r8, pc}
0000e760 <rtems_rfs_format>:
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
e760: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
e764: e5d13015 ldrb r3, [r1, #21]
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
e768: e24dd0e8 sub sp, sp, #232 ; 0xe8
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
e76c: e3530000 cmp r3, #0
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
e770: e58d0004 str r0, [sp, #4]
e774: e1a04001 mov r4, r1
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
printf ("rtems-rfs: format: %s\n", name);
e778: 159f0ab0 ldrne r0, [pc, #2736] ; f230 <rtems_rfs_format+0xad0>
e77c: 159d1004 ldrne r1, [sp, #4]
e780: 1b0040a9 blne 1ea2c <printf>
memset (&fs, 0, sizeof (rtems_rfs_file_system));
e784: e3a01000 mov r1, #0
e788: e3a02084 mov r2, #132 ; 0x84
e78c: e28d0010 add r0, sp, #16
e790: eb004034 bl 1e868 <memset>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
e794: e28d3058 add r3, sp, #88 ; 0x58
e798: e58d3054 str r3, [sp, #84] ; 0x54
head->previous = NULL; tail->previous = head;
e79c: e28d3054 add r3, sp, #84 ; 0x54
e7a0: e58d305c str r3, [sp, #92] ; 0x5c
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
e7a4: e28d3068 add r3, sp, #104 ; 0x68
e7a8: e58d3064 str r3, [sp, #100] ; 0x64
head->previous = NULL; tail->previous = head;
e7ac: e28d3064 add r3, sp, #100 ; 0x64
e7b0: e58d306c str r3, [sp, #108] ; 0x6c
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
e7b4: e28d3078 add r3, sp, #120 ; 0x78
e7b8: e58d3074 str r3, [sp, #116] ; 0x74
head->previous = NULL; tail->previous = head;
e7bc: e28d3074 add r3, sp, #116 ; 0x74
e7c0: e58d307c str r3, [sp, #124] ; 0x7c
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
e7c4: e28d3088 add r3, sp, #136 ; 0x88
e7c8: e58d3084 str r3, [sp, #132] ; 0x84
head->previous = NULL; tail->previous = head;
e7cc: e28d3084 add r3, sp, #132 ; 0x84
e7d0: e58d308c str r3, [sp, #140] ; 0x8c
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;
e7d4: e3a03005 mov r3, #5
e7d8: e58d3050 str r3, [sp, #80] ; 0x50
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
e7dc: e59d0004 ldr r0, [sp, #4]
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;
e7e0: e3a03002 mov r3, #2
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
e7e4: e28d1010 add r1, sp, #16
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;
e7e8: e58d3010 str r3, [sp, #16]
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
e7ec: eb002876 bl 189cc <rtems_rfs_buffer_open>
if (rc > 0)
e7f0: e2505000 subs r5, r0, #0
e7f4: da000003 ble e808 <rtems_rfs_format+0xa8>
{
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
e7f8: eb004539 bl 1fce4 <strerror> <== NOT EXECUTED
e7fc: e1a02000 mov r2, r0 <== NOT EXECUTED
e800: e59f0a2c ldr r0, [pc, #2604] ; f234 <rtems_rfs_format+0xad4><== NOT EXECUTED
e804: ea000280 b f20c <rtems_rfs_format+0xaac> <== NOT EXECUTED
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
e808: e59d3020 ldr r3, [sp, #32]
e80c: e5931020 ldr r1, [r3, #32]
e810: e3510000 cmp r1, #0
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
e814: 059f0a1c ldreq r0, [pc, #2588] ; f238 <rtems_rfs_format+0xad8>
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
e818: 0a000139 beq ed04 <rtems_rfs_format+0x5a4>
static bool
rtems_rfs_check_config (rtems_rfs_file_system* fs,
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
e81c: e5943000 ldr r3, [r4]
if (!fs->block_size)
e820: e3530000 cmp r3, #0
static bool
rtems_rfs_check_config (rtems_rfs_file_system* fs,
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
e824: e58d3018 str r3, [sp, #24]
if (!fs->block_size)
e828: 1a00001d bne e8a4 <rtems_rfs_format+0x144>
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
e82c: e28d0010 add r0, sp, #16
e830: eb003100 bl 1ac38 <rtems_rfs_fs_media_size>
if (total_size >= GIGS (1))
e834: e59f2a00 ldr r2, [pc, #2560] ; f23c <rtems_rfs_format+0xadc>
e838: e3a03000 mov r3, #0
e83c: e1530001 cmp r3, r1
e840: 01520000 cmpeq r2, r0
e844: 2a00000e bcs e884 <rtems_rfs_format+0x124>
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
e848: e3a02601 mov r2, #1048576 ; 0x100000 <== NOT EXECUTED
e84c: e0922000 adds r2, r2, r0 <== NOT EXECUTED
e850: e3a03000 mov r3, #0 <== NOT EXECUTED
e854: e0a33001 adc r3, r3, r1 <== NOT EXECUTED
e858: e1a01a22 lsr r1, r2, #20 <== NOT EXECUTED
e85c: e1811603 orr r1, r1, r3, lsl #12 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
e860: e3a02001 mov r2, #1 <== NOT EXECUTED
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
int b;
for (b = 31; b > 0; b--)
e864: e3a0301f mov r3, #31 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
e868: e0110312 ands r0, r1, r2, lsl r3 <== NOT EXECUTED
e86c: 1a000001 bne e878 <rtems_rfs_format+0x118> <== NOT EXECUTED
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
int b;
for (b = 31; b > 0; b--)
e870: e2533001 subs r3, r3, #1 <== NOT EXECUTED
e874: 1afffffb bne e868 <rtems_rfs_format+0x108> <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
e878: e3a02001 mov r2, #1 <== NOT EXECUTED
e87c: e1a03312 lsl r3, r2, r3 <== NOT EXECUTED
e880: e58d3018 str r3, [sp, #24] <== NOT EXECUTED
}
if (fs->block_size < 512)
e884: e59d3018 ldr r3, [sp, #24]
e888: e3530c02 cmp r3, #512 ; 0x200
fs->block_size = 512;
e88c: 33a03c02 movcc r3, #512 ; 0x200
e890: 358d3018 strcc r3, [sp, #24]
if (fs->block_size > (4 * 1024))
e894: e59d3018 ldr r3, [sp, #24]
e898: e3530a01 cmp r3, #4096 ; 0x1000
fs->block_size = (4 * 1024);
e89c: 83a03a01 movhi r3, #4096 ; 0x1000
e8a0: 858d3018 strhi r3, [sp, #24]
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
e8a4: e59d3020 ldr r3, [sp, #32]
e8a8: e59d5018 ldr r5, [sp, #24]
e8ac: e5937020 ldr r7, [r3, #32]
e8b0: e1a00005 mov r0, r5
e8b4: e1a01007 mov r1, r7
e8b8: eb0071ce bl 2aff8 <__umodsi3>
e8bc: e2506000 subs r6, r0, #0
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
e8c0: 159f0978 ldrne r0, [pc, #2424] ; f240 <rtems_rfs_format+0xae0>
e8c4: 11a01005 movne r1, r5
e8c8: 11a02007 movne r2, r7
e8cc: 1a00024f bne f210 <rtems_rfs_format+0xab0>
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
e8d0: e5943004 ldr r3, [r4, #4]
e8d4: e1a05185 lsl r5, r5, #3
{
/*
* 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);
e8d8: e3530000 cmp r3, #0
e8dc: 01a03005 moveq r3, r5
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
e8e0: e1530005 cmp r3, r5
{
/*
* 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);
e8e4: e58d3038 str r3, [sp, #56] ; 0x38
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
{
printf ("group block count is higher than bits in block\n");
e8e8: 859f0954 ldrhi r0, [pc, #2388] ; f244 <rtems_rfs_format+0xae4>
* block.
*/
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
e8ec: 8a0000f8 bhi ecd4 <rtems_rfs_format+0x574>
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
e8f0: e28d0010 add r0, sp, #16
e8f4: eb0030cf bl 1ac38 <rtems_rfs_fs_media_size>
e8f8: e59d5018 ldr r5, [sp, #24]
e8fc: e1a03006 mov r3, r6
e900: e1a02005 mov r2, r5
e904: eb0076f0 bl 2c4cc <__udivdi3>
* 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));
e908: e1a06185 lsl r6, r5, #3
/* * 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),
e90c: e1a01006 mov r1, r6
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
e910: e1a08000 mov r8, r0
e914: e58d0014 str r0, [sp, #20]
/* * 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),
e918: ebffff75 bl e6f4 <rtems_rfs_rup_quotient>
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
e91c: e5943008 ldr r3, [r4, #8]
if (!fs->group_inodes)
e920: e3530000 cmp r3, #0
/* * 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),
e924: e1a07000 mov r7, r0
e928: e58d0034 str r0, [sp, #52] ; 0x34
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
e92c: e58d303c str r3, [sp, #60] ; 0x3c
if (!fs->group_inodes)
e930: 1a00000e bne e970 <rtems_rfs_format+0x210>
int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
/*
* The number of inodes per group is set as a percentage.
*/
if (config->inode_overhead)
e934: e594300c ldr r3, [r4, #12]
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
if (!fs->group_inodes)
{
int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
e938: e3530000 cmp r3, #0
e93c: 03a03001 moveq r3, #1
static int
rtems_rfs_inodes_from_percent (rtems_rfs_file_system* fs,
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
e940: e2480001 sub r0, r8, #1
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
e944: e0000093 mul r0, r3, r0
e948: e3a01064 mov r1, #100 ; 0x64
e94c: ebffcbfb bl 1940 <__aeabi_uidiv>
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
e950: e1a01007 mov r1, r7
e954: ebffff66 bl e6f4 <rtems_rfs_rup_quotient>
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
e958: e3a01038 mov r1, #56 ; 0x38
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
e95c: e1a07000 mov r7, r0
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
e960: e1a00005 mov r0, r5
e964: ebffcbf5 bl 1940 <__aeabi_uidiv>
e968: e0000097 mul r0, r7, r0
* 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);
e96c: e58d003c str r0, [sp, #60] ; 0x3c
}
/*
* 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;
e970: e1a00005 mov r0, r5
e974: e3a01038 mov r1, #56 ; 0x38
e978: ebffcbf0 bl 1940 <__aeabi_uidiv>
e97c: e1a05000 mov r5, r0
e980: e58d0040 str r0, [sp, #64] ; 0x40
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
e984: e1a01005 mov r1, r5
e988: e59d003c ldr r0, [sp, #60] ; 0x3c
e98c: ebffff58 bl e6f4 <rtems_rfs_rup_quotient>
fs->inodes_per_block) * fs->inodes_per_block;
e990: e0000095 mul r0, r5, r0
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;
e994: e5943010 ldr r3, [r4, #16]
fs->group_inodes =
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);
e998: e1560000 cmp r6, r0
e99c: 958d603c strls r6, [sp, #60] ; 0x3c
e9a0: 858d003c strhi r0, [sp, #60] ; 0x3c
fs->max_name_length = config->max_name_length;
if (!fs->max_name_length)
e9a4: e3530000 cmp r3, #0
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;
e9a8: e58d302c str r3, [sp, #44] ; 0x2c
if (!fs->max_name_length)
{
fs->max_name_length = 512;
e9ac: 03a03c02 moveq r3, #512 ; 0x200
e9b0: 058d302c streq r3, [sp, #44] ; 0x2c
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
e9b4: e5d43015 ldrb r3, [r4, #21]
e9b8: e3530000 cmp r3, #0
e9bc: 0a00003a beq eaac <rtems_rfs_format+0x34c>
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
e9c0: e28d0010 add r0, sp, #16 <== NOT EXECUTED
e9c4: eb00309b bl 1ac38 <rtems_rfs_fs_media_size> <== NOT EXECUTED
e9c8: e1a02001 mov r2, r1 <== NOT EXECUTED
e9cc: e1a01000 mov r1, r0 <== NOT EXECUTED
e9d0: e59f0870 ldr r0, [pc, #2160] ; f248 <rtems_rfs_format+0xae8><== NOT EXECUTED
e9d4: eb004014 bl 1ea2c <printf> <== NOT EXECUTED
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
e9d8: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
e9dc: e59f0868 ldr r0, [pc, #2152] ; f24c <rtems_rfs_format+0xaec><== NOT EXECUTED
e9e0: e593101c ldr r1, [r3, #28] <== NOT EXECUTED
e9e4: eb004010 bl 1ea2c <printf> <== NOT EXECUTED
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
e9e8: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
e9ec: e59f085c ldr r0, [pc, #2140] ; f250 <rtems_rfs_format+0xaf0><== NOT EXECUTED
e9f0: e5931020 ldr r1, [r3, #32] <== NOT EXECUTED
e9f4: eb00400c bl 1ea2c <printf> <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
e9f8: e28d0010 add r0, sp, #16 <== NOT EXECUTED
e9fc: eb003089 bl 1ac28 <rtems_rfs_fs_size> <== NOT EXECUTED
ea00: e1a02001 mov r2, r1 <== NOT EXECUTED
ea04: e1a01000 mov r1, r0 <== NOT EXECUTED
ea08: e59f0844 ldr r0, [pc, #2116] ; f254 <rtems_rfs_format+0xaf4><== NOT EXECUTED
ea0c: eb004006 bl 1ea2c <printf> <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
ea10: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED
ea14: e59f083c ldr r0, [pc, #2108] ; f258 <rtems_rfs_format+0xaf8><== NOT EXECUTED
ea18: eb004003 bl 1ea2c <printf> <== NOT EXECUTED
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
ea1c: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED
ea20: e59f0834 ldr r0, [pc, #2100] ; f25c <rtems_rfs_format+0xafc><== NOT EXECUTED
ea24: eb004000 bl 1ea2c <printf> <== NOT EXECUTED
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
ea28: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED
ea2c: e59f082c ldr r0, [pc, #2092] ; f260 <rtems_rfs_format+0xb00><== NOT EXECUTED
ea30: e1a01181 lsl r1, r1, #3 <== NOT EXECUTED
ea34: eb003ffc bl 1ea2c <printf> <== NOT EXECUTED
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
ea38: e3a01038 mov r1, #56 ; 0x38 <== NOT EXECUTED
ea3c: e59f0820 ldr r0, [pc, #2080] ; f264 <rtems_rfs_format+0xb04><== NOT EXECUTED
ea40: eb003ff9 bl 1ea2c <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
ea44: e59d3034 ldr r3, [sp, #52] ; 0x34 <== NOT EXECUTED
ea48: e59d603c ldr r6, [sp, #60] ; 0x3c <== NOT EXECUTED
fs.group_inodes * fs.group_count,
rtems_rfs_inode_overhead (&fs) / 10,
ea4c: e28d0010 add r0, sp, #16 <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
ea50: e0060693 mul r6, r3, r6 <== NOT EXECUTED
fs.group_inodes * fs.group_count,
rtems_rfs_inode_overhead (&fs) / 10,
ea54: ebffff2f bl e718 <rtems_rfs_inode_overhead> <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
ea58: e3a0100a mov r1, #10 <== NOT EXECUTED
fs.group_inodes * fs.group_count,
rtems_rfs_inode_overhead (&fs) / 10,
ea5c: e1a07000 mov r7, r0 <== NOT EXECUTED
printf ("rtems-rfs: format: block size = %zu\n",
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
ea60: eb007112 bl 2aeb0 <__aeabi_idiv> <== NOT EXECUTED
ea64: e3a0100a mov r1, #10 <== NOT EXECUTED
ea68: e1a05000 mov r5, r0 <== NOT EXECUTED
ea6c: e1a00007 mov r0, r7 <== NOT EXECUTED
ea70: eb007193 bl 2b0c4 <__modsi3> <== NOT EXECUTED
ea74: e1a02005 mov r2, r5 <== NOT EXECUTED
ea78: e1a03000 mov r3, r0 <== NOT EXECUTED
ea7c: e1a01006 mov r1, r6 <== NOT EXECUTED
ea80: e59f07e0 ldr r0, [pc, #2016] ; f268 <rtems_rfs_format+0xb08><== NOT EXECUTED
ea84: eb003fe8 bl 1ea2c <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);
ea88: e59d1034 ldr r1, [sp, #52] ; 0x34 <== NOT EXECUTED
ea8c: e59f07d8 ldr r0, [pc, #2008] ; f26c <rtems_rfs_format+0xb0c><== NOT EXECUTED
ea90: eb003fe5 bl 1ea2c <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
ea94: e59d1038 ldr r1, [sp, #56] ; 0x38 <== NOT EXECUTED
ea98: e59f07d0 ldr r0, [pc, #2000] ; f270 <rtems_rfs_format+0xb10><== NOT EXECUTED
ea9c: eb003fe2 bl 1ea2c <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
eaa0: e59f07cc ldr r0, [pc, #1996] ; f274 <rtems_rfs_format+0xb14><== NOT EXECUTED
eaa4: e59d103c ldr r1, [sp, #60] ; 0x3c <== NOT EXECUTED
eaa8: eb003fdf bl 1ea2c <printf> <== NOT EXECUTED
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
eaac: e28d7010 add r7, sp, #16
eab0: e1a00007 mov r0, r7
eab4: e59d1018 ldr r1, [sp, #24]
eab8: eb002856 bl 18c18 <rtems_rfs_buffer_setblksize>
if (rc > 0)
eabc: e2505000 subs r5, r0, #0
eac0: da000003 ble ead4 <rtems_rfs_format+0x374>
{
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
eac4: eb004486 bl 1fce4 <strerror> <== NOT EXECUTED
eac8: e1a02000 mov r2, r0 <== NOT EXECUTED
eacc: e59f07a4 ldr r0, [pc, #1956] ; f278 <rtems_rfs_format+0xb18><== NOT EXECUTED
ead0: ea0001cd b f20c <rtems_rfs_format+0xaac> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ead4: e3a05000 mov r5, #0
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);
ead8: e28d60d4 add r6, sp, #212 ; 0xd4
eadc: e1a00007 mov r0, r7
eae0: e1a01006 mov r1, r6
eae4: e1a02005 mov r2, r5
eae8: e1a03005 mov r3, r5
eaec: e5cd50d4 strb r5, [sp, #212] ; 0xd4
handle->bnum = 0;
eaf0: e58d50d8 str r5, [sp, #216] ; 0xd8
handle->buffer = NULL;
eaf4: e58d50dc str r5, [sp, #220] ; 0xdc
eaf8: eb00271b bl 1876c <rtems_rfs_buffer_handle_request>
if (rc > 0)
eafc: e2508000 subs r8, r0, #0
eb00: da000007 ble eb24 <rtems_rfs_format+0x3c4>
{
rtems_rfs_buffer_handle_close (fs, &handle);
eb04: e1a01006 mov r1, r6 <== NOT EXECUTED
eb08: e1a00007 mov r0, r7 <== NOT EXECUTED
eb0c: ebfffef0 bl e6d4 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
eb10: e1a00008 mov r0, r8 <== NOT EXECUTED
eb14: eb004472 bl 1fce4 <strerror> <== NOT EXECUTED
eb18: e1a02000 mov r2, r0 <== NOT EXECUTED
eb1c: e59f0758 ldr r0, [pc, #1880] ; f27c <rtems_rfs_format+0xb1c><== NOT EXECUTED
eb20: ea000068 b ecc8 <rtems_rfs_format+0x568> <== NOT EXECUTED
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
eb24: e59d30dc ldr r3, [sp, #220] ; 0xdc
eb28: e593801c ldr r8, [r3, #28]
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
eb2c: e3a010ff mov r1, #255 ; 0xff
eb30: e1a00008 mov r0, r8
eb34: e59d2018 ldr r2, [sp, #24]
eb38: eb003f4a bl 1e868 <memset>
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
eb3c: e3a03028 mov r3, #40 ; 0x28
eb40: e5c83000 strb r3, [r8]
eb44: e3a03009 mov r3, #9
eb48: e5c83001 strb r3, [r8, #1]
eb4c: e3a02001 mov r2, #1
eb50: e3a03020 mov r3, #32
eb54: e5c82003 strb r2, [r8, #3]
eb58: e5c83002 strb r3, [r8, #2]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
eb5c: e5c85004 strb r5, [r8, #4]
eb60: e5c85005 strb r5, [r8, #5]
eb64: e5c85006 strb r5, [r8, #6]
eb68: e5c85007 strb r5, [r8, #7]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
eb6c: e59d3014 ldr r3, [sp, #20]
eb70: e1a01c23 lsr r1, r3, #24
eb74: e5c8100c strb r1, [r8, #12]
eb78: e1a01823 lsr r1, r3, #16
eb7c: e5c8100d strb r1, [r8, #13]
eb80: e1a01423 lsr r1, r3, #8
eb84: e5c8100e strb r1, [r8, #14]
eb88: e5c8300f strb r3, [r8, #15]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
eb8c: e5dd301b ldrb r3, [sp, #27]
eb90: e5c83008 strb r3, [r8, #8]
eb94: e1dd31ba ldrh r3, [sp, #26]
eb98: e5c83009 strb r3, [r8, #9]
eb9c: e59d3018 ldr r3, [sp, #24]
eba0: e1a03423 lsr r3, r3, #8
eba4: e5c8300a strb r3, [r8, #10]
eba8: e59d3018 ldr r3, [sp, #24]
ebac: e5c8300b strb r3, [r8, #11]
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
ebb0: e5dd302b ldrb r3, [sp, #43] ; 0x2b
ebb4: e5c83010 strb r3, [r8, #16]
ebb8: e1dd32ba ldrh r3, [sp, #42] ; 0x2a
ebbc: e5c83011 strb r3, [r8, #17]
ebc0: e59d3028 ldr r3, [sp, #40] ; 0x28
ebc4: e1a03423 lsr r3, r3, #8
ebc8: e5c83012 strb r3, [r8, #18]
ebcc: e59d3028 ldr r3, [sp, #40] ; 0x28
ebd0: e5c83013 strb r3, [r8, #19]
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
ebd4: e5dd302f ldrb r3, [sp, #47] ; 0x2f
ebd8: e5c83014 strb r3, [r8, #20]
ebdc: e1dd32be ldrh r3, [sp, #46] ; 0x2e
ebe0: e5c83015 strb r3, [r8, #21]
ebe4: e59d302c ldr r3, [sp, #44] ; 0x2c
ebe8: e1a03423 lsr r3, r3, #8
ebec: e5c83016 strb r3, [r8, #22]
ebf0: e59d302c ldr r3, [sp, #44] ; 0x2c
ebf4: e5c83017 strb r3, [r8, #23]
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
ebf8: e5dd3037 ldrb r3, [sp, #55] ; 0x37
ebfc: e5c83018 strb r3, [r8, #24]
ec00: e1dd33b6 ldrh r3, [sp, #54] ; 0x36
ec04: e5c83019 strb r3, [r8, #25]
ec08: e59d3034 ldr r3, [sp, #52] ; 0x34
ec0c: e1a03423 lsr r3, r3, #8
ec10: e5c8301a strb r3, [r8, #26]
ec14: e59d3034 ldr r3, [sp, #52] ; 0x34
ec18: e5c8301b strb r3, [r8, #27]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
ec1c: e5dd303b ldrb r3, [sp, #59] ; 0x3b
ec20: e5c8301c strb r3, [r8, #28]
ec24: e1dd33ba ldrh r3, [sp, #58] ; 0x3a
ec28: e5c8301d strb r3, [r8, #29]
ec2c: e59d3038 ldr r3, [sp, #56] ; 0x38
ec30: e1a03423 lsr r3, r3, #8
ec34: e5c8301e strb r3, [r8, #30]
ec38: e59d3038 ldr r3, [sp, #56] ; 0x38
ec3c: e5c8301f strb r3, [r8, #31]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
ec40: e5dd303f ldrb r3, [sp, #63] ; 0x3f
ec44: e5c83020 strb r3, [r8, #32]
ec48: e1dd33be ldrh r3, [sp, #62] ; 0x3e
ec4c: e5c83021 strb r3, [r8, #33] ; 0x21
ec50: e59d303c ldr r3, [sp, #60] ; 0x3c
ec54: e1a03423 lsr r3, r3, #8
ec58: e5c83022 strb r3, [r8, #34] ; 0x22
ec5c: e59d303c ldr r3, [sp, #60] ; 0x3c
ec60: e5c83023 strb r3, [r8, #35] ; 0x23
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
ec64: e3a03038 mov r3, #56 ; 0x38
ec68: e5c85024 strb r5, [r8, #36] ; 0x24
ec6c: e5c85025 strb r5, [r8, #37] ; 0x25
ec70: e5c85026 strb r5, [r8, #38] ; 0x26
ec74: e5c83027 strb r3, [r8, #39] ; 0x27
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
ec78: e1a01006 mov r1, r6
ec7c: e1a00007 mov r0, r7
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);
rtems_rfs_buffer_mark_dirty (&handle);
ec80: e5cd20d4 strb r2, [sp, #212] ; 0xd4
rc = rtems_rfs_buffer_handle_release (fs, &handle);
ec84: eb00264c bl 185bc <rtems_rfs_buffer_handle_release>
if (rc > 0)
ec88: e2508000 subs r8, r0, #0
{
rtems_rfs_buffer_handle_close (fs, &handle);
ec8c: e1a01006 mov r1, r6
ec90: e1a00007 mov r0, r7
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);
if (rc > 0)
ec94: da000005 ble ecb0 <rtems_rfs_format+0x550>
{
rtems_rfs_buffer_handle_close (fs, &handle);
ec98: ebfffe8d bl e6d4 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
ec9c: e1a00008 mov r0, r8 <== NOT EXECUTED
eca0: eb00440f bl 1fce4 <strerror> <== NOT EXECUTED
eca4: e1a02000 mov r2, r0 <== NOT EXECUTED
eca8: e59f05d0 ldr r0, [pc, #1488] ; f280 <rtems_rfs_format+0xb20><== NOT EXECUTED
ecac: ea000005 b ecc8 <rtems_rfs_format+0x568> <== NOT EXECUTED
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
ecb0: ebfffe87 bl e6d4 <rtems_rfs_buffer_handle_close>
if (rc > 0)
ecb4: e2508000 subs r8, r0, #0
ecb8: da0000d1 ble f004 <rtems_rfs_format+0x8a4>
{
printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
ecbc: eb004408 bl 1fce4 <strerror> <== NOT EXECUTED
ecc0: e1a02000 mov r2, r0 <== NOT EXECUTED
ecc4: e59f05b8 ldr r0, [pc, #1464] ; f284 <rtems_rfs_format+0xb24><== NOT EXECUTED
ecc8: e1a01008 mov r1, r8 <== NOT EXECUTED
eccc: eb003f56 bl 1ea2c <printf> <== NOT EXECUTED
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
ecd0: e59f05b0 ldr r0, [pc, #1456] ; f288 <rtems_rfs_format+0xb28><== NOT EXECUTED
ecd4: eb003fec bl 1ec8c <puts> <== NOT EXECUTED
ecd8: ea00014d b f214 <rtems_rfs_format+0xab4> <== NOT EXECUTED
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
ecdc: e59d4038 ldr r4, [sp, #56] ; 0x38
ece0: e00a0594 mul sl, r4, r5
if (group_base > rtems_rfs_fs_blocks (fs))
ece4: e59d3014 ldr r3, [sp, #20]
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
ece8: e5db2014 ldrb r2, [fp, #20]
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
ecec: e28a8001 add r8, sl, #1
if (group_base > rtems_rfs_fs_blocks (fs))
ecf0: e1580003 cmp r8, r3
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
ecf4: e58d200c str r2, [sp, #12]
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
ecf8: 9a000003 bls ed0c <rtems_rfs_format+0x5ac>
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
ecfc: e59f0588 ldr r0, [pc, #1416] ; f28c <rtems_rfs_format+0xb2c><== NOT EXECUTED
ed00: e1a01005 mov r1, r5 <== NOT EXECUTED
ed04: eb003f48 bl 1ea2c <printf> <== NOT EXECUTED
ed08: ea000141 b f214 <rtems_rfs_format+0xab4> <== 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))
ed0c: e0882004 add r2, r8, r4
ed10: e1520003 cmp r2, r3
group_size = rtems_rfs_fs_blocks (fs) - group_base;
ed14: 80684003 rsbhi r4, r8, r3
if (verbose)
ed18: e3590000 cmp r9, #0
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
ed1c: 159f056c ldrne r0, [pc, #1388] ; f290 <rtems_rfs_format+0xb30>
ed20: 11a01005 movne r1, r5
ed24: 11a02008 movne r2, r8
ed28: 11a03004 movne r3, r4
ed2c: 1b003f3e blne 1ea2c <printf>
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ed30: e3a03000 mov r3, #0
printf ("\nrtems-rfs: write-group: handle open failed: %d: %s\n",
rc, strerror (rc));
return false;
}
if (verbose)
ed34: e1590003 cmp r9, r3
ed38: e5cd30d4 strb r3, [sp, #212] ; 0xd4
handle->bnum = 0;
ed3c: e58d30d8 str r3, [sp, #216] ; 0xd8
handle->buffer = NULL;
ed40: e58d30dc str r3, [sp, #220] ; 0xdc
printf (", blocks");
ed44: 159f0548 ldrne r0, [pc, #1352] ; f294 <rtems_rfs_format+0xb34>
ed48: 1b003f37 blne 1ea2c <printf>
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
ed4c: e28d00bc add r0, sp, #188 ; 0xbc
ed50: e1a01007 mov r1, r7
ed54: e1a02006 mov r2, r6
ed58: e1a03004 mov r3, r4
ed5c: e58d8000 str r8, [sp]
ed60: eb0021d2 bl 174b0 <rtems_rfs_bitmap_open>
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
ed64: e3500000 cmp r0, #0
ed68: da000008 ble ed90 <rtems_rfs_format+0x630>
ed6c: e1a0a000 mov sl, r0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
ed70: e1a01006 mov r1, r6 <== NOT EXECUTED
ed74: e1a00007 mov r0, r7 <== NOT EXECUTED
ed78: ebfffe55 bl e6d4 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
ed7c: e1a0000a mov r0, sl <== NOT EXECUTED
ed80: eb0043d7 bl 1fce4 <strerror> <== NOT EXECUTED
ed84: e1a03000 mov r3, r0 <== NOT EXECUTED
ed88: e59f0508 ldr r0, [pc, #1288] ; f298 <rtems_rfs_format+0xb38><== NOT EXECUTED
ed8c: ea000012 b eddc <rtems_rfs_format+0x67c> <== 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));
ed90: e59d30dc ldr r3, [sp, #220] ; 0xdc
ed94: e3a010ff mov r1, #255 ; 0xff
ed98: e593001c ldr r0, [r3, #28]
ed9c: e59d2018 ldr r2, [sp, #24]
eda0: eb003eb0 bl 1e868 <memset>
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
eda4: e28d00bc add r0, sp, #188 ; 0xbc
eda8: eb002136 bl 17288 <rtems_rfs_bitmap_map_clear_all>
if (rc > 0)
edac: e3500000 cmp r0, #0
edb0: da00000d ble edec <rtems_rfs_format+0x68c>
edb4: e1a0a000 mov sl, r0 <== NOT EXECUTED
{
rtems_rfs_bitmap_close (&bitmap);
edb8: e28d00bc add r0, sp, #188 ; 0xbc <== NOT EXECUTED
edbc: eb0021cf bl 17500 <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
edc0: e1a01006 mov r1, r6 <== NOT EXECUTED
edc4: e1a00007 mov r0, r7 <== NOT EXECUTED
edc8: ebfffe41 bl e6d4 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
edcc: e1a0000a mov r0, sl <== NOT EXECUTED
edd0: eb0043c3 bl 1fce4 <strerror> <== NOT EXECUTED
edd4: e1a03000 mov r3, r0 <== NOT EXECUTED
edd8: e59f04bc ldr r0, [pc, #1212] ; f29c <rtems_rfs_format+0xb3c><== NOT EXECUTED
eddc: e1a01005 mov r1, r5 <== NOT EXECUTED
ede0: e1a0200a mov r2, sl <== NOT EXECUTED
ede4: eb003f10 bl 1ea2c <printf> <== NOT EXECUTED
ede8: ea000109 b f214 <rtems_rfs_format+0xab4> <== NOT EXECUTED
}
/*
* Forced allocation of the block bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
edec: e3a01000 mov r1, #0
edf0: e28d00bc add r0, sp, #188 ; 0xbc
edf4: eb0020ab bl 170a8 <rtems_rfs_bitmap_map_set>
/*
* Forced allocation of the inode bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
edf8: e3a01001 mov r1, #1
edfc: e28d00bc add r0, sp, #188 ; 0xbc
ee00: eb0020a8 bl 170a8 <rtems_rfs_bitmap_map_set>
/*
* Determine the number of inodes blocks in the group.
*/
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
ee04: e28d003c add r0, sp, #60 ; 0x3c
ee08: e8900003 ldm r0, {r0, r1}
ee0c: ebfffe38 bl e6f4 <rtems_rfs_rup_quotient>
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
ee10: e3a08000 mov r8, #0
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);
ee14: e58d0008 str r0, [sp, #8]
ee18: ea000002 b ee28 <rtems_rfs_format+0x6c8>
/*
* 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);
ee1c: e2881002 add r1, r8, #2
ee20: eb0020a0 bl 170a8 <rtems_rfs_bitmap_map_set>
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++)
ee24: e2888001 add r8, r8, #1
ee28: e59d3008 ldr r3, [sp, #8]
ee2c: e1580003 cmp r8, r3
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
ee30: e28d00bc add r0, sp, #188 ; 0xbc
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++)
ee34: bafffff8 blt ee1c <rtems_rfs_format+0x6bc>
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
/*
* Close the block bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
ee38: eb0021b0 bl 17500 <rtems_rfs_bitmap_close>
if (rc > 0)
ee3c: e3500000 cmp r0, #0
ee40: da000008 ble ee68 <rtems_rfs_format+0x708>
ee44: e1a0a000 mov sl, r0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
ee48: e1a01006 mov r1, r6 <== NOT EXECUTED
ee4c: e1a00007 mov r0, r7 <== NOT EXECUTED
ee50: ebfffe1f bl e6d4 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
ee54: e1a0000a mov r0, sl <== NOT EXECUTED
ee58: eb0043a1 bl 1fce4 <strerror> <== NOT EXECUTED
ee5c: e1a03000 mov r3, r0 <== NOT EXECUTED
ee60: e59f0438 ldr r0, [pc, #1080] ; f2a0 <rtems_rfs_format+0xb40><== NOT EXECUTED
ee64: eaffffdc b eddc <rtems_rfs_format+0x67c> <== NOT EXECUTED
group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
ee68: e3a03001 mov r3, #1
if (verbose)
ee6c: e3590000 cmp r9, #0
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);
ee70: e5cd30d4 strb r3, [sp, #212] ; 0xd4
if (verbose)
printf (", inodes");
ee74: 159f0428 ldrne r0, [pc, #1064] ; f2a4 <rtems_rfs_format+0xb44>
ee78: 1b003eeb blne 1ea2c <printf>
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
ee7c: e28a3002 add r3, sl, #2
ee80: e58d3000 str r3, [sp]
ee84: e28d00bc add r0, sp, #188 ; 0xbc
ee88: e1a01007 mov r1, r7
ee8c: e1a02006 mov r2, r6
ee90: e1a03004 mov r3, r4
ee94: eb002185 bl 174b0 <rtems_rfs_bitmap_open>
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
ee98: e2508000 subs r8, r0, #0
ee9c: da000007 ble eec0 <rtems_rfs_format+0x760>
{
rtems_rfs_buffer_handle_close (fs, &handle);
eea0: e1a01006 mov r1, r6 <== NOT EXECUTED
eea4: e1a00007 mov r0, r7 <== NOT EXECUTED
eea8: ebfffe09 bl e6d4 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
eeac: e1a00008 mov r0, r8 <== NOT EXECUTED
eeb0: eb00438b bl 1fce4 <strerror> <== NOT EXECUTED
eeb4: e1a03000 mov r3, r0 <== NOT EXECUTED
eeb8: e59f03e8 ldr r0, [pc, #1000] ; f2a8 <rtems_rfs_format+0xb48><== NOT EXECUTED
eebc: ea000011 b ef08 <rtems_rfs_format+0x7a8> <== 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));
eec0: e59d30dc ldr r3, [sp, #220] ; 0xdc
eec4: e3a01000 mov r1, #0
eec8: e593001c ldr r0, [r3, #28]
eecc: e59d2018 ldr r2, [sp, #24]
eed0: eb003e64 bl 1e868 <memset>
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
eed4: e28d00bc add r0, sp, #188 ; 0xbc
eed8: eb0020ea bl 17288 <rtems_rfs_bitmap_map_clear_all>
if (rc > 0)
eedc: e2508000 subs r8, r0, #0
{
rtems_rfs_bitmap_close (&bitmap);
eee0: e28d00bc add r0, sp, #188 ; 0xbc
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
if (rc > 0)
eee4: da00000a ble ef14 <rtems_rfs_format+0x7b4>
{
rtems_rfs_bitmap_close (&bitmap);
eee8: eb002184 bl 17500 <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
eeec: e1a01006 mov r1, r6 <== NOT EXECUTED
eef0: e1a00007 mov r0, r7 <== NOT EXECUTED
eef4: ebfffdf6 bl e6d4 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
eef8: e1a00008 mov r0, r8 <== NOT EXECUTED
eefc: eb004378 bl 1fce4 <strerror> <== NOT EXECUTED
ef00: e1a03000 mov r3, r0 <== NOT EXECUTED
ef04: e59f03a0 ldr r0, [pc, #928] ; f2ac <rtems_rfs_format+0xb4c><== NOT EXECUTED
ef08: e1a01005 mov r1, r5 <== NOT EXECUTED
ef0c: e1a02008 mov r2, r8 <== NOT EXECUTED
ef10: eaffffb3 b ede4 <rtems_rfs_format+0x684> <== NOT EXECUTED
}
/*
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
ef14: eb002179 bl 17500 <rtems_rfs_bitmap_close>
if (rc > 0)
ef18: e2508000 subs r8, r0, #0
ef1c: da000007 ble ef40 <rtems_rfs_format+0x7e0>
{
rtems_rfs_buffer_handle_close (fs, &handle);
ef20: e1a01006 mov r1, r6 <== NOT EXECUTED
ef24: e1a00007 mov r0, r7 <== NOT EXECUTED
ef28: ebfffde9 bl e6d4 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
ef2c: e1a00008 mov r0, r8 <== NOT EXECUTED
ef30: eb00436b bl 1fce4 <strerror> <== NOT EXECUTED
ef34: e1a03000 mov r3, r0 <== NOT EXECUTED
ef38: e59f0370 ldr r0, [pc, #880] ; f2b0 <rtems_rfs_format+0xb50><== NOT EXECUTED
ef3c: eafffff1 b ef08 <rtems_rfs_format+0x7a8> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
ef40: e59d000c ldr r0, [sp, #12]
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);
ef44: e3a03001 mov r3, #1
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
ef48: e3500000 cmp r0, #0
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);
ef4c: e5cd30d4 strb r3, [sp, #212] ; 0xd4
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
ef50: 13a04000 movne r4, #0
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
ef54: 128a8003 addne r8, sl, #3
rtems_rfs_buffer_mark_dirty (&handle);
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
ef58: 1a00001c bne efd0 <rtems_rfs_format+0x870>
ef5c: ea00001e b efdc <rtems_rfs_format+0x87c>
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
ef60: e0889004 add r9, r8, r4 <== NOT EXECUTED
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
ef64: e1a00007 mov r0, r7 <== NOT EXECUTED
ef68: e1a01006 mov r1, r6 <== NOT EXECUTED
ef6c: e1a02009 mov r2, r9 <== NOT EXECUTED
ef70: e3a03000 mov r3, #0 <== NOT EXECUTED
ef74: eb0025fc bl 1876c <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
ef78: e250a000 subs sl, r0, #0 <== NOT EXECUTED
ef7c: da00000b ble efb0 <rtems_rfs_format+0x850> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
ef80: e1a01006 mov r1, r6 <== NOT EXECUTED
ef84: e1a00007 mov r0, r7 <== NOT EXECUTED
ef88: ebfffdd1 bl e6d4 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
ef8c: e1a0000a mov r0, sl <== NOT EXECUTED
ef90: eb004353 bl 1fce4 <strerror> <== NOT EXECUTED
ef94: e1a01005 mov r1, r5 <== NOT EXECUTED
ef98: e58d0000 str r0, [sp] <== NOT EXECUTED
ef9c: e1a02009 mov r2, r9 <== NOT EXECUTED
efa0: e1a0300a mov r3, sl <== NOT EXECUTED
efa4: e59f0308 ldr r0, [pc, #776] ; f2b4 <rtems_rfs_format+0xb54><== NOT EXECUTED
efa8: eb003e9f bl 1ea2c <printf> <== NOT EXECUTED
efac: ea000098 b f214 <rtems_rfs_format+0xab4> <== 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));
efb0: e59d30dc ldr r3, [sp, #220] ; 0xdc <== NOT EXECUTED
efb4: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED
efb8: e593001c ldr r0, [r3, #28] <== NOT EXECUTED
efbc: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED
efc0: eb003e28 bl 1e868 <memset> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
efc4: e3a03001 mov r3, #1 <== NOT EXECUTED
efc8: e5cd30d4 strb r3, [sp, #212] ; 0xd4 <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
efcc: e0844003 add r4, r4, r3 <== NOT EXECUTED
efd0: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED
efd4: e1540002 cmp r4, r2 <== NOT EXECUTED
efd8: baffffe0 blt ef60 <rtems_rfs_format+0x800> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
efdc: e1a00007 mov r0, r7
efe0: e1a01006 mov r1, r6
efe4: ebfffdba bl e6d4 <rtems_rfs_buffer_handle_close>
if (rc > 0)
efe8: e2508000 subs r8, r0, #0
efec: da00008d ble f228 <rtems_rfs_format+0xac8>
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
eff0: eb00433b bl 1fce4 <strerror> <== NOT EXECUTED
eff4: e1a01008 mov r1, r8 <== NOT EXECUTED
eff8: e1a02000 mov r2, r0 <== NOT EXECUTED
effc: e59f02b4 ldr r0, [pc, #692] ; f2b8 <rtems_rfs_format+0xb58><== NOT EXECUTED
f000: ea000082 b f210 <rtems_rfs_format+0xab0> <== NOT EXECUTED
printf (", blocks");
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
f004: e1a0b004 mov fp, r4
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
f008: e59d3034 ldr r3, [sp, #52] ; 0x34
f00c: e1550003 cmp r5, r3
f010: e5db9015 ldrb r9, [fp, #21]
f014: baffff30 blt ecdc <rtems_rfs_format+0x57c>
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
if (config->verbose)
f018: e3590000 cmp r9, #0
printf ("\n");
f01c: 13a0000a movne r0, #10
f020: 1b003eeb blne 1ebd4 <putchar>
rc = rtems_rfs_buffer_close (&fs);
f024: e28d0010 add r0, sp, #16
f028: eb002731 bl 18cf4 <rtems_rfs_buffer_close>
if (rc > 0)
f02c: e2504000 subs r4, r0, #0
f030: da000004 ble f048 <rtems_rfs_format+0x8e8>
{
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
f034: eb00432a bl 1fce4 <strerror> <== NOT EXECUTED
f038: e1a01004 mov r1, r4 <== NOT EXECUTED
f03c: e1a02000 mov r2, r0 <== NOT EXECUTED
f040: e59f0274 ldr r0, [pc, #628] ; f2bc <rtems_rfs_format+0xb5c><== NOT EXECUTED
f044: ea000071 b f210 <rtems_rfs_format+0xab0> <== NOT EXECUTED
int rc;
/*
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL,
f048: e28d30e0 add r3, sp, #224 ; 0xe0
f04c: e3a01000 mov r1, #0
f050: e58d3000 str r3, [sp]
f054: e59d0004 ldr r0, [sp, #4]
f058: e3a02006 mov r2, #6
f05c: e1a03001 mov r3, r1
f060: eb002ef9 bl 1ac4c <rtems_rfs_fs_open>
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
f064: e3500000 cmp r0, #0
f068: aa000007 bge f08c <rtems_rfs_format+0x92c>
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
f06c: eb003958 bl 1d5d4 <__errno> <== NOT EXECUTED
rc = rtems_rfs_fs_open (name, NULL,
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
f070: e5904000 ldr r4, [r0] <== NOT EXECUTED
errno, strerror (errno));
f074: eb003956 bl 1d5d4 <__errno> <== NOT EXECUTED
rc = rtems_rfs_fs_open (name, NULL,
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
f078: e5900000 ldr r0, [r0] <== NOT EXECUTED
f07c: eb004318 bl 1fce4 <strerror> <== NOT EXECUTED
f080: e1a02000 mov r2, r0 <== NOT EXECUTED
f084: e59f0234 ldr r0, [pc, #564] ; f2c0 <rtems_rfs_format+0xb60><== NOT EXECUTED
f088: ea000057 b f1ec <rtems_rfs_format+0xa8c> <== NOT EXECUTED
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
f08c: e59d00e0 ldr r0, [sp, #224] ; 0xe0
f090: e3a01001 mov r1, #1
f094: e28d20e4 add r2, sp, #228 ; 0xe4
f098: eb000231 bl f964 <rtems_rfs_inode_alloc>
if (rc > 0)
f09c: e2505000 subs r5, r0, #0
f0a0: da000005 ble f0bc <rtems_rfs_format+0x95c>
{
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
f0a4: eb00430e bl 1fce4 <strerror> <== NOT EXECUTED
f0a8: e1a01005 mov r1, r5 <== NOT EXECUTED
f0ac: e1a02000 mov r2, r0 <== NOT EXECUTED
f0b0: e59f020c ldr r0, [pc, #524] ; f2c4 <rtems_rfs_format+0xb64><== NOT EXECUTED
f0b4: eb003e5c bl 1ea2c <printf> <== NOT EXECUTED
f0b8: ea000018 b f120 <rtems_rfs_format+0x9c0> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
return rc;
}
if (ino != RTEMS_RFS_ROOT_INO)
f0bc: e59d40e4 ldr r4, [sp, #228] ; 0xe4
f0c0: e3540001 cmp r4, #1
f0c4: 0a000005 beq f0e0 <rtems_rfs_format+0x980>
{
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
f0c8: e1a01004 mov r1, r4 <== NOT EXECUTED
f0cc: e59f01f4 ldr r0, [pc, #500] ; f2c8 <rtems_rfs_format+0xb68><== NOT EXECUTED
f0d0: eb003e55 bl 1ea2c <printf> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
f0d4: e59d00e0 ldr r0, [sp, #224] ; 0xe0 <== NOT EXECUTED
f0d8: eb0030b2 bl 1b3a8 <rtems_rfs_fs_close> <== NOT EXECUTED
f0dc: ea00004e b f21c <rtems_rfs_format+0xabc> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
f0e0: e59d00e0 ldr r0, [sp, #224] ; 0xe0
f0e4: e1a01004 mov r1, r4
f0e8: e28d2094 add r2, sp, #148 ; 0x94
f0ec: e1a03004 mov r3, r4
f0f0: eb00024f bl fa34 <rtems_rfs_inode_open>
if (rc > 0)
f0f4: e2505000 subs r5, r0, #0
f0f8: da00000b ble f12c <rtems_rfs_format+0x9cc>
{
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
f0fc: eb0042f8 bl 1fce4 <strerror> <== NOT EXECUTED
f100: e1a01005 mov r1, r5 <== NOT EXECUTED
f104: e1a02000 mov r2, r0 <== NOT EXECUTED
f108: e59f01bc ldr r0, [pc, #444] ; f2cc <rtems_rfs_format+0xb6c><== NOT EXECUTED
f10c: eb003e46 bl 1ea2c <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_group_bitmap_free (fs, true, ino);
f110: e59d00e0 ldr r0, [sp, #224] ; 0xe0 <== NOT EXECUTED
f114: e1a01004 mov r1, r4 <== NOT EXECUTED
f118: e59d20e4 ldr r2, [sp, #228] ; 0xe4 <== NOT EXECUTED
f11c: eb000183 bl f730 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
f120: e59d00e0 ldr r0, [sp, #224] ; 0xe0 <== NOT EXECUTED
f124: eb00309f bl 1b3a8 <rtems_rfs_fs_close> <== NOT EXECUTED
f128: ea000033 b f1fc <rtems_rfs_format+0xa9c> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
f12c: e3a01000 mov r1, #0
f130: e28d0094 add r0, sp, #148 ; 0x94
f134: e59f2194 ldr r2, [pc, #404] ; f2d0 <rtems_rfs_format+0xb70>
f138: e1a03001 mov r3, r1
f13c: e58d1000 str r1, [sp]
f140: eb000332 bl fe10 <rtems_rfs_inode_initialise>
(RTEMS_RFS_S_IFDIR | RTEMS_RFS_S_IRWXU |
RTEMS_RFS_S_IXGRP | RTEMS_RFS_S_IXOTH),
0, 0);
if (rc > 0)
f144: e2504000 subs r4, r0, #0
f148: da000004 ble f160 <rtems_rfs_format+0xa00>
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
f14c: eb0042e4 bl 1fce4 <strerror> <== NOT EXECUTED
f150: e1a01004 mov r1, r4 <== NOT EXECUTED
f154: e1a02000 mov r2, r0 <== NOT EXECUTED
f158: e59f0174 ldr r0, [pc, #372] ; f2d4 <rtems_rfs_format+0xb74><== NOT EXECUTED
f15c: eb003e32 bl 1ea2c <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
f160: e59d30e4 ldr r3, [sp, #228] ; 0xe4
f164: e59d00e0 ldr r0, [sp, #224] ; 0xe0
f168: e58d3000 str r3, [sp]
f16c: e28d1094 add r1, sp, #148 ; 0x94
f170: e59f2160 ldr r2, [pc, #352] ; f2d8 <rtems_rfs_format+0xb78>
f174: e3a03001 mov r3, #1
f178: eb00283e bl 19278 <rtems_rfs_dir_add_entry>
if (rc > 0)
f17c: e2504000 subs r4, r0, #0
f180: da000004 ble f198 <rtems_rfs_format+0xa38>
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
f184: eb0042d6 bl 1fce4 <strerror> <== NOT EXECUTED
f188: e1a01004 mov r1, r4 <== NOT EXECUTED
f18c: e1a02000 mov r2, r0 <== NOT EXECUTED
f190: e59f0144 ldr r0, [pc, #324] ; f2dc <rtems_rfs_format+0xb7c><== NOT EXECUTED
f194: eb003e24 bl 1ea2c <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
f198: e59d00e0 ldr r0, [sp, #224] ; 0xe0
f19c: e28d1094 add r1, sp, #148 ; 0x94
f1a0: eb000298 bl fc08 <rtems_rfs_inode_close>
if (rc > 0)
f1a4: e2504000 subs r4, r0, #0
f1a8: da000004 ble f1c0 <rtems_rfs_format+0xa60>
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
f1ac: eb0042cc bl 1fce4 <strerror> <== NOT EXECUTED
f1b0: e1a01004 mov r1, r4 <== NOT EXECUTED
f1b4: e1a02000 mov r2, r0 <== NOT EXECUTED
f1b8: e59f0120 ldr r0, [pc, #288] ; f2e0 <rtems_rfs_format+0xb80><== NOT EXECUTED
f1bc: eb003e1a bl 1ea2c <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
f1c0: e59d00e0 ldr r0, [sp, #224] ; 0xe0
f1c4: eb003077 bl 1b3a8 <rtems_rfs_fs_close>
if (rc < 0)
f1c8: e2505000 subs r5, r0, #0
f1cc: aa000009 bge f1f8 <rtems_rfs_format+0xa98>
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
errno, strerror (errno));
f1d0: eb0038ff bl 1d5d4 <__errno> <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
if (rc < 0)
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
f1d4: e5904000 ldr r4, [r0] <== NOT EXECUTED
errno, strerror (errno));
f1d8: eb0038fd bl 1d5d4 <__errno> <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
if (rc < 0)
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
f1dc: e5900000 ldr r0, [r0] <== NOT EXECUTED
f1e0: eb0042bf bl 1fce4 <strerror> <== NOT EXECUTED
f1e4: e1a02000 mov r2, r0 <== NOT EXECUTED
f1e8: e59f00f4 ldr r0, [pc, #244] ; f2e4 <rtems_rfs_format+0xb84><== NOT EXECUTED
f1ec: e1a01004 mov r1, r4 <== NOT EXECUTED
f1f0: eb003e0d bl 1ea2c <printf> <== NOT EXECUTED
f1f4: ea000008 b f21c <rtems_rfs_format+0xabc> <== NOT EXECUTED
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
f1f8: da000007 ble f21c <rtems_rfs_format+0xabc>
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
f1fc: e1a00005 mov r0, r5 <== NOT EXECUTED
f200: eb0042b7 bl 1fce4 <strerror> <== NOT EXECUTED
f204: e1a02000 mov r2, r0 <== NOT EXECUTED
f208: e59f00d8 ldr r0, [pc, #216] ; f2e8 <rtems_rfs_format+0xb88><== NOT EXECUTED
f20c: e1a01005 mov r1, r5 <== NOT EXECUTED
f210: eb003e05 bl 1ea2c <printf> <== NOT EXECUTED
rc, strerror (rc));
return -1;
f214: e3e00000 mvn r0, #0 <== NOT EXECUTED
f218: ea000000 b f220 <rtems_rfs_format+0xac0> <== NOT EXECUTED
}
return 0;
f21c: e3a00000 mov r0, #0
}
f220: e28dd0e8 add sp, sp, #232 ; 0xe8
f224: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
f228: e2855001 add r5, r5, #1
f22c: eaffff75 b f008 <rtems_rfs_format+0x8a8>
0001ac4c <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)
{
1ac4c: e92d4df0 push {r4, r5, r6, r7, r8, sl, fp, lr}
1ac50: e1a04000 mov r4, r0
1ac54: e24dd038 sub sp, sp, #56 ; 0x38
1ac58: e1a05001 mov r5, r1
#endif
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1ac5c: e3a00001 mov r0, #1 1ac60: e3a01000 mov r1, #0
rtems_rfs_fs_open (const char* name,
void* user,
uint32_t flags,
uint32_t max_held_buffers,
rtems_rfs_file_system** fs)
{
1ac64: e1a07002 mov r7, r2 1ac68: e1a08003 mov r8, r3 1ac6c: e59d6058 ldr r6, [sp, #88] ; 0x58
#endif
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1ac70: ebffd97d bl 1126c <rtems_rfs_trace> 1ac74: e3500000 cmp r0, #0
printf ("rtems-rfs: open: %s\n", name);
1ac78: 159f06e4 ldrne r0, [pc, #1764] ; 1b364 <rtems_rfs_fs_open+0x718> 1ac7c: 11a01004 movne r1, r4 1ac80: 1b000f69 blne 1ea2c <printf>
*fs = malloc (sizeof (rtems_rfs_file_system));
1ac84: e3a00084 mov r0, #132 ; 0x84 1ac88: ebffb050 bl 6dd0 <malloc>
if (!*fs)
1ac8c: e3500000 cmp r0, #0
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
1ac90: e5860000 str r0, [r6]
if (!*fs)
1ac94: 1a000008 bne 1acbc <rtems_rfs_fs_open+0x70>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1ac98: e3a00001 mov r0, #1 <== NOT EXECUTED 1ac9c: e3a01000 mov r1, #0 <== NOT EXECUTED 1aca0: ebffd971 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1aca4: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
1aca8: 159f06b8 ldrne r0, [pc, #1720] ; 1b368 <rtems_rfs_fs_open+0x71c><== NOT EXECUTED 1acac: 1b000ff6 blne 1ec8c <puts> <== NOT EXECUTED
errno = ENOMEM;
1acb0: eb000a47 bl 1d5d4 <__errno> <== NOT EXECUTED 1acb4: e3a0300c mov r3, #12 <== NOT EXECUTED 1acb8: ea000187 b 1b2dc <rtems_rfs_fs_open+0x690> <== NOT EXECUTED
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
1acbc: e3a01000 mov r1, #0 1acc0: e3a02084 mov r2, #132 ; 0x84 1acc4: eb000ee7 bl 1e868 <memset>
(*fs)->user = user;
1acc8: e5963000 ldr r3, [r6] 1accc: e5835080 str r5, [r3, #128] ; 0x80
rtems_chain_initialize_empty (&(*fs)->buffers);
1acd0: e5963000 ldr r3, [r6]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
1acd4: e3a05000 mov r5, #0
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
1acd8: e2832044 add r2, r3, #68 ; 0x44 1acdc: e2831048 add r1, r3, #72 ; 0x48
head->next = tail;
1ace0: e5831044 str r1, [r3, #68] ; 0x44
head->previous = NULL; tail->previous = head;
1ace4: e583204c str r2, [r3, #76] ; 0x4c
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
1ace8: e5835048 str r5, [r3, #72] ; 0x48
rtems_chain_initialize_empty (&(*fs)->release);
1acec: e5963000 ldr r3, [r6]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
1acf0: e2832054 add r2, r3, #84 ; 0x54 1acf4: e2831058 add r1, r3, #88 ; 0x58
head->next = tail;
1acf8: e5831054 str r1, [r3, #84] ; 0x54
head->previous = NULL; tail->previous = head;
1acfc: e583205c str r2, [r3, #92] ; 0x5c
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
1ad00: e5835058 str r5, [r3, #88] ; 0x58
rtems_chain_initialize_empty (&(*fs)->release_modified);
1ad04: e5963000 ldr r3, [r6]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
1ad08: e2832064 add r2, r3, #100 ; 0x64 1ad0c: e2831068 add r1, r3, #104 ; 0x68
head->next = tail;
1ad10: e5831064 str r1, [r3, #100] ; 0x64
head->previous = NULL; tail->previous = head;
1ad14: e583206c str r2, [r3, #108] ; 0x6c
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
1ad18: e5835068 str r5, [r3, #104] ; 0x68
rtems_chain_initialize_empty (&(*fs)->file_shares);
1ad1c: e5963000 ldr r3, [r6]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
1ad20: e2831078 add r1, r3, #120 ; 0x78 1ad24: e2832074 add r2, r3, #116 ; 0x74
head->next = tail;
1ad28: e5831074 str r1, [r3, #116] ; 0x74
head->previous = NULL;
1ad2c: e5835078 str r5, [r3, #120] ; 0x78
tail->previous = head;
1ad30: e583207c str r2, [r3, #124] ; 0x7c
(*fs)->max_held_buffers = max_held_buffers;
1ad34: e5961000 ldr r1, [r6]
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
1ad38: e1a00004 mov r0, r4
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;
1ad3c: e5818040 str r8, [r1, #64] ; 0x40
(*fs)->buffers_count = 0;
1ad40: e5815050 str r5, [r1, #80] ; 0x50
(*fs)->release_count = 0;
1ad44: e5815060 str r5, [r1, #96] ; 0x60
(*fs)->release_modified_count = 0;
1ad48: e5815070 str r5, [r1, #112] ; 0x70
(*fs)->flags = flags;
1ad4c: e5817000 str r7, [r1]
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
1ad50: ebfff71d bl 189cc <rtems_rfs_buffer_open>
if (rc > 0)
1ad54: e2504000 subs r4, r0, #0
1ad58: da000010 ble 1ada0 <rtems_rfs_fs_open+0x154>
{
free (*fs);
1ad5c: e5960000 ldr r0, [r6] <== NOT EXECUTED 1ad60: ebffaeaa bl 6810 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1ad64: e3a00001 mov r0, #1 <== NOT EXECUTED 1ad68: e3a01000 mov r1, #0 <== NOT EXECUTED 1ad6c: ebffd93e bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1ad70: e1500005 cmp r0, r5 <== NOT EXECUTED 1ad74: 0a000005 beq 1ad90 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
1ad78: e1a00004 mov r0, r4 <== NOT EXECUTED 1ad7c: eb0013d8 bl 1fce4 <strerror> <== NOT EXECUTED 1ad80: e1a02000 mov r2, r0 <== NOT EXECUTED 1ad84: e59f05e0 ldr r0, [pc, #1504] ; 1b36c <rtems_rfs_fs_open+0x720><== NOT EXECUTED 1ad88: e1a01004 mov r1, r4 <== NOT EXECUTED 1ad8c: eb000f26 bl 1ea2c <printf> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
1ad90: eb000a0f bl 1d5d4 <__errno> <== NOT EXECUTED 1ad94: e5804000 str r4, [r0] <== NOT EXECUTED
return -1;
1ad98: e3e00000 mvn r0, #0 <== NOT EXECUTED 1ad9c: ea000166 b 1b33c <rtems_rfs_fs_open+0x6f0> <== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
1ada0: e5964000 ldr r4, [r6]
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);
1ada4: e28d102c add r1, sp, #44 ; 0x2c 1ada8: e1a00004 mov r0, r4 1adac: e1a02005 mov r2, r5 1adb0: e3a03001 mov r3, #1
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
1adb4: e5cd502c strb r5, [sp, #44] ; 0x2c
handle->bnum = 0;
1adb8: e58d5030 str r5, [sp, #48] ; 0x30
handle->buffer = NULL;
1adbc: e58d5034 str r5, [sp, #52] ; 0x34 1adc0: ebfff669 bl 1876c <rtems_rfs_buffer_handle_request>
if (rc > 0)
1adc4: e2508000 subs r8, r0, #0
1adc8: da000009 ble 1adf4 <rtems_rfs_fs_open+0x1a8>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1adcc: e3a00001 mov r0, #1 <== NOT EXECUTED 1add0: e3a01000 mov r1, #0 <== NOT EXECUTED 1add4: ebffd924 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1add8: e3500000 cmp r0, #0 <== NOT EXECUTED 1addc: 0a000102 beq 1b1ec <rtems_rfs_fs_open+0x5a0> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
1ade0: e1a00008 mov r0, r8 <== NOT EXECUTED 1ade4: eb0013be bl 1fce4 <strerror> <== NOT EXECUTED 1ade8: e1a02000 mov r2, r0 <== NOT EXECUTED 1adec: e59f057c ldr r0, [pc, #1404] ; 1b370 <rtems_rfs_fs_open+0x724><== NOT EXECUTED 1adf0: ea0000f2 b 1b1c0 <rtems_rfs_fs_open+0x574> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
1adf4: e59d3034 ldr r3, [sp, #52] ; 0x34 1adf8: e593701c ldr r7, [r3, #28]
#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
1adfc: e5d72001 ldrb r2, [r7, #1] 1ae00: e5d73000 ldrb r3, [r7] 1ae04: e1a02802 lsl r2, r2, #16 1ae08: e1822c03 orr r2, r2, r3, lsl #24 1ae0c: e5d73003 ldrb r3, [r7, #3] 1ae10: e1822003 orr r2, r2, r3 1ae14: e5d73002 ldrb r3, [r7, #2] 1ae18: e1822403 orr r2, r2, r3, lsl #8 1ae1c: e59f3550 ldr r3, [pc, #1360] ; 1b374 <rtems_rfs_fs_open+0x728> 1ae20: e1520003 cmp r2, r3
1ae24: 0a000006 beq 1ae44 <rtems_rfs_fs_open+0x1f8>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1ae28: e3a00001 mov r0, #1 <== NOT EXECUTED 1ae2c: e3a01000 mov r1, #0 <== NOT EXECUTED 1ae30: ebffd90d bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1ae34: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
1ae38: 159f0538 ldrne r0, [pc, #1336] ; 1b378 <rtems_rfs_fs_open+0x72c><== NOT EXECUTED
#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1ae3c: 0a00003c beq 1af34 <rtems_rfs_fs_open+0x2e8> <== NOT EXECUTED 1ae40: ea00001f b 1aec4 <rtems_rfs_fs_open+0x278> <== 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);
1ae44: e5d7300d ldrb r3, [r7, #13] 1ae48: e5d7200c ldrb r2, [r7, #12] 1ae4c: e1a03803 lsl r3, r3, #16 1ae50: e1833c02 orr r3, r3, r2, lsl #24 1ae54: e5d7200f ldrb r2, [r7, #15] 1ae58: e1833002 orr r3, r3, r2 1ae5c: e5d7200e ldrb r2, [r7, #14] 1ae60: e1833402 orr r3, r3, r2, lsl #8 1ae64: e5843004 str r3, [r4, #4]
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
1ae68: e5d78009 ldrb r8, [r7, #9] 1ae6c: e5d72008 ldrb r2, [r7, #8] 1ae70: e1a08808 lsl r8, r8, #16 1ae74: e1888c02 orr r8, r8, r2, lsl #24 1ae78: e5d7200b ldrb r2, [r7, #11] 1ae7c: e1888002 orr r8, r8, r2 1ae80: e5d7200a ldrb r2, [r7, #10] 1ae84: e1888402 orr r8, r8, r2, lsl #8
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
1ae88: e5942010 ldr r2, [r4, #16] 1ae8c: e592101c ldr r1, [r2, #28]
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
1ae90: e5920020 ldr r0, [r2, #32]
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
1ae94: e08ba398 umull sl, fp, r8, r3
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
return media_blocks * media_block_size;
1ae98: e0832190 umull r2, r3, r0, r1
}
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))
1ae9c: e153000b cmp r3, fp 1aea0: 0152000a cmpeq r2, sl
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
1aea4: e5848008 str r8, [r4, #8]
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
1aea8: 2a000007 bcs 1aecc <rtems_rfs_fs_open+0x280>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1aeac: e3a00001 mov r0, #1 <== NOT EXECUTED 1aeb0: e3a01000 mov r1, #0 <== NOT EXECUTED 1aeb4: ebffd8ec bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1aeb8: e3500000 cmp r0, #0 <== NOT EXECUTED 1aebc: 0a00001c beq 1af34 <rtems_rfs_fs_open+0x2e8> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
1aec0: e59f04b4 ldr r0, [pc, #1204] ; 1b37c <rtems_rfs_fs_open+0x730><== NOT EXECUTED 1aec4: eb000f70 bl 1ec8c <puts> <== NOT EXECUTED 1aec8: ea000019 b 1af34 <rtems_rfs_fs_open+0x2e8> <== 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)
1aecc: e5d71025 ldrb r1, [r7, #37] ; 0x25 1aed0: e5d73024 ldrb r3, [r7, #36] ; 0x24 1aed4: e1a01801 lsl r1, r1, #16 1aed8: e1811c03 orr r1, r1, r3, lsl #24 1aedc: e5d73027 ldrb r3, [r7, #39] ; 0x27 1aee0: e1811003 orr r1, r1, r3 1aee4: e5d73026 ldrb r3, [r7, #38] ; 0x26 1aee8: e1811403 orr r1, r1, r3, lsl #8 1aeec: e3510038 cmp r1, #56 ; 0x38
1aef0: 0a000013 beq 1af44 <rtems_rfs_fs_open+0x2f8>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1aef4: e3a00001 mov r0, #1 <== NOT EXECUTED 1aef8: e3a01000 mov r1, #0 <== NOT EXECUTED 1aefc: ebffd8da bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1af00: e3500000 cmp r0, #0 <== NOT EXECUTED 1af04: 0a00000a beq 1af34 <rtems_rfs_fs_open+0x2e8> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
1af08: e5d73005 ldrb r3, [r7, #5] <== NOT EXECUTED 1af0c: e5d72004 ldrb r2, [r7, #4] <== NOT EXECUTED 1af10: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED 1af14: e1833c02 orr r3, r3, r2, lsl #24 <== NOT EXECUTED 1af18: e5d72007 ldrb r2, [r7, #7] <== NOT EXECUTED 1af1c: e5d71006 ldrb r1, [r7, #6] <== NOT EXECUTED 1af20: e1833002 orr r3, r3, r2 <== NOT EXECUTED
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
1af24: e59f0454 ldr r0, [pc, #1108] ; 1b380 <rtems_rfs_fs_open+0x734><== NOT EXECUTED 1af28: e1831401 orr r1, r3, r1, lsl #8 <== NOT EXECUTED 1af2c: e1a02005 mov r2, r5 <== NOT EXECUTED 1af30: eb000ebd bl 1ea2c <printf> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
1af34: e1a00004 mov r0, r4 <== NOT EXECUTED 1af38: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 1af3c: ebfff59e bl 185bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED 1af40: ea0000a6 b 1b1e0 <rtems_rfs_fs_open+0x594> <== 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);
1af44: e5d73011 ldrb r3, [r7, #17] 1af48: e5d72010 ldrb r2, [r7, #16] 1af4c: e1a03803 lsl r3, r3, #16 1af50: e1833c02 orr r3, r3, r2, lsl #24 1af54: e5d72013 ldrb r2, [r7, #19] 1af58: e1833002 orr r3, r3, r2 1af5c: e5d72012 ldrb r2, [r7, #18] 1af60: e1833402 orr r3, r3, r2, lsl #8 1af64: e5843018 str r3, [r4, #24]
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
1af68: e5d73015 ldrb r3, [r7, #21] 1af6c: e5d72014 ldrb r2, [r7, #20] 1af70: e1a03803 lsl r3, r3, #16 1af74: e1833c02 orr r3, r3, r2, lsl #24 1af78: e5d72017 ldrb r2, [r7, #23] 1af7c: e1833002 orr r3, r3, r2 1af80: e5d72016 ldrb r2, [r7, #22] 1af84: e1833402 orr r3, r3, r2, lsl #8 1af88: e584301c str r3, [r4, #28]
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
1af8c: e5d70019 ldrb r0, [r7, #25] 1af90: e5d73018 ldrb r3, [r7, #24] 1af94: e1a00800 lsl r0, r0, #16 1af98: e1800c03 orr r0, r0, r3, lsl #24 1af9c: e5d7301b ldrb r3, [r7, #27] 1afa0: e5d7201a ldrb r2, [r7, #26] 1afa4: e1800003 orr r0, r0, r3 1afa8: e1800402 orr r0, r0, r2, lsl #8 1afac: e5840024 str r0, [r4, #36] ; 0x24
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
1afb0: e5d7a01d ldrb sl, [r7, #29] 1afb4: e5d7301c ldrb r3, [r7, #28] 1afb8: e1a0a80a lsl sl, sl, #16 1afbc: e18aac03 orr sl, sl, r3, lsl #24 1afc0: e5d7301f ldrb r3, [r7, #31] 1afc4: e18aa003 orr sl, sl, r3 1afc8: e5d7301e ldrb r3, [r7, #30] 1afcc: e18aa403 orr sl, sl, r3, lsl #8 1afd0: e584a028 str sl, [r4, #40] ; 0x28
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
1afd4: e5d72021 ldrb r2, [r7, #33] ; 0x21 1afd8: e5d73020 ldrb r3, [r7, #32] 1afdc: e1a02802 lsl r2, r2, #16 1afe0: e1822c03 orr r2, r2, r3, lsl #24 1afe4: e5d73023 ldrb r3, [r7, #35] ; 0x23 1afe8: e1822003 orr r2, r2, r3 1afec: e5d73022 ldrb r3, [r7, #34] ; 0x22 1aff0: e1822403 orr r2, r2, r3, lsl #8
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
1aff4: e1a03128 lsr r3, r8, #2
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
1aff8: e083c103 add ip, r3, r3, lsl #2
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 =
1affc: e584c038 str ip, [r4, #56] ; 0x38
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;
1b000: e00c0393 mul ip, r3, r3
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);
1b004: e584202c str r2, [r4, #44] ; 0x2c
fs->block_map_singly_blocks =
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;
1b008: e0020290 mul r2, r0, r2
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);
fs->blocks_per_block =
1b00c: e5843034 str r3, [r4, #52] ; 0x34
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 =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
1b010: e08c310c add r3, ip, ip, lsl #2
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 =
1b014: e584303c str r3, [r4, #60] ; 0x3c
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
1b018: e5842014 str r2, [r4, #20]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
1b01c: e1a00008 mov r0, r8 1b020: ebff9a46 bl 1940 <__aeabi_uidiv>
if (fs->group_blocks >
1b024: e15a0188 cmp sl, r8, lsl #3
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;
1b028: e5840030 str r0, [r4, #48] ; 0x30 1b02c: e28d102c add r1, sp, #44 ; 0x2c 1b030: e1a00004 mov r0, r4
if (fs->group_blocks >
1b034: 9a00000b bls 1b068 <rtems_rfs_fs_open+0x41c>
1b038: ebfff55f bl 185bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1b03c: e3a00001 mov r0, #1 <== NOT EXECUTED 1b040: e3a01000 mov r1, #0 <== NOT EXECUTED
handle->dirty = false;
1b044: e5cd502c strb r5, [sp, #44] ; 0x2c <== NOT EXECUTED
handle->bnum = 0;
1b048: e58d5030 str r5, [sp, #48] ; 0x30 <== NOT EXECUTED
handle->buffer = NULL;
1b04c: e58d5034 str r5, [sp, #52] ; 0x34 <== NOT EXECUTED 1b050: ebffd885 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1b054: e3500000 cmp r0, #0 <== NOT EXECUTED 1b058: 0a000060 beq 1b1e0 <rtems_rfs_fs_open+0x594> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
1b05c: e59f0320 ldr r0, [pc, #800] ; 1b384 <rtems_rfs_fs_open+0x738><== NOT EXECUTED 1b060: eb000f09 bl 1ec8c <puts> <== NOT EXECUTED 1b064: ea00005d b 1b1e0 <rtems_rfs_fs_open+0x594> <== 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);
1b068: ebfff553 bl 185bc <rtems_rfs_buffer_handle_release>
rtems_rfs_buffer_handle_close (fs, &handle);
/*
* Change the block size to the value in the superblock.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
1b06c: e1a00004 mov r0, r4 1b070: e5941008 ldr r1, [r4, #8]
handle->dirty = false;
1b074: e5cd502c strb r5, [sp, #44] ; 0x2c
handle->bnum = 0;
1b078: e58d5030 str r5, [sp, #48] ; 0x30
handle->buffer = NULL;
1b07c: e58d5034 str r5, [sp, #52] ; 0x34 1b080: ebfff6e4 bl 18c18 <rtems_rfs_buffer_setblksize>
if (rc > 0)
1b084: e2508000 subs r8, r0, #0
1b088: da00000f ble 1b0cc <rtems_rfs_fs_open+0x480>
*/
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);
1b08c: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 1b090: e1a00004 mov r0, r4 <== NOT EXECUTED 1b094: ebfff548 bl 185bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1b098: e3a00001 mov r0, #1 <== NOT EXECUTED 1b09c: e3a01000 mov r1, #0 <== NOT EXECUTED
handle->dirty = false;
1b0a0: e5cd502c strb r5, [sp, #44] ; 0x2c <== NOT EXECUTED
handle->bnum = 0;
1b0a4: e58d5030 str r5, [sp, #48] ; 0x30 <== NOT EXECUTED
handle->buffer = NULL;
1b0a8: e58d5034 str r5, [sp, #52] ; 0x34 <== NOT EXECUTED 1b0ac: ebffd86e bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1b0b0: e3500000 cmp r0, #0 <== NOT EXECUTED 1b0b4: 0a00004c beq 1b1ec <rtems_rfs_fs_open+0x5a0> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
1b0b8: e1a00008 mov r0, r8 <== NOT EXECUTED 1b0bc: eb001308 bl 1fce4 <strerror> <== NOT EXECUTED 1b0c0: e1a02000 mov r2, r0 <== NOT EXECUTED 1b0c4: e59f02bc ldr r0, [pc, #700] ; 1b388 <rtems_rfs_fs_open+0x73c><== NOT EXECUTED 1b0c8: ea00003c b 1b1c0 <rtems_rfs_fs_open+0x574> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
1b0cc: e5940024 ldr r0, [r4, #36] ; 0x24 1b0d0: e3a01050 mov r1, #80 ; 0x50 1b0d4: ebffacef bl 6498 <calloc>
if (!fs->groups)
1b0d8: e3500000 cmp r0, #0
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));
1b0dc: e1a07000 mov r7, r0 1b0e0: e5840020 str r0, [r4, #32]
if (!fs->groups)
1b0e4: 11a07005 movne r7, r5
1b0e8: 1a000038 bne 1b1d0 <rtems_rfs_fs_open+0x584>
*/
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);
1b0ec: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 1b0f0: e1a00004 mov r0, r4 <== NOT EXECUTED 1b0f4: ebfff530 bl 185bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1b0f8: e3a00001 mov r0, #1 <== NOT EXECUTED 1b0fc: e3a01000 mov r1, #0 <== NOT EXECUTED
handle->dirty = false;
1b100: e5cd702c strb r7, [sp, #44] ; 0x2c <== NOT EXECUTED
handle->bnum = 0;
1b104: e58d7030 str r7, [sp, #48] ; 0x30 <== NOT EXECUTED
handle->buffer = NULL;
1b108: e58d7034 str r7, [sp, #52] ; 0x34 <== NOT EXECUTED 1b10c: ebffd856 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1b110: e3500000 cmp r0, #0 <== NOT EXECUTED 1b114: 0a000033 beq 1b1e8 <rtems_rfs_fs_open+0x59c> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
1b118: e59f026c ldr r0, [pc, #620] ; 1b38c <rtems_rfs_fs_open+0x740><== NOT EXECUTED 1b11c: eb000eda bl 1ec8c <puts> <== NOT EXECUTED 1b120: ea000030 b 1b1e8 <rtems_rfs_fs_open+0x59c> <== 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),
1b124: e5942028 ldr r2, [r4, #40] ; 0x28 1b128: e0010792 mul r1, r2, r7
* 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,
1b12c: e5943020 ldr r3, [r4, #32] 1b130: e0833005 add r3, r3, r5 1b134: e58d3000 str r3, [sp] 1b138: e1a00004 mov r0, r4 1b13c: e2811001 add r1, r1, #1 1b140: e594302c ldr r3, [r4, #44] ; 0x2c 1b144: ebffd068 bl f2ec <rtems_rfs_group_open>
rtems_rfs_fs_block (fs, group, 0),
fs->group_blocks,
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
1b148: e2508000 subs r8, r0, #0
* 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,
1b14c: e2855050 add r5, r5, #80 ; 0x50
rtems_rfs_fs_block (fs, group, 0),
fs->group_blocks,
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
1b150: da00001d ble 1b1cc <rtems_rfs_fs_open+0x580>
1b154: e3a05000 mov r5, #0 <== NOT EXECUTED 1b158: e1a0a005 mov sl, r5 <== NOT EXECUTED 1b15c: ea000005 b 1b178 <rtems_rfs_fs_open+0x52c> <== NOT EXECUTED
{
int g;
for (g = 0; g < group; g++)
rtems_rfs_group_close (fs, &fs->groups[g]);
1b160: e5941020 ldr r1, [r4, #32] <== NOT EXECUTED 1b164: e1a00004 mov r0, r4 <== NOT EXECUTED 1b168: e0811005 add r1, r1, r5 <== NOT EXECUTED 1b16c: ebffd0da bl f4dc <rtems_rfs_group_close> <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
1b170: e28aa001 add sl, sl, #1 <== NOT EXECUTED 1b174: e2855050 add r5, r5, #80 ; 0x50 <== NOT EXECUTED 1b178: e15a0007 cmp sl, r7 <== NOT EXECUTED 1b17c: bafffff7 blt 1b160 <rtems_rfs_fs_open+0x514> <== 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);
1b180: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 1b184: e1a00004 mov r0, r4 <== NOT EXECUTED 1b188: ebfff50b bl 185bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
1b18c: e3a03000 mov r3, #0 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1b190: e3a00001 mov r0, #1 <== NOT EXECUTED 1b194: e3a01000 mov r1, #0 <== NOT EXECUTED 1b198: e5cd302c strb r3, [sp, #44] ; 0x2c <== NOT EXECUTED
handle->bnum = 0;
1b19c: e58d3030 str r3, [sp, #48] ; 0x30 <== NOT EXECUTED
handle->buffer = NULL;
1b1a0: e58d3034 str r3, [sp, #52] ; 0x34 <== NOT EXECUTED 1b1a4: ebffd830 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1b1a8: e3500000 cmp r0, #0 <== NOT EXECUTED 1b1ac: 0a00000e beq 1b1ec <rtems_rfs_fs_open+0x5a0> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
1b1b0: e1a00008 mov r0, r8 <== NOT EXECUTED 1b1b4: eb0012ca bl 1fce4 <strerror> <== NOT EXECUTED 1b1b8: e1a02000 mov r2, r0 <== NOT EXECUTED 1b1bc: e59f01cc ldr r0, [pc, #460] ; 1b390 <rtems_rfs_fs_open+0x744><== NOT EXECUTED 1b1c0: e1a01008 mov r1, r8 <== NOT EXECUTED 1b1c4: eb000e18 bl 1ea2c <printf> <== NOT EXECUTED 1b1c8: ea000007 b 1b1ec <rtems_rfs_fs_open+0x5a0> <== 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++)
1b1cc: e2877001 add r7, r7, #1 1b1d0: e5943024 ldr r3, [r4, #36] ; 0x24 1b1d4: e1570003 cmp r7, r3
1b1d8: baffffd1 blt 1b124 <rtems_rfs_fs_open+0x4d8>
1b1dc: ea000058 b 1b344 <rtems_rfs_fs_open+0x6f8>
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
return EIO;
1b1e0: e3a08005 mov r8, #5 <== NOT EXECUTED 1b1e4: ea000000 b 1b1ec <rtems_rfs_fs_open+0x5a0> <== NOT EXECUTED
if (!fs->groups)
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: no memory for group table\n");
return ENOMEM;
1b1e8: e3a0800c mov r8, #12 <== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
1b1ec: e5960000 ldr r0, [r6] <== NOT EXECUTED 1b1f0: ebfff6bf bl 18cf4 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
1b1f4: e5960000 ldr r0, [r6] <== NOT EXECUTED 1b1f8: ebffad84 bl 6810 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1b1fc: e3a00001 mov r0, #1 <== NOT EXECUTED 1b200: e3a01000 mov r1, #0 <== NOT EXECUTED 1b204: ebffd818 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1b208: e3500000 cmp r0, #0 <== NOT EXECUTED 1b20c: 0a000005 beq 1b228 <rtems_rfs_fs_open+0x5dc> <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
1b210: e1a00008 mov r0, r8 <== NOT EXECUTED 1b214: eb0012b2 bl 1fce4 <strerror> <== NOT EXECUTED 1b218: e1a01008 mov r1, r8 <== NOT EXECUTED 1b21c: e1a02000 mov r2, r0 <== NOT EXECUTED 1b220: e59f016c ldr r0, [pc, #364] ; 1b394 <rtems_rfs_fs_open+0x748><== NOT EXECUTED 1b224: eb000e00 bl 1ea2c <printf> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
1b228: eb0008e9 bl 1d5d4 <__errno> <== NOT EXECUTED 1b22c: e5808000 str r8, [r0] <== NOT EXECUTED 1b230: eafffed8 b 1ad98 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
1b234: e5960000 ldr r0, [r6] <== NOT EXECUTED 1b238: ebfff6ad bl 18cf4 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
1b23c: e5960000 ldr r0, [r6] <== NOT EXECUTED 1b240: ebffad72 bl 6810 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1b244: e3a00001 mov r0, #1 <== NOT EXECUTED 1b248: e3a01000 mov r1, #0 <== NOT EXECUTED 1b24c: ebffd806 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1b250: e3500000 cmp r0, #0 <== NOT EXECUTED 1b254: 0afffecd beq 1ad90 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
1b258: e1a00004 mov r0, r4 <== NOT EXECUTED 1b25c: eb0012a0 bl 1fce4 <strerror> <== NOT EXECUTED 1b260: e1a02000 mov r2, r0 <== NOT EXECUTED 1b264: e59f012c ldr r0, [pc, #300] ; 1b398 <rtems_rfs_fs_open+0x74c><== NOT EXECUTED 1b268: eafffec6 b 1ad88 <rtems_rfs_fs_open+0x13c> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
1b26c: e5960000 ldr r0, [r6] 1b270: e5903000 ldr r3, [r0] 1b274: e3130004 tst r3, #4
1b278: 1a000019 bne 1b2e4 <rtems_rfs_fs_open+0x698>
* @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);
1b27c: e59d2010 ldr r2, [sp, #16] 1b280: e5d21002 ldrb r1, [r2, #2] 1b284: e5d23003 ldrb r3, [r2, #3]
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
1b288: e59f210c ldr r2, [pc, #268] ; 1b39c <rtems_rfs_fs_open+0x750> 1b28c: e1833401 orr r3, r3, r1, lsl #8 1b290: e1530002 cmp r3, r2
1b294: 0a000002 beq 1b2a4 <rtems_rfs_fs_open+0x658>
1b298: e2033a0f and r3, r3, #61440 ; 0xf000 1b29c: e3530901 cmp r3, #16384 ; 0x4000
1b2a0: 0a00000f beq 1b2e4 <rtems_rfs_fs_open+0x698>
{
rtems_rfs_inode_close (*fs, &inode);
1b2a4: e28d1004 add r1, sp, #4 <== NOT EXECUTED 1b2a8: ebffd256 bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
1b2ac: e5960000 ldr r0, [r6] <== NOT EXECUTED 1b2b0: ebfff68f bl 18cf4 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
1b2b4: e5960000 ldr r0, [r6] <== NOT EXECUTED 1b2b8: ebffad54 bl 6810 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1b2bc: e3a00001 mov r0, #1 <== NOT EXECUTED 1b2c0: e3a01000 mov r1, #0 <== NOT EXECUTED 1b2c4: ebffd7e8 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1b2c8: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
1b2cc: 159f00cc ldrne r0, [pc, #204] ; 1b3a0 <rtems_rfs_fs_open+0x754><== NOT EXECUTED 1b2d0: 1b000e6d blne 1ec8c <puts> <== NOT EXECUTED
errno = EIO;
1b2d4: eb0008be bl 1d5d4 <__errno> <== NOT EXECUTED 1b2d8: e3a03005 mov r3, #5 <== NOT EXECUTED 1b2dc: e5803000 str r3, [r0] <== NOT EXECUTED 1b2e0: eafffeac b 1ad98 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
1b2e4: e28d1004 add r1, sp, #4 1b2e8: ebffd246 bl fc08 <rtems_rfs_inode_close>
if (rc > 0)
1b2ec: e2504000 subs r4, r0, #0
1b2f0: da00000d ble 1b32c <rtems_rfs_fs_open+0x6e0>
{
rtems_rfs_buffer_close (*fs);
1b2f4: e5960000 ldr r0, [r6] <== NOT EXECUTED 1b2f8: ebfff67d bl 18cf4 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
1b2fc: e5960000 ldr r0, [r6] <== NOT EXECUTED 1b300: ebffad42 bl 6810 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1b304: e3a00001 mov r0, #1 <== NOT EXECUTED 1b308: e3a01000 mov r1, #0 <== NOT EXECUTED 1b30c: ebffd7d6 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1b310: e3500000 cmp r0, #0 <== NOT EXECUTED 1b314: 0afffe9d beq 1ad90 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
1b318: e1a00004 mov r0, r4 <== NOT EXECUTED 1b31c: eb001270 bl 1fce4 <strerror> <== NOT EXECUTED 1b320: e1a02000 mov r2, r0 <== NOT EXECUTED 1b324: e59f0078 ldr r0, [pc, #120] ; 1b3a4 <rtems_rfs_fs_open+0x758><== NOT EXECUTED 1b328: eafffe96 b 1ad88 <rtems_rfs_fs_open+0x13c> <== NOT EXECUTED
errno = rc;
return -1;
}
errno = 0;
1b32c: eb0008a8 bl 1d5d4 <__errno> 1b330: e3a03000 mov r3, #0 1b334: e5803000 str r3, [r0]
return 0;
1b338: e1a00003 mov r0, r3
}
1b33c: e28dd038 add sp, sp, #56 ; 0x38
1b340: e8bd8df0 pop {r4, r5, r6, r7, r8, sl, fp, pc}
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
1b344: e3a01001 mov r1, #1 1b348: e5960000 ldr r0, [r6] 1b34c: e28d2004 add r2, sp, #4 1b350: e1a03001 mov r3, r1 1b354: ebffd1b6 bl fa34 <rtems_rfs_inode_open>
if (rc > 0)
1b358: e2504000 subs r4, r0, #0
1b35c: daffffc2 ble 1b26c <rtems_rfs_fs_open+0x620>
1b360: eaffffb3 b 1b234 <rtems_rfs_fs_open+0x5e8> <== NOT EXECUTED
0001ac28 <rtems_rfs_fs_size>:
#include <rtems/rfs/rtems-rfs-trace.h>
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
uint64_t blocks = rtems_rfs_fs_blocks (fs);
1ac28: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED
uint64_t block_size = rtems_rfs_fs_block_size (fs);
1ac2c: e5902008 ldr r2, [r0, #8] <== NOT EXECUTED
return blocks * block_size;
1ac30: e0810392 umull r0, r1, r2, r3 <== NOT EXECUTED
}
1ac34: e12fff1e bx lr <== NOT EXECUTED
0000f564 <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)
{
f564: e92d4fff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
f568: e212b0ff ands fp, r2, #255 ; 0xff
{
size = fs->group_inodes;
f56c: 1590802c ldrne r8, [r0, #44] ; 0x2c
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
f570: 05908028 ldreq r8, [r0, #40] ; 0x28
int
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
bool inode,
rtems_rfs_bitmap_bit* result)
{
f574: e1a05001 mov r5, r1
int direction;
if (inode)
{
size = fs->group_inodes;
goal -= RTEMS_RFS_ROOT_INO;
f578: 12415001 subne r5, r1, #1
int
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
bool inode,
rtems_rfs_bitmap_bit* result)
{
f57c: e1a04000 mov r4, r0
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
f580: e1a01008 mov r1, r8
f584: e1a00005 mov r0, r5
int
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
bool inode,
rtems_rfs_bitmap_bit* result)
{
f588: e58d3000 str r3, [sp]
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
f58c: ebffc8eb bl 1940 <__aeabi_uidiv>
bit = (rtems_rfs_bitmap_bit) (goal % size);
f590: e1a01008 mov r1, r8
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
f594: e58d0004 str r0, [sp, #4]
bit = (rtems_rfs_bitmap_bit) (goal % size);
f598: e1a00005 mov r0, r5
f59c: eb006e95 bl 2aff8 <__umodsi3>
offset = 0; updown = true; direction = 1;
f5a0: e3a05001 mov r5, #1
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
f5a4: e58d0008 str r0, [sp, #8]
offset = 0; updown = true;
f5a8: e1a0a005 mov sl, r5
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
f5ac: e3a07000 mov r7, #0
f5b0: ea000001 b f5bc <rtems_rfs_group_bitmap_alloc+0x58>
*/
if ((group < 0) || (group >= fs->group_count))
{
if (!updown)
break;
direction = direction > 0 ? -1 : 1;
f5b4: e3e05000 mvn r5, #0 <== NOT EXECUTED
updown = false;
f5b8: e3a0a000 mov sl, #0
/*
* 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);
f5bc: e59d3004 ldr r3, [sp, #4]
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
f5c0: e3a02000 mov r2, #0
/*
* 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)
f5c4: e3570000 cmp r7, #0
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
f5c8: e5cd200f strb r2, [sp, #15]
/*
* 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);
f5cc: e0263597 mla r6, r7, r5, r3
if (offset)
f5d0: 0a000003 beq f5e4 <rtems_rfs_group_bitmap_alloc+0x80>
bit = direction > 0 ? 0 : size - 1;
f5d4: e3550001 cmp r5, #1
f5d8: 12483001 subne r3, r8, #1
f5dc: 03a03000 moveq r3, #0
f5e0: e58d3008 str r3, [sp, #8]
/*
* 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))
f5e4: e3560000 cmp r6, #0
f5e8: ba000002 blt f5f8 <rtems_rfs_group_bitmap_alloc+0x94>
f5ec: e5943024 ldr r3, [r4, #36] ; 0x24
f5f0: e1560003 cmp r6, r3
f5f4: ba000005 blt f610 <rtems_rfs_group_bitmap_alloc+0xac>
{
if (!updown)
f5f8: e35a0000 cmp sl, #0
f5fc: 0a00003e beq f6fc <rtems_rfs_group_bitmap_alloc+0x198>
break;
direction = direction > 0 ? -1 : 1;
f600: e3550001 cmp r5, #1
f604: 13a05001 movne r5, #1
f608: 0affffe9 beq f5b4 <rtems_rfs_group_bitmap_alloc+0x50>
f60c: eaffffe9 b f5b8 <rtems_rfs_group_bitmap_alloc+0x54>
f610: e5943020 ldr r3, [r4, #32]
f614: e3a09050 mov r9, #80 ; 0x50
updown = false;
continue;
}
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
f618: e0293996 mla r9, r6, r9, r3
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
f61c: e35b0000 cmp fp, #0
bitmap = &fs->groups[group].inode_bitmap;
f620: 1289902c addne r9, r9, #44 ; 0x2c
else
bitmap = &fs->groups[group].block_bitmap;
f624: 02899008 addeq r9, r9, #8
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
f628: e1a00009 mov r0, r9
f62c: e59d1008 ldr r1, [sp, #8]
f630: e28d200f add r2, sp, #15
f634: e28d3008 add r3, sp, #8
f638: eb001f39 bl 17324 <rtems_rfs_bitmap_map_alloc>
if (rc > 0)
f63c: e3500000 cmp r0, #0
f640: ca000034 bgt f718 <rtems_rfs_group_bitmap_alloc+0x1b4>
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
f644: e5943000 ldr r3, [r4]
f648: e3130001 tst r3, #1
rtems_rfs_bitmap_release_buffer (fs, bitmap);
f64c: 01a00004 moveq r0, r4
f650: 05991000 ldreq r1, [r9]
f654: 0b0023d8 bleq 185bc <rtems_rfs_buffer_handle_release>
if (allocated)
f658: e5dd300f ldrb r3, [sp, #15]
f65c: e3530000 cmp r3, #0
f660: 0a00001e beq f6e0 <rtems_rfs_group_bitmap_alloc+0x17c>
{
if (inode)
f664: e35b0000 cmp fp, #0
f668: e59d3008 ldr r3, [sp, #8]
f66c: 0a000005 beq f688 <rtems_rfs_group_bitmap_alloc+0x124>
*result = rtems_rfs_group_inode (fs, group, bit);
f670: e594202c ldr r2, [r4, #44] ; 0x2c
f674: e2833001 add r3, r3, #1
f678: e0263692 mla r6, r2, r6, r3
f67c: e59d2000 ldr r2, [sp]
f680: e5826000 str r6, [r2]
f684: ea000006 b f6a4 <rtems_rfs_group_bitmap_alloc+0x140>
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
f688: e3a01050 mov r1, #80 ; 0x50
f68c: e0060691 mul r6, r1, r6
f690: e5942020 ldr r2, [r4, #32]
f694: e7922006 ldr r2, [r2, r6]
f698: e0833002 add r3, r3, r2
f69c: e59d2000 ldr r2, [sp]
f6a0: e5823000 str r3, [r2]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
f6a4: e3a00802 mov r0, #131072 ; 0x20000
f6a8: e3a01000 mov r1, #0
f6ac: eb0006ee bl 1126c <rtems_rfs_trace>
f6b0: e3500000 cmp r0, #0
f6b4: 0a000017 beq f718 <rtems_rfs_group_bitmap_alloc+0x1b4>
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
f6b8: e59f3060 ldr r3, [pc, #96] ; f720 <rtems_rfs_group_bitmap_alloc+0x1bc><== NOT EXECUTED
f6bc: e35b0000 cmp fp, #0 <== NOT EXECUTED
f6c0: e59f105c ldr r1, [pc, #92] ; f724 <rtems_rfs_group_bitmap_alloc+0x1c0><== NOT EXECUTED
f6c4: 11a01003 movne r1, r3 <== NOT EXECUTED
f6c8: e59d3000 ldr r3, [sp] <== NOT EXECUTED
f6cc: e59f0054 ldr r0, [pc, #84] ; f728 <rtems_rfs_group_bitmap_alloc+0x1c4><== NOT EXECUTED
f6d0: e5932000 ldr r2, [r3] <== NOT EXECUTED
f6d4: eb003cd4 bl 1ea2c <printf> <== NOT EXECUTED
inode ? "inode" : "block", *result);
return 0;
f6d8: e3a00000 mov r0, #0 <== NOT EXECUTED
f6dc: ea00000d b f718 <rtems_rfs_group_bitmap_alloc+0x1b4> <== NOT EXECUTED
}
if (updown)
f6e0: e35a0000 cmp sl, #0
f6e4: 0a000002 beq f6f4 <rtems_rfs_group_bitmap_alloc+0x190>
direction = direction > 0 ? -1 : 1;
f6e8: e3550001 cmp r5, #1
f6ec: 13a05001 movne r5, #1
f6f0: 03e05000 mvneq r5, #0
offset++;
f6f4: e2877001 add r7, r7, #1
f6f8: eaffffaf b f5bc <rtems_rfs_group_bitmap_alloc+0x58>
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
f6fc: e3a00802 mov r0, #131072 ; 0x20000
f700: e3a01000 mov r1, #0
f704: eb0006d8 bl 1126c <rtems_rfs_trace>
f708: e3500000 cmp r0, #0
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
f70c: 159f0018 ldrne r0, [pc, #24] ; f72c <rtems_rfs_group_bitmap_alloc+0x1c8>
f710: 1b003d5d blne 1ec8c <puts>
return ENOSPC;
f714: e3a0001c mov r0, #28
}
f718: e28dd010 add sp, sp, #16
f71c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000f730 <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
f730: e92d41f0 push {r4, r5, r6, r7, r8, lr}
f734: e1a04000 mov r4, r0
f738: e20150ff and r5, r1, #255 ; 0xff
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
f73c: e3a00802 mov r0, #131072 ; 0x20000
f740: e3a01000 mov r1, #0
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
f744: e1a06002 mov r6, r2
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
f748: eb0006c7 bl 1126c <rtems_rfs_trace>
f74c: e3500000 cmp r0, #0
f750: 0a000006 beq f770 <rtems_rfs_group_bitmap_free+0x40>
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
f754: e59f307c ldr r3, [pc, #124] ; f7d8 <rtems_rfs_group_bitmap_free+0xa8><== NOT EXECUTED
f758: e3550000 cmp r5, #0 <== NOT EXECUTED
f75c: e59f1078 ldr r1, [pc, #120] ; f7dc <rtems_rfs_group_bitmap_free+0xac><== NOT EXECUTED
f760: e59f0078 ldr r0, [pc, #120] ; f7e0 <rtems_rfs_group_bitmap_free+0xb0><== NOT EXECUTED
f764: 11a01003 movne r1, r3 <== NOT EXECUTED
f768: e1a02006 mov r2, r6 <== NOT EXECUTED
f76c: eb003cae bl 1ea2c <printf> <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
f770: e3550000 cmp r5, #0
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
f774: 1594702c ldrne r7, [r4, #44] ; 0x2c
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
f778: 05947028 ldreq r7, [r4, #40] ; 0x28
f77c: e2466001 sub r6, r6, #1
}
group = no / size;
f780: e1a01007 mov r1, r7
f784: e1a00006 mov r0, r6
f788: ebffc86c bl 1940 <__aeabi_uidiv>
bit = (rtems_rfs_bitmap_bit) (no % size);
f78c: e1a01007 mov r1, r7
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
f790: e1a08000 mov r8, r0
bit = (rtems_rfs_bitmap_bit) (no % size);
f794: e1a00006 mov r0, r6
f798: eb006e16 bl 2aff8 <__umodsi3>
f79c: e5943020 ldr r3, [r4, #32]
if (inode)
f7a0: e3550000 cmp r5, #0
f7a4: e3a05050 mov r5, #80 ; 0x50
bitmap = &fs->groups[group].inode_bitmap;
f7a8: e0253598 mla r5, r8, r5, r3
f7ac: 1285502c addne r5, r5, #44 ; 0x2c
else
bitmap = &fs->groups[group].block_bitmap;
f7b0: 02855008 addeq r5, r5, #8
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
f7b4: e1a01000 mov r1, r0
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
f7b8: e1a00005 mov r0, r5
f7bc: eb001e5a bl 1712c <rtems_rfs_bitmap_map_clear>
rtems_rfs_bitmap_release_buffer (fs, bitmap);
f7c0: e5951000 ldr r1, [r5]
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
f7c4: e1a06000 mov r6, r0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
f7c8: e1a00004 mov r0, r4
f7cc: eb00237a bl 185bc <rtems_rfs_buffer_handle_release>
return rc;
}
f7d0: e1a00006 mov r0, r6
f7d4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
0000f7e4 <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)
{
f7e4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
f7e8: e1a05000 mov r5, r0 <== NOT EXECUTED
f7ec: e20160ff and r6, r1, #255 ; 0xff <== NOT EXECUTED
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
f7f0: e3a00802 mov r0, #131072 ; 0x20000 <== NOT EXECUTED
f7f4: e3a01000 mov r1, #0 <== NOT EXECUTED
int
rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no,
bool* state)
{
f7f8: e1a04002 mov r4, r2 <== NOT EXECUTED
f7fc: e1a07003 mov r7, r3 <== NOT EXECUTED
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
f800: eb000699 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED
f804: e3500000 cmp r0, #0 <== NOT EXECUTED
f808: 0a000006 beq f828 <rtems_rfs_group_bitmap_test+0x44> <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
f80c: e59f30b0 ldr r3, [pc, #176] ; f8c4 <rtems_rfs_group_bitmap_test+0xe0><== NOT EXECUTED
f810: e3560000 cmp r6, #0 <== NOT EXECUTED
f814: e59f10ac ldr r1, [pc, #172] ; f8c8 <rtems_rfs_group_bitmap_test+0xe4><== NOT EXECUTED
f818: e59f00ac ldr r0, [pc, #172] ; f8cc <rtems_rfs_group_bitmap_test+0xe8><== NOT EXECUTED
f81c: 11a01003 movne r1, r3 <== NOT EXECUTED
f820: e1a02004 mov r2, r4 <== NOT EXECUTED
f824: eb003c80 bl 1ea2c <printf> <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
f828: e3560000 cmp r6, #0 <== NOT EXECUTED
f82c: 0a000007 beq f850 <rtems_rfs_group_bitmap_test+0x6c> <== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
f830: e3540000 cmp r4, #0 <== NOT EXECUTED
f834: da00001f ble f8b8 <rtems_rfs_group_bitmap_test+0xd4> <== NOT EXECUTED
f838: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED
f83c: e1540003 cmp r4, r3 <== NOT EXECUTED
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
f840: 92444001 subls r4, r4, #1 <== NOT EXECUTED
size = fs->group_inodes;
f844: 9595802c ldrls r8, [r5, #44] ; 0x2c <== 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)))
f848: 8a00001a bhi f8b8 <rtems_rfs_group_bitmap_test+0xd4> <== NOT EXECUTED
f84c: ea000003 b f860 <rtems_rfs_group_bitmap_test+0x7c> <== NOT EXECUTED
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
f850: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED
f854: e1540003 cmp r4, r3 <== NOT EXECUTED
f858: 2a000016 bcs f8b8 <rtems_rfs_group_bitmap_test+0xd4> <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
f85c: e5958028 ldr r8, [r5, #40] ; 0x28 <== NOT EXECUTED
}
group = no / size;
f860: e1a01008 mov r1, r8 <== NOT EXECUTED
f864: e1a00004 mov r0, r4 <== NOT EXECUTED
f868: ebffc834 bl 1940 <__aeabi_uidiv> <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
f86c: e1a01008 mov r1, r8 <== NOT EXECUTED
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
f870: e1a0a000 mov sl, r0 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
f874: e1a00004 mov r0, r4 <== NOT EXECUTED
f878: eb006dde bl 2aff8 <__umodsi3> <== NOT EXECUTED
f87c: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED
f880: e3a04050 mov r4, #80 ; 0x50 <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
f884: e024349a mla r4, sl, r4, r3 <== NOT EXECUTED
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
f888: e3560000 cmp r6, #0 <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
f88c: 1284402c addne r4, r4, #44 ; 0x2c <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
f890: 02844008 addeq r4, r4, #8 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
f894: e1a01000 mov r1, r0 <== 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);
f898: e1a02007 mov r2, r7 <== NOT EXECUTED
f89c: e1a00004 mov r0, r4 <== NOT EXECUTED
f8a0: eb001e40 bl 171a8 <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
f8a4: e5941000 ldr r1, [r4] <== 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);
f8a8: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
f8ac: e1a00005 mov r0, r5 <== NOT EXECUTED
f8b0: eb002341 bl 185bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
return rc;
f8b4: ea000000 b f8bc <rtems_rfs_group_bitmap_test+0xd8> <== NOT EXECUTED
size = fs->group_inodes;
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
f8b8: e3a06016 mov r6, #22 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
rtems_rfs_bitmap_release_buffer (fs, bitmap);
return rc;
}
f8bc: e1a00006 mov r0, r6 <== NOT EXECUTED
f8c0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
0000f2ec <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)
{
f2ec: e92d4ff1 push {r0, r4, r5, r6, r7, r8, r9, sl, fp, lr}
f2f0: e1a08002 mov r8, r2
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
f2f4: e5902004 ldr r2, [r0, #4]
f2f8: e1510002 cmp r1, r2
rtems_rfs_group_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block base,
size_t size,
size_t inodes,
rtems_rfs_group* group)
{
f2fc: e1a06000 mov r6, r0
f300: e1a07001 mov r7, r1
f304: e59d4028 ldr r4, [sp, #40] ; 0x28
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
f308: 3a00000b bcc f33c <rtems_rfs_group_open+0x50>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
f30c: e3a00902 mov r0, #32768 ; 0x8000 <== NOT EXECUTED
f310: e3a01000 mov r1, #0 <== NOT EXECUTED
f314: eb0007d4 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED
f318: e3500000 cmp r0, #0 <== NOT EXECUTED
f31c: 0a000067 beq f4c0 <rtems_rfs_group_open+0x1d4> <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
f320: e3a00005 mov r0, #5 <== NOT EXECUTED
f324: eb00426e bl 1fce4 <strerror> <== NOT EXECUTED
f328: e3a01005 mov r1, #5 <== NOT EXECUTED
f32c: e1a02000 mov r2, r0 <== NOT EXECUTED
f330: e59f0194 ldr r0, [pc, #404] ; f4cc <rtems_rfs_group_open+0x1e0><== NOT EXECUTED
f334: eb003dbc bl 1ea2c <printf> <== NOT EXECUTED
f338: ea000060 b f4c0 <rtems_rfs_group_open+0x1d4> <== NOT EXECUTED
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
f33c: e0881001 add r1, r8, r1
f340: e1510002 cmp r1, r2
size = rtems_rfs_fs_blocks (fs) - base;
f344: 20678002 rsbcs r8, r7, r2
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
f348: e3a00902 mov r0, #32768 ; 0x8000
f34c: e3a01000 mov r1, #0
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
size = rtems_rfs_fs_blocks (fs) - base;
f350: e1580003 cmp r8, r3
f354: 31a09008 movcc r9, r8
f358: 21a09003 movcs r9, r3
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
f35c: eb0007c2 bl 1126c <rtems_rfs_trace>
f360: e3500000 cmp r0, #0
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
f364: 159f0164 ldrne r0, [pc, #356] ; f4d0 <rtems_rfs_group_open+0x1e4>
f368: 11a01007 movne r1, r7
f36c: 11a02008 movne r2, r8
f370: 11a03009 movne r3, r9
f374: 1b003dac blne 1ea2c <printf>
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
f378: e3a05000 mov r5, #0
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,
f37c: e284b008 add fp, r4, #8
f380: e284a020 add sl, r4, #32
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;
group->size = size;
f384: e8840180 stm r4, {r7, r8}
f388: e5c45020 strb r5, [r4, #32]
handle->bnum = 0;
f38c: e5845024 str r5, [r4, #36] ; 0x24
handle->buffer = NULL;
f390: e5845028 str r5, [r4, #40] ; 0x28
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,
f394: e1a03008 mov r3, r8
f398: e1a0000b mov r0, fp
f39c: e1a01006 mov r1, r6
f3a0: e1a0200a mov r2, sl
f3a4: e58d7000 str r7, [sp]
f3a8: eb002040 bl 174b0 <rtems_rfs_bitmap_open>
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
f3ac: e2508000 subs r8, r0, #0
f3b0: da00000f ble f3f4 <rtems_rfs_group_open+0x108>
*/
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);
f3b4: e1a0100a mov r1, sl <== NOT EXECUTED
f3b8: e1a00006 mov r0, r6 <== NOT EXECUTED
f3bc: eb00247e bl 185bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
f3c0: e5c45020 strb r5, [r4, #32] <== NOT EXECUTED
handle->bnum = 0;
f3c4: e5845024 str r5, [r4, #36] ; 0x24 <== NOT EXECUTED
handle->buffer = NULL;
f3c8: e5845028 str r5, [r4, #40] ; 0x28 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
f3cc: e3a00902 mov r0, #32768 ; 0x8000 <== NOT EXECUTED
f3d0: e3a01000 mov r1, #0 <== NOT EXECUTED
f3d4: eb0007a4 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED
f3d8: e1500005 cmp r0, r5 <== NOT EXECUTED
f3dc: 0a000038 beq f4c4 <rtems_rfs_group_open+0x1d8> <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
f3e0: e1a00008 mov r0, r8 <== NOT EXECUTED
f3e4: eb00423e bl 1fce4 <strerror> <== NOT EXECUTED
f3e8: e1a02000 mov r2, r0 <== NOT EXECUTED
f3ec: e59f00e0 ldr r0, [pc, #224] ; f4d4 <rtems_rfs_group_open+0x1e8><== NOT EXECUTED
f3f0: ea000024 b f488 <rtems_rfs_group_open+0x19c> <== 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,
f3f4: e5943000 ldr r3, [r4]
f3f8: e2847044 add r7, r4, #68 ; 0x44
f3fc: e2833001 add r3, r3, #1
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
f400: e5c45044 strb r5, [r4, #68] ; 0x44
handle->bnum = 0;
f404: e5845048 str r5, [r4, #72] ; 0x48
handle->buffer = NULL;
f408: e584504c str r5, [r4, #76] ; 0x4c
f40c: e284002c add r0, r4, #44 ; 0x2c
f410: e58d3000 str r3, [sp]
f414: e1a01006 mov r1, r6
f418: e1a02007 mov r2, r7
f41c: e1a03009 mov r3, r9
f420: eb002022 bl 174b0 <rtems_rfs_bitmap_open>
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
f424: e2508000 subs r8, r0, #0
f428: da000019 ble f494 <rtems_rfs_group_open+0x1a8>
*/
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);
f42c: e1a01007 mov r1, r7 <== NOT EXECUTED
f430: e1a00006 mov r0, r6 <== NOT EXECUTED
f434: eb002460 bl 185bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
f438: e5c45044 strb r5, [r4, #68] ; 0x44 <== NOT EXECUTED
handle->bnum = 0;
f43c: e5845048 str r5, [r4, #72] ; 0x48 <== NOT EXECUTED
handle->buffer = NULL;
f440: 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);
f444: e1a0000b mov r0, fp <== NOT EXECUTED
f448: eb00202c bl 17500 <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);
f44c: e1a0100a mov r1, sl <== NOT EXECUTED
f450: e1a00006 mov r0, r6 <== NOT EXECUTED
f454: eb002458 bl 185bc <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
f458: e5c45020 strb r5, [r4, #32] <== NOT EXECUTED
handle->bnum = 0;
f45c: e5845024 str r5, [r4, #36] ; 0x24 <== NOT EXECUTED
handle->buffer = NULL;
f460: e5845028 str r5, [r4, #40] ; 0x28 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
f464: e3a00902 mov r0, #32768 ; 0x8000 <== NOT EXECUTED
f468: e3a01000 mov r1, #0 <== NOT EXECUTED
f46c: eb00077e bl 1126c <rtems_rfs_trace> <== NOT EXECUTED
f470: e3500000 cmp r0, #0 <== NOT EXECUTED
f474: 0a000012 beq f4c4 <rtems_rfs_group_open+0x1d8> <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
f478: e1a00008 mov r0, r8 <== NOT EXECUTED
f47c: eb004218 bl 1fce4 <strerror> <== NOT EXECUTED
f480: e1a02000 mov r2, r0 <== NOT EXECUTED
f484: e59f004c ldr r0, [pc, #76] ; f4d8 <rtems_rfs_group_open+0x1ec><== NOT EXECUTED
f488: e1a01008 mov r1, r8 <== NOT EXECUTED
f48c: eb003d66 bl 1ea2c <printf> <== NOT EXECUTED
f490: ea00000b b f4c4 <rtems_rfs_group_open+0x1d8> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
f494: e5968000 ldr r8, [r6]
f498: e2188001 ands r8, r8, #1
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
f49c: 11a08005 movne r8, r5
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))
f4a0: 1a000007 bne f4c4 <rtems_rfs_group_open+0x1d8>
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
f4a4: e5941008 ldr r1, [r4, #8]
f4a8: e1a00006 mov r0, r6
f4ac: eb002442 bl 185bc <rtems_rfs_buffer_handle_release>
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
f4b0: e1a00006 mov r0, r6
f4b4: e594102c ldr r1, [r4, #44] ; 0x2c
f4b8: eb00243f bl 185bc <rtems_rfs_buffer_handle_release>
f4bc: ea000000 b f4c4 <rtems_rfs_group_open+0x1d8>
if (base >= rtems_rfs_fs_blocks (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
EIO, strerror (EIO));
return EIO;
f4c0: e3a08005 mov r8, #5 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
}
f4c4: e1a00008 mov r0, r8
f4c8: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000f8d0 <rtems_rfs_group_usage>:
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
f8d0: e3a03000 mov r3, #0 <== NOT EXECUTED
int
rtems_rfs_group_usage (rtems_rfs_file_system* fs,
size_t* blocks,
size_t* inodes)
{
f8d4: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
int g;
*blocks = 0;
f8d8: e5813000 str r3, [r1] <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
f8dc: e5905024 ldr r5, [r0, #36] ; 0x24 <== NOT EXECUTED
size_t* inodes)
{
int g;
*blocks = 0;
*inodes = 0;
f8e0: e5823000 str r3, [r2] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
f8e4: e1a04003 mov r4, r3 <== NOT EXECUTED
f8e8: ea00000f b f92c <rtems_rfs_group_usage+0x5c> <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
f8ec: e590c020 ldr ip, [r0, #32] <== NOT EXECUTED
f8f0: e08cc003 add ip, ip, r3 <== NOT EXECUTED
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
f8f4: e28c7014 add r7, ip, #20 <== NOT EXECUTED
f8f8: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED
f8fc: e0466007 sub r6, r6, r7 <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
f900: e5917000 ldr r7, [r1] <== NOT EXECUTED
f904: e0876006 add r6, r7, r6 <== NOT EXECUTED
f908: e5816000 str r6, [r1] <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
f90c: e28c6038 add r6, ip, #56 ; 0x38 <== NOT EXECUTED
f910: e8961040 ldm r6, {r6, ip} <== NOT EXECUTED
f914: e046c00c sub ip, r6, ip <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
f918: e5926000 ldr r6, [r2] <== NOT EXECUTED
f91c: e086c00c add ip, r6, ip <== NOT EXECUTED
f920: e582c000 str ip, [r2] <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
f924: e2844001 add r4, r4, #1 <== NOT EXECUTED
f928: e2833050 add r3, r3, #80 ; 0x50 <== NOT EXECUTED
f92c: e1540005 cmp r4, r5 <== NOT EXECUTED
f930: baffffed blt f8ec <rtems_rfs_group_usage+0x1c> <== 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))
f934: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED
f938: e591c000 ldr ip, [r1] <== NOT EXECUTED
f93c: e15c0003 cmp ip, r3 <== NOT EXECUTED
f940: 9581c000 strls ip, [r1] <== NOT EXECUTED
f944: 85813000 strhi r3, [r1] <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
f948: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED
f94c: e5921000 ldr r1, [r2] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
f950: 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))
f954: e1510003 cmp r1, r3 <== NOT EXECUTED
f958: 95821000 strls r1, [r2] <== NOT EXECUTED
f95c: 85823000 strhi r3, [r2] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
f960: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
0000fc08 <rtems_rfs_inode_close>:
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
fc08: e92d4030 push {r4, r5, lr}
fc0c: e1a05000 mov r5, r0
fc10: e1a04001 mov r4, r1
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
fc14: e3a00702 mov r0, #524288 ; 0x80000
fc18: e3a01000 mov r1, #0
fc1c: eb000592 bl 1126c <rtems_rfs_trace>
fc20: e3500000 cmp r0, #0
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
fc24: 159f0054 ldrne r0, [pc, #84] ; fc80 <rtems_rfs_inode_close+0x78>
fc28: 15941008 ldrne r1, [r4, #8]
fc2c: 1b003b7e blne 1ea2c <printf>
rc = rtems_rfs_inode_unload (fs, handle, true);
fc30: e1a00005 mov r0, r5
fc34: e1a01004 mov r1, r4
fc38: e3a02001 mov r2, #1
fc3c: ebffffb6 bl fb1c <rtems_rfs_inode_unload>
if ((rc == 0) && (handle->loads > 0))
fc40: e3500000 cmp r0, #0
fc44: 1a00000a bne fc74 <rtems_rfs_inode_close+0x6c>
fc48: e5943024 ldr r3, [r4, #36] ; 0x24
fc4c: e3530000 cmp r3, #0
fc50: da000007 ble fc74 <rtems_rfs_inode_close+0x6c>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
fc54: e3a00702 mov r0, #524288 ; 0x80000 <== NOT EXECUTED
fc58: e3a01000 mov r1, #0 <== NOT EXECUTED
fc5c: eb000582 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED
fc60: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
fc64: 159f0018 ldrne r0, [pc, #24] ; fc84 <rtems_rfs_inode_close+0x7c><== NOT EXECUTED
fc68: 15941024 ldrne r1, [r4, #36] ; 0x24 <== NOT EXECUTED
fc6c: 1b003b6e blne 1ea2c <printf> <== NOT EXECUTED
handle->loads);
rc = EIO;
fc70: e3a00005 mov r0, #5 <== NOT EXECUTED
}
handle->ino = 0;
fc74: e3a03000 mov r3, #0
fc78: e5843008 str r3, [r4, #8]
return rc; }
fc7c: e8bd8030 pop {r4, r5, pc}
0000ff7c <rtems_rfs_inode_create>:
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
ff7c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
ff80: e24dd060 sub sp, sp, #96 ; 0x60
ff84: e1a09003 mov r9, r3
ff88: e1dd38b8 ldrh r3, [sp, #136] ; 0x88
ff8c: e58d3004 str r3, [sp, #4]
ff90: e1dd38bc ldrh r3, [sp, #140] ; 0x8c
ff94: e58d3008 str r3, [sp, #8]
ff98: e1dd39b0 ldrh r3, [sp, #144] ; 0x90
ff9c: e1a04000 mov r4, r0
ffa0: e1a08001 mov r8, r1
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
ffa4: e3a00501 mov r0, #4194304 ; 0x400000
ffa8: e3a01000 mov r1, #0
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
ffac: e1a0a002 mov sl, r2
ffb0: e59d5094 ldr r5, [sp, #148] ; 0x94
ffb4: e1dd78b4 ldrh r7, [sp, #132] ; 0x84
ffb8: e58d300c str r3, [sp, #12]
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
ffbc: eb0004aa bl 1126c <rtems_rfs_trace>
ffc0: e3500000 cmp r0, #0
ffc4: 0a000020 beq 1004c <rtems_rfs_inode_create+0xd0>
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
ffc8: e2073a0f and r3, r7, #61440 ; 0xf000 <== NOT EXECUTED
ffcc: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED
type = "dir";
ffd0: 059f6270 ldreq r6, [pc, #624] ; 10248 <rtems_rfs_inode_create+0x2cc><== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
ffd4: 0a00000c beq 1000c <rtems_rfs_inode_create+0x90> <== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
ffd8: e3530a02 cmp r3, #8192 ; 0x2000 <== NOT EXECUTED
type = "char";
ffdc: 059f6268 ldreq r6, [pc, #616] ; 1024c <rtems_rfs_inode_create+0x2d0><== NOT EXECUTED
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
ffe0: 0a000009 beq 1000c <rtems_rfs_inode_create+0x90> <== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
ffe4: e3530a06 cmp r3, #24576 ; 0x6000 <== NOT EXECUTED
type = "block";
ffe8: 059f6260 ldreq r6, [pc, #608] ; 10250 <rtems_rfs_inode_create+0x2d4><== NOT EXECUTED
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
ffec: 0a000006 beq 1000c <rtems_rfs_inode_create+0x90> <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
fff0: e3530902 cmp r3, #32768 ; 0x8000 <== NOT EXECUTED
type = "file";
fff4: 059f6258 ldreq r6, [pc, #600] ; 10254 <rtems_rfs_inode_create+0x2d8><== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
fff8: 0a000003 beq 1000c <rtems_rfs_inode_create+0x90> <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
fffc: e59f2254 ldr r2, [pc, #596] ; 10258 <rtems_rfs_inode_create+0x2dc><== NOT EXECUTED
10000: e3530a0a cmp r3, #40960 ; 0xa000 <== NOT EXECUTED
10004: e59f6250 ldr r6, [pc, #592] ; 1025c <rtems_rfs_inode_create+0x2e0><== NOT EXECUTED
10008: 11a06002 movne r6, r2 <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
1000c: e59f024c ldr r0, [pc, #588] ; 10260 <rtems_rfs_inode_create+0x2e4><== NOT EXECUTED 10010: e1a01008 mov r1, r8 <== NOT EXECUTED 10014: eb003a84 bl 1ea2c <printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
10018: e3a0b000 mov fp, #0 <== NOT EXECUTED 1001c: ea000002 b 1002c <rtems_rfs_inode_create+0xb0> <== NOT EXECUTED
printf ("%c", name[c]);
10020: e7da000b ldrb r0, [sl, fp] <== NOT EXECUTED 10024: eb003aea bl 1ebd4 <putchar> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
10028: e28bb001 add fp, fp, #1 <== NOT EXECUTED 1002c: e15b0009 cmp fp, r9 <== NOT EXECUTED 10030: 1afffffa bne 10020 <rtems_rfs_inode_create+0xa4> <== NOT EXECUTED
printf ("%c", name[c]);
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
10034: e1a03b07 lsl r3, r7, #22 <== NOT EXECUTED 10038: e59f0224 ldr r0, [pc, #548] ; 10264 <rtems_rfs_inode_create+0x2e8><== NOT EXECUTED 1003c: e1a01006 mov r1, r6 <== NOT EXECUTED 10040: e1a02007 mov r2, r7 <== NOT EXECUTED 10044: e1a03b23 lsr r3, r3, #22 <== NOT EXECUTED 10048: eb003a77 bl 1ea2c <printf> <== NOT EXECUTED
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
1004c: e2076a0f and r6, r7, #61440 ; 0xf000 10050: e3560a06 cmp r6, #24576 ; 0x6000
10054: 0a000009 beq 10080 <rtems_rfs_inode_create+0x104> 10058: ca000003 bgt 1006c <rtems_rfs_inode_create+0xf0>
1005c: e3560a02 cmp r6, #8192 ; 0x2000
10060: 0a000006 beq 10080 <rtems_rfs_inode_create+0x104>
10064: e3560901 cmp r6, #16384 ; 0x4000 10068: ea000002 b 10078 <rtems_rfs_inode_create+0xfc> 1006c: e3560902 cmp r6, #32768 ; 0x8000
10070: 0a000002 beq 10080 <rtems_rfs_inode_create+0x104>
10074: e3560a0a cmp r6, #40960 ; 0xa000
case RTEMS_RFS_S_IFBLK:
case RTEMS_RFS_S_IFREG:
case RTEMS_RFS_S_IFLNK:
break;
default:
return EINVAL;
10078: 13a0b016 movne fp, #22
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
1007c: 1a00006e bne 1023c <rtems_rfs_inode_create+0x2c0>
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
10080: e1a00004 mov r0, r4 10084: e1a01008 mov r1, r8 10088: e1a02005 mov r2, r5 1008c: ebfffe34 bl f964 <rtems_rfs_inode_alloc>
if (rc > 0)
10090: e250b000 subs fp, r0, #0
10094: ca000068 bgt 1023c <rtems_rfs_inode_create+0x2c0>
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
10098: e1a00004 mov r0, r4 1009c: e5951000 ldr r1, [r5] 100a0: e28d2038 add r2, sp, #56 ; 0x38 100a4: e3a03001 mov r3, #1 100a8: ebfffe61 bl fa34 <rtems_rfs_inode_open>
if (rc > 0)
100ac: e250b000 subs fp, r0, #0
100b0: ca00005e bgt 10230 <rtems_rfs_inode_create+0x2b4>
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
100b4: e59d300c ldr r3, [sp, #12] 100b8: e28d0038 add r0, sp, #56 ; 0x38 100bc: e58d3000 str r3, [sp] 100c0: e59d1004 ldr r1, [sp, #4] 100c4: e1a02007 mov r2, r7 100c8: e59d3008 ldr r3, [sp, #8] 100cc: ebffff4f bl fe10 <rtems_rfs_inode_initialise>
if (rc > 0)
100d0: e250b000 subs fp, r0, #0
100d4: da000003 ble 100e8 <rtems_rfs_inode_create+0x16c>
{
rtems_rfs_inode_close (fs, &inode);
100d8: e1a00004 mov r0, r4 <== NOT EXECUTED 100dc: e28d1038 add r1, sp, #56 ; 0x38 <== NOT EXECUTED 100e0: ebfffec8 bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED 100e4: ea000051 b 10230 <rtems_rfs_inode_create+0x2b4> <== 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))
100e8: e3560901 cmp r6, #16384 ; 0x4000
100ec: 1a000011 bne 10138 <rtems_rfs_inode_create+0x1bc>
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
100f0: e5953000 ldr r3, [r5] 100f4: e1a00004 mov r0, r4 100f8: e58d3000 str r3, [sp] 100fc: e28d1038 add r1, sp, #56 ; 0x38 10100: e59f2160 ldr r2, [pc, #352] ; 10268 <rtems_rfs_inode_create+0x2ec> 10104: e3a03001 mov r3, #1 10108: eb00245a bl 19278 <rtems_rfs_dir_add_entry>
if (rc == 0)
1010c: e250b000 subs fp, r0, #0
10110: 1a000006 bne 10130 <rtems_rfs_inode_create+0x1b4>
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
10114: e1a00004 mov r0, r4 10118: e28d1038 add r1, sp, #56 ; 0x38 1011c: e59f2148 ldr r2, [pc, #328] ; 1026c <rtems_rfs_inode_create+0x2f0> 10120: e3a03002 mov r3, #2 10124: e58d8000 str r8, [sp] 10128: eb002452 bl 19278 <rtems_rfs_dir_add_entry> 1012c: e1a0b000 mov fp, r0
if (rc > 0)
10130: e35b0000 cmp fp, #0
10134: ca000006 bgt 10154 <rtems_rfs_inode_create+0x1d8>
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
10138: e1a00004 mov r0, r4 1013c: e1a01008 mov r1, r8 10140: e28d2010 add r2, sp, #16 10144: e3a03001 mov r3, #1 10148: ebfffe39 bl fa34 <rtems_rfs_inode_open>
if (rc > 0)
1014c: e250b000 subs fp, r0, #0
10150: da000002 ble 10160 <rtems_rfs_inode_create+0x1e4>
{
rtems_rfs_inode_delete (fs, &inode);
10154: e1a00004 mov r0, r4 <== NOT EXECUTED 10158: e28d1038 add r1, sp, #56 ; 0x38 <== NOT EXECUTED 1015c: ea00002a b 1020c <rtems_rfs_inode_create+0x290> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
10160: e5953000 ldr r3, [r5] 10164: e1a00004 mov r0, r4 10168: e58d3000 str r3, [sp] 1016c: e28d1010 add r1, sp, #16 10170: e1a0200a mov r2, sl 10174: e1a03009 mov r3, r9 10178: eb00243e bl 19278 <rtems_rfs_dir_add_entry>
if (rc > 0)
1017c: e250b000 subs fp, r0, #0
10180: da000008 ble 101a8 <rtems_rfs_inode_create+0x22c>
{
rtems_rfs_inode_delete (fs, &inode);
10184: e28d1038 add r1, sp, #56 ; 0x38 <== NOT EXECUTED 10188: e1a00004 mov r0, r4 <== NOT EXECUTED 1018c: ebfffebd bl fc88 <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
10190: e28d1038 add r1, sp, #56 ; 0x38 <== NOT EXECUTED 10194: e1a00004 mov r0, r4 <== NOT EXECUTED 10198: ebfffe9a bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
1019c: e1a00004 mov r0, r4 <== NOT EXECUTED 101a0: e28d1010 add r1, sp, #16 <== NOT EXECUTED 101a4: ea00001b b 10218 <rtems_rfs_inode_create+0x29c> <== 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))
101a8: e3560901 cmp r6, #16384 ; 0x4000
101ac: 1a00000f bne 101f0 <rtems_rfs_inode_create+0x274>
*/
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);
101b0: e59d201c ldr r2, [sp, #28] 101b4: e5d21000 ldrb r1, [r2] 101b8: e5d23001 ldrb r3, [r2, #1] 101bc: e1833401 orr r3, r3, r1, lsl #8
if (links == 0xffff)
links = 0;
101c0: e59f10a8 ldr r1, [pc, #168] ; 10270 <rtems_rfs_inode_create+0x2f4> 101c4: e1530001 cmp r3, r1 101c8: 03a03000 moveq r3, #0
rtems_rfs_inode_set_links (&parent_inode,
101cc: e2833001 add r3, r3, #1 101d0: e1a03803 lsl r3, r3, #16 101d4: e1a01823 lsr r1, r3, #16
* @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);
101d8: e1a03c23 lsr r3, r3, #24 101dc: e5c23000 strb r3, [r2] 101e0: e59d301c ldr r3, [sp, #28] 101e4: e5c31001 strb r1, [r3, #1]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
101e8: e3a03001 mov r3, #1 101ec: e5cd3020 strb r3, [sp, #32]
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
101f0: e28d1010 add r1, sp, #16 101f4: e1a00004 mov r0, r4 101f8: ebfffe82 bl fc08 <rtems_rfs_inode_close>
if (rc > 0)
101fc: e250b000 subs fp, r0, #0
{
rtems_rfs_inode_delete (fs, &inode);
10200: e28d1038 add r1, sp, #56 ; 0x38 10204: e1a00004 mov r0, r4
if (RTEMS_RFS_S_ISDIR (mode))
rtems_rfs_inode_set_links (&parent_inode,
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
if (rc > 0)
10208: da000004 ble 10220 <rtems_rfs_inode_create+0x2a4>
{
rtems_rfs_inode_delete (fs, &inode);
1020c: ebfffe9d bl fc88 <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
10210: e1a00004 mov r0, r4 <== NOT EXECUTED 10214: e28d1038 add r1, sp, #56 ; 0x38 <== NOT EXECUTED 10218: ebfffe7a bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
1021c: ea000006 b 1023c <rtems_rfs_inode_create+0x2c0> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
10220: ebfffe78 bl fc08 <rtems_rfs_inode_close>
if (rc > 0)
10224: e250b000 subs fp, r0, #0
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
return 0;
10228: d3a0b000 movle fp, #0
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
1022c: da000002 ble 1023c <rtems_rfs_inode_create+0x2c0>
{
rtems_rfs_inode_free (fs, *ino);
10230: e1a00004 mov r0, r4 <== NOT EXECUTED 10234: e5951000 ldr r1, [r5] <== NOT EXECUTED 10238: ebfffdd1 bl f984 <rtems_rfs_inode_free> <== NOT EXECUTED
return rc;
}
return 0;
}
1023c: e1a0000b mov r0, fp
10240: e28dd060 add sp, sp, #96 ; 0x60
10244: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000fc88 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
fc88: e92d4030 push {r4, r5, lr}
fc8c: e1a05000 mov r5, r0
fc90: e24dd050 sub sp, sp, #80 ; 0x50
fc94: e1a04001 mov r4, r1
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
fc98: e3a00502 mov r0, #8388608 ; 0x800000
fc9c: e3a01000 mov r1, #0
fca0: eb000571 bl 1126c <rtems_rfs_trace>
fca4: e3500000 cmp r0, #0
fca8: 0a000007 beq fccc <rtems_rfs_inode_delete+0x44>
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
fcac: e594c00c ldr ip, [r4, #12] <== NOT EXECUTED
fcb0: e59f309c ldr r3, [pc, #156] ; fd54 <rtems_rfs_inode_delete+0xcc><== NOT EXECUTED
fcb4: e35c0000 cmp ip, #0 <== NOT EXECUTED
fcb8: e59f2098 ldr r2, [pc, #152] ; fd58 <rtems_rfs_inode_delete+0xd0><== NOT EXECUTED
fcbc: e59f0098 ldr r0, [pc, #152] ; fd5c <rtems_rfs_inode_delete+0xd4><== NOT EXECUTED
fcc0: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED
fcc4: 11a02003 movne r2, r3 <== NOT EXECUTED
fcc8: eb003b57 bl 1ea2c <printf> <== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
fccc: e594000c ldr r0, [r4, #12]
fcd0: e3500000 cmp r0, #0
fcd4: 0a00001c beq fd4c <rtems_rfs_inode_delete+0xc4>
rtems_rfs_block_map map;
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
fcd8: e1a00005 mov r0, r5
fcdc: e5941008 ldr r1, [r4, #8]
fce0: ebffff27 bl f984 <rtems_rfs_inode_free>
if (rc > 0)
fce4: e3500000 cmp r0, #0
fce8: ca000017 bgt fd4c <rtems_rfs_inode_delete+0xc4>
return rc;
/*
* Free the blocks the inode may have attached.
*/
rc = rtems_rfs_block_map_open (fs, handle, &map);
fcec: e1a00005 mov r0, r5
fcf0: e1a01004 mov r1, r4
fcf4: e1a0200d mov r2, sp
fcf8: eb001ee6 bl 17898 <rtems_rfs_block_map_open>
if (rc == 0)
fcfc: e3500000 cmp r0, #0
fd00: 1a000011 bne fd4c <rtems_rfs_inode_delete+0xc4>
{
int rrc;
rrc = rtems_rfs_block_map_free_all (fs, &map);
fd04: e1a0100d mov r1, sp
fd08: e1a00005 mov r0, r5
fd0c: eb0021cc bl 18444 <rtems_rfs_block_map_free_all>
rc = rtems_rfs_block_map_close (fs, &map);
fd10: e1a0100d mov r1, sp
fd14: e1a00005 mov r0, r5
fd18: eb001f37 bl 179fc <rtems_rfs_block_map_close>
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
fd1c: e3a010ff mov r1, #255 ; 0xff
fd20: e3a02038 mov r2, #56 ; 0x38
fd24: e594000c ldr r0, [r4, #12]
fd28: eb003ace bl 1e868 <memset>
rtems_rfs_buffer_mark_dirty (&handle->buffer);
fd2c: e3a03001 mov r3, #1
fd30: e1a01004 mov r1, r4
fd34: e5e13010 strb r3, [r1, #16]!
/*
* 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);
fd38: e1a00005 mov r0, r5
fd3c: eb00221e bl 185bc <rtems_rfs_buffer_handle_release>
handle->loads = 0;
fd40: e3a03000 mov r3, #0
fd44: e5843024 str r3, [r4, #36] ; 0x24
handle->node = NULL;
fd48: e584300c str r3, [r4, #12]
}
}
return rc;
}
fd4c: e28dd050 add sp, sp, #80 ; 0x50
fd50: e8bd8030 pop {r4, r5, pc}
000102d8 <rtems_rfs_inode_get_block>:
* @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]);
102d8: e590200c ldr r2, [r0, #12] <== NOT EXECUTED 102dc: e282301c add r3, r2, #28 <== NOT EXECUTED 102e0: e0833101 add r3, r3, r1, lsl #2 <== NOT EXECUTED 102e4: e2811007 add r1, r1, #7 <== NOT EXECUTED 102e8: e5d30003 ldrb r0, [r3, #3] <== NOT EXECUTED 102ec: e7d22101 ldrb r2, [r2, r1, lsl #2] <== NOT EXECUTED 102f0: e5d31001 ldrb r1, [r3, #1] <== NOT EXECUTED 102f4: e1802c02 orr r2, r0, r2, lsl #24 <== NOT EXECUTED 102f8: e5d30002 ldrb r0, [r3, #2] <== NOT EXECUTED 102fc: e1822801 orr r2, r2, r1, lsl #16 <== NOT EXECUTED
}
10300: e1820400 orr r0, r2, r0, lsl #8 <== NOT EXECUTED 10304: e12fff1e bx lr <== NOT EXECUTED
0000f990 <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
f990: e92d4030 push {r4, r5, lr}
f994: e1a05000 mov r5, r0
f998: e1a04001 mov r4, r1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
f99c: e3a00601 mov r0, #1048576 ; 0x100000
f9a0: e3a01000 mov r1, #0
f9a4: eb000630 bl 1126c <rtems_rfs_trace>
f9a8: e3500000 cmp r0, #0
f9ac: 0a000008 beq f9d4 <rtems_rfs_inode_load+0x44>
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
f9b0: e594e00c ldr lr, [r4, #12] <== NOT EXECUTED
f9b4: e59fc06c ldr ip, [pc, #108] ; fa28 <rtems_rfs_inode_load+0x98><== NOT EXECUTED
f9b8: e35e0000 cmp lr, #0 <== NOT EXECUTED
f9bc: e59f3068 ldr r3, [pc, #104] ; fa2c <rtems_rfs_inode_load+0x9c><== NOT EXECUTED
f9c0: e59f0068 ldr r0, [pc, #104] ; fa30 <rtems_rfs_inode_load+0xa0><== NOT EXECUTED
f9c4: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED
f9c8: e5942024 ldr r2, [r4, #36] ; 0x24 <== NOT EXECUTED
f9cc: 11a0300c movne r3, ip <== NOT EXECUTED
f9d0: eb003c15 bl 1ea2c <printf> <== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
f9d4: e594300c ldr r3, [r4, #12]
f9d8: e3530000 cmp r3, #0
f9dc: 1a00000c bne fa14 <rtems_rfs_inode_load+0x84>
{
int rc;
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
f9e0: e1a00005 mov r0, r5
f9e4: e2841010 add r1, r4, #16
f9e8: e594201c ldr r2, [r4, #28]
f9ec: e3a03001 mov r3, #1
f9f0: eb00235d bl 1876c <rtems_rfs_buffer_handle_request>
handle->block, true);
if (rc > 0)
f9f4: e3500000 cmp r0, #0
f9f8: c8bd8030 popgt {r4, r5, pc}
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
f9fc: e5942018 ldr r2, [r4, #24]
handle->node += handle->offset;
fa00: e5943020 ldr r3, [r4, #32]
fa04: e592201c ldr r2, [r2, #28]
fa08: e3a01038 mov r1, #56 ; 0x38
fa0c: e0232391 mla r3, r1, r3, r2
fa10: e584300c str r3, [r4, #12]
}
handle->loads++;
fa14: e5943024 ldr r3, [r4, #36] ; 0x24
fa18: e2833001 add r3, r3, #1
fa1c: e5843024 str r3, [r4, #36] ; 0x24
return 0;
fa20: e3a00000 mov r0, #0
}
fa24: e8bd8030 pop {r4, r5, pc}
0000fa34 <rtems_rfs_inode_open>:
int
rtems_rfs_inode_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
rtems_rfs_inode_handle* handle,
bool load)
{
fa34: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
fa38: e1a04000 mov r4, r0
fa3c: e1a05001 mov r5, r1
int group;
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
fa40: e3a00701 mov r0, #262144 ; 0x40000
fa44: e3a01000 mov r1, #0
int
rtems_rfs_inode_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
rtems_rfs_inode_handle* handle,
bool load)
{
fa48: e1a06002 mov r6, r2
fa4c: e20380ff and r8, r3, #255 ; 0xff
int group;
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
fa50: eb000605 bl 1126c <rtems_rfs_trace>
fa54: e3500000 cmp r0, #0
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
fa58: 159f00b8 ldrne r0, [pc, #184] ; fb18 <rtems_rfs_inode_open+0xe4>
fa5c: 11a01005 movne r1, r5
fa60: 1b003bf1 blne 1ea2c <printf>
if (ino == RTEMS_RFS_EMPTY_INO)
fa64: e3550000 cmp r5, #0
return EINVAL;
fa68: 03a00016 moveq r0, #22
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)
fa6c: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
fa70: e5943014 ldr r3, [r4, #20]
fa74: e2457001 sub r7, r5, #1
fa78: e1570003 cmp r7, r3
fa7c: 8a000023 bhi fb10 <rtems_rfs_inode_open+0xdc>
handle->ino = ino;
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
fa80: e594902c ldr r9, [r4, #44] ; 0x2c
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
fa84: e5865008 str r5, [r6, #8]
handle->node = NULL;
fa88: e3a05000 mov r5, #0
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
fa8c: e1a00007 mov r0, r7
fa90: e1a01009 mov r1, r9
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
handle->node = NULL;
fa94: e586500c str r5, [r6, #12]
handle->loads = 0;
fa98: e5865024 str r5, [r6, #36] ; 0x24
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
fa9c: eb006d55 bl 2aff8 <__umodsi3>
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
faa0: e594a030 ldr sl, [r4, #48] ; 0x30
handle->offset = gino % fs->inodes_per_block;
faa4: e1a0100a mov r1, sl
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
faa8: e1a0b000 mov fp, r0
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
faac: eb006d51 bl 2aff8 <__umodsi3>
handle->ino = ino;
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
fab0: e1a01009 mov r1, r9
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
fab4: e5860020 str r0, [r6, #32]
handle->ino = ino;
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
fab8: e1a00007 mov r0, r7
fabc: ebffc79f bl 1940 <__aeabi_uidiv>
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);
fac0: e3a02050 mov r2, #80 ; 0x50
fac4: e0020290 mul r2, r0, r2
fac8: e5943020 ldr r3, [r4, #32]
handle->loads = 0;
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;
facc: e1a0000b mov r0, fp
fad0: e1a0100a mov r1, sl
fad4: e7937002 ldr r7, [r3, r2]
fad8: ebffc798 bl 1940 <__aeabi_uidiv>
fadc: e2877002 add r7, r7, #2
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
fae0: e0870000 add r0, r7, r0
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
fae4: e1580005 cmp r8, r5
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);
fae8: e586001c str r0, [r6, #28]
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
faec: e5c65010 strb r5, [r6, #16]
handle->bnum = 0;
faf0: e5865014 str r5, [r6, #20]
handle->buffer = NULL;
faf4: e5865018 str r5, [r6, #24]
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
faf8: 01a00008 moveq r0, r8
if ((rc == 0) && load)
fafc: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rc = rtems_rfs_inode_load (fs, handle);
fb00: e1a00004 mov r0, r4
fb04: e1a01006 mov r1, r6
return rc; }
fb08: e8bd4ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, lr}
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);
fb0c: eaffff9f b f990 <rtems_rfs_inode_load>
if (ino == RTEMS_RFS_EMPTY_INO)
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
fb10: e3a00016 mov r0, #22 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
rc = rtems_rfs_inode_load (fs, handle);
return rc;
}
fb14: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0000e718 <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,
e718: e590302c ldr r3, [r0, #44] ; 0x2c <== NOT EXECUTED
/**
* Return the inode overhead given a number of inodes.
*/
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
e71c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
int blocks; int bits_per_block; blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
e720: e5905008 ldr r5, [r0, #8] <== NOT EXECUTED
/**
* Return the inode overhead given a number of inodes.
*/
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
e724: e1a04000 mov r4, r0 <== NOT EXECUTED
int blocks; int bits_per_block; blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
e728: e3a00038 mov r0, #56 ; 0x38 <== NOT EXECUTED
e72c: e1a01005 mov r1, r5 <== NOT EXECUTED
e730: e0000093 mul r0, r3, r0 <== NOT EXECUTED
e734: ebffffee bl e6f4 <rtems_rfs_rup_quotient> <== 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))
e738: 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));
e73c: 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))
e740: e2433001 sub r3, r3, #1 <== NOT EXECUTED
bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
return ((blocks + 1) * 100 * 10) / bits_per_block;
e744: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED
e748: e2800001 add r0, r0, #1 <== NOT EXECUTED
e74c: e0000092 mul r0, r2, r0 <== NOT EXECUTED
e750: e1510003 cmp r1, r3 <== NOT EXECUTED
e754: 21a01003 movcs r1, r3 <== NOT EXECUTED
e758: eb0071d4 bl 2aeb0 <__aeabi_idiv> <== NOT EXECUTED
}
e75c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00010308 <rtems_rfs_inode_set_block>:
* @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);
10308: e590300c ldr r3, [r0, #12] <== NOT EXECUTED
* @param block The block index.
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
1030c: e92d4010 push {r4, lr} <== NOT EXECUTED
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
10310: e281c007 add ip, r1, #7 <== NOT EXECUTED 10314: e1a04c22 lsr r4, r2, #24 <== NOT EXECUTED 10318: e7c3410c strb r4, [r3, ip, lsl #2] <== NOT EXECUTED 1031c: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 10320: e1a01101 lsl r1, r1, #2 <== NOT EXECUTED 10324: e0833001 add r3, r3, r1 <== NOT EXECUTED 10328: e1a0c822 lsr ip, r2, #16 <== NOT EXECUTED 1032c: e5c3c01d strb ip, [r3, #29] <== NOT EXECUTED 10330: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 10334: e1a0c422 lsr ip, r2, #8 <== NOT EXECUTED 10338: e0833001 add r3, r3, r1 <== NOT EXECUTED 1033c: e5c3c01e strb ip, [r3, #30] <== NOT EXECUTED 10340: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 10344: e0831001 add r1, r3, r1 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
10348: e3a03001 mov r3, #1 <== 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);
1034c: e5c1201f strb r2, [r1, #31] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
10350: e5c03010 strb r3, [r0, #16] <== NOT EXECUTED
}
10354: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0000fd60 <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))
fd60: e590300c ldr r3, [r0, #12]
fd64: e3530000 cmp r3, #0
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
fd68: e92d4070 push {r4, r5, r6, lr}
fd6c: e1a04000 mov r4, r0
fd70: e20160ff and r6, r1, #255 ; 0xff
fd74: e20250ff and r5, r2, #255 ; 0xff
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
return ENXIO;
fd78: 03a00006 moveq r0, #6
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))
fd7c: 08bd8070 popeq {r4, r5, r6, pc}
return ENXIO;
now = time (NULL);
fd80: e3a00000 mov r0, #0
fd84: eb004b63 bl 22b18 <time>
if (atime)
fd88: e3560000 cmp r6, #0
fd8c: 0a00000c beq fdc4 <rtems_rfs_inode_time_stamp_now+0x64>
*/
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);
fd90: e594300c ldr r3, [r4, #12]
fd94: e1a02c20 lsr r2, r0, #24
fd98: e5c32010 strb r2, [r3, #16]
fd9c: e594300c ldr r3, [r4, #12]
fda0: e1a02820 lsr r2, r0, #16
fda4: e5c32011 strb r2, [r3, #17]
fda8: e594300c ldr r3, [r4, #12]
fdac: e1a02420 lsr r2, r0, #8
fdb0: e5c32012 strb r2, [r3, #18]
fdb4: e594300c ldr r3, [r4, #12]
fdb8: e5c30013 strb r0, [r3, #19]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
fdbc: e3a03001 mov r3, #1
fdc0: e5c43010 strb r3, [r4, #16]
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
fdc4: e3550000 cmp r5, #0
fdc8: 0a00000e beq fe08 <rtems_rfs_inode_time_stamp_now+0xa8>
*/
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);
fdcc: e594300c ldr r3, [r4, #12]
fdd0: e1a02c20 lsr r2, r0, #24
fdd4: e5c32014 strb r2, [r3, #20]
fdd8: e594300c ldr r3, [r4, #12]
fddc: e1a02820 lsr r2, r0, #16
fde0: e5c32015 strb r2, [r3, #21]
fde4: e594300c ldr r3, [r4, #12]
fde8: e1a02420 lsr r2, r0, #8
fdec: e5c32016 strb r2, [r3, #22]
fdf0: e594300c ldr r3, [r4, #12]
fdf4: e5c30017 strb r0, [r3, #23]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
fdf8: e3a03001 mov r3, #1
fdfc: e5c43010 strb r3, [r4, #16]
rtems_rfs_inode_set_mtime (handle, now);
return 0;
fe00: e3a00000 mov r0, #0
fe04: e8bd8070 pop {r4, r5, r6, pc}
fe08: e1a00005 mov r0, r5 <== NOT EXECUTED
}
fe0c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
0000fb1c <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
fb1c: e92d4070 push {r4, r5, r6, lr}
fb20: e1a05000 mov r5, r0
fb24: e1a04001 mov r4, r1
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
fb28: e3a00602 mov r0, #2097152 ; 0x200000
fb2c: e3a01000 mov r1, #0
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
fb30: e20260ff and r6, r2, #255 ; 0xff
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
fb34: eb0005cc bl 1126c <rtems_rfs_trace>
fb38: e3500000 cmp r0, #0
fb3c: 0a000008 beq fb64 <rtems_rfs_inode_unload+0x48>
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
fb40: e594e00c ldr lr, [r4, #12] <== NOT EXECUTED
fb44: e59fc0b0 ldr ip, [pc, #176] ; fbfc <rtems_rfs_inode_unload+0xe0><== NOT EXECUTED
fb48: e35e0000 cmp lr, #0 <== NOT EXECUTED
fb4c: e59f30ac ldr r3, [pc, #172] ; fc00 <rtems_rfs_inode_unload+0xe4><== NOT EXECUTED
fb50: e59f00ac ldr r0, [pc, #172] ; fc04 <rtems_rfs_inode_unload+0xe8><== NOT EXECUTED
fb54: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED
fb58: e5942024 ldr r2, [r4, #36] ; 0x24 <== NOT EXECUTED
fb5c: 11a0300c movne r3, ip <== NOT EXECUTED
fb60: eb003bb1 bl 1ea2c <printf> <== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
fb64: e594000c ldr r0, [r4, #12]
fb68: e3500000 cmp r0, #0
fb6c: 08bd8070 popeq {r4, r5, r6, pc}
{
if (handle->loads == 0)
fb70: e5940024 ldr r0, [r4, #36] ; 0x24
fb74: e3500000 cmp r0, #0
return EIO;
fb78: 03a00005 moveq r0, #5
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
{
if (handle->loads == 0)
fb7c: 08bd8070 popeq {r4, r5, r6, pc}
return EIO;
handle->loads--;
fb80: e2400001 sub r0, r0, #1
if (handle->loads == 0)
fb84: e3500000 cmp r0, #0
if (rtems_rfs_inode_is_loaded (handle))
{
if (handle->loads == 0)
return EIO;
handle->loads--;
fb88: e5840024 str r0, [r4, #36] ; 0x24
if (handle->loads == 0)
fb8c: 1a000018 bne fbf4 <rtems_rfs_inode_unload+0xd8>
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
fb90: e5d43010 ldrb r3, [r4, #16]
fb94: e3530000 cmp r3, #0
fb98: 0a00000f beq fbdc <rtems_rfs_inode_unload+0xc0>
fb9c: e3560000 cmp r6, #0
fba0: 0a00000d beq fbdc <rtems_rfs_inode_unload+0xc0>
rtems_rfs_inode_set_ctime (handle, time (NULL));
fba4: eb004bdb bl 22b18 <time>
*/
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);
fba8: e594300c ldr r3, [r4, #12]
fbac: e1a02c20 lsr r2, r0, #24
fbb0: e5c32018 strb r2, [r3, #24]
fbb4: e594300c ldr r3, [r4, #12]
fbb8: e1a02820 lsr r2, r0, #16
fbbc: e5c32019 strb r2, [r3, #25]
fbc0: e594300c ldr r3, [r4, #12]
fbc4: e1a02420 lsr r2, r0, #8
fbc8: e5c3201a strb r2, [r3, #26]
fbcc: e594300c ldr r3, [r4, #12]
fbd0: e5c3001b strb r0, [r3, #27]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
fbd4: e3a03001 mov r3, #1
fbd8: e5c43010 strb r3, [r4, #16]
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
fbdc: e1a00005 mov r0, r5
fbe0: e2841010 add r1, r4, #16
fbe4: eb002274 bl 185bc <rtems_rfs_buffer_handle_release>
handle->node = NULL;
fbe8: e3a03000 mov r3, #0
fbec: e584300c str r3, [r4, #12]
fbf0: e8bd8070 pop {r4, r5, r6, pc}
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
int rc = 0;
fbf4: e3a00000 mov r0, #0
handle->node = NULL;
}
}
return rc;
}
fbf8: e8bd8070 pop {r4, r5, r6, pc}
0001b438 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
1b438: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
1b43c: e1a04000 mov r4, r0
1b440: e24dd054 sub sp, sp, #84 ; 0x54
1b444: e1a06001 mov r6, r1
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle target_inode;
uint16_t links;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
1b448: e3a00401 mov r0, #16777216 ; 0x1000000 1b44c: e3a01000 mov r1, #0
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
1b450: e1a08002 mov r8, r2 1b454: e1a07003 mov r7, r3 1b458: e59d5074 ldr r5, [sp, #116] ; 0x74 1b45c: e5dda078 ldrb sl, [sp, #120] ; 0x78
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle target_inode;
uint16_t links;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
1b460: ebffd781 bl 1126c <rtems_rfs_trace> 1b464: e3500000 cmp r0, #0
1b468: 0a00000c beq 1b4a0 <rtems_rfs_link+0x68>
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
1b46c: e59f0144 ldr r0, [pc, #324] ; 1b5b8 <rtems_rfs_link+0x180> <== NOT EXECUTED 1b470: e1a01007 mov r1, r7 <== NOT EXECUTED 1b474: eb000d6c bl 1ea2c <printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
1b478: e3a09000 mov r9, #0 <== NOT EXECUTED 1b47c: ea000002 b 1b48c <rtems_rfs_link+0x54> <== NOT EXECUTED
printf ("%c", name[c]);
1b480: e7d60009 ldrb r0, [r6, r9] <== NOT EXECUTED 1b484: eb000dd2 bl 1ebd4 <putchar> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
for (c = 0; c < length; c++)
1b488: e2899001 add r9, r9, #1 <== NOT EXECUTED 1b48c: e1590008 cmp r9, r8 <== NOT EXECUTED 1b490: bafffffa blt 1b480 <rtems_rfs_link+0x48> <== NOT EXECUTED
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
1b494: e59f0120 ldr r0, [pc, #288] ; 1b5bc <rtems_rfs_link+0x184> <== NOT EXECUTED 1b498: e1a01005 mov r1, r5 <== NOT EXECUTED 1b49c: eb000d62 bl 1ea2c <printf> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
1b4a0: e1a00004 mov r0, r4 1b4a4: e1a01005 mov r1, r5 1b4a8: e28d202c add r2, sp, #44 ; 0x2c 1b4ac: e3a03001 mov r3, #1 1b4b0: ebffd15f bl fa34 <rtems_rfs_inode_open>
if (rc)
1b4b4: e2509000 subs r9, r0, #0
1b4b8: 1a00003b bne 1b5ac <rtems_rfs_link+0x174>
/*
* 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)))
1b4bc: e35a0000 cmp sl, #0
{
rtems_rfs_inode_close (fs, &target_inode);
1b4c0: e1a00004 mov r0, r4
/*
* 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)))
1b4c4: 1a000009 bne 1b4f0 <rtems_rfs_link+0xb8>
* @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);
1b4c8: e59d3038 ldr r3, [sp, #56] ; 0x38 1b4cc: e5d33002 ldrb r3, [r3, #2] 1b4d0: e1a03403 lsl r3, r3, #8 1b4d4: e2033a0f and r3, r3, #61440 ; 0xf000 1b4d8: e3530901 cmp r3, #16384 ; 0x4000
1b4dc: 1a000003 bne 1b4f0 <rtems_rfs_link+0xb8>
{
rtems_rfs_inode_close (fs, &target_inode);
1b4e0: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 1b4e4: ebffd1c7 bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED
return ENOTSUP;
1b4e8: e3a09086 mov r9, #134 ; 0x86 <== NOT EXECUTED 1b4ec: ea00002e b 1b5ac <rtems_rfs_link+0x174> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
1b4f0: e1a01007 mov r1, r7 1b4f4: e28d2004 add r2, sp, #4 1b4f8: e3a03001 mov r3, #1 1b4fc: ebffd14c bl fa34 <rtems_rfs_inode_open>
if (rc)
1b500: e2509000 subs r9, r0, #0
1b504: 1a00000a bne 1b534 <rtems_rfs_link+0xfc>
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
1b508: e1a00004 mov r0, r4 1b50c: e28d1004 add r1, sp, #4 1b510: e1a02006 mov r2, r6 1b514: e1a03008 mov r3, r8 1b518: e58d5000 str r5, [sp] 1b51c: ebfff755 bl 19278 <rtems_rfs_dir_add_entry>
if (rc > 0)
1b520: e2509000 subs r9, r0, #0
1b524: da000006 ble 1b544 <rtems_rfs_link+0x10c>
{
rtems_rfs_inode_close (fs, &parent_inode);
1b528: e1a00004 mov r0, r4 <== NOT EXECUTED 1b52c: e28d1004 add r1, sp, #4 <== NOT EXECUTED 1b530: ebffd1b4 bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
1b534: e1a00004 mov r0, r4 <== NOT EXECUTED 1b538: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 1b53c: ebffd1b1 bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
1b540: ea000019 b 1b5ac <rtems_rfs_link+0x174> <== NOT EXECUTED
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
1b544: e28d002c add r0, sp, #44 ; 0x2c 1b548: ebffffb1 bl 1b414 <rtems_rfs_inode_get_links> 1b54c: e2800001 add r0, r0, #1
* @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);
1b550: e59d3038 ldr r3, [sp, #56] ; 0x38 1b554: e1a00800 lsl r0, r0, #16 1b558: e1a02820 lsr r2, r0, #16 1b55c: e1a00c20 lsr r0, r0, #24 1b560: e5c30000 strb r0, [r3] 1b564: e59d3038 ldr r3, [sp, #56] ; 0x38
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1b568: e3a01001 mov r1, #1
* @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);
1b56c: e5c32001 strb r2, [r3, #1]
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
1b570: e28d0004 add r0, sp, #4 1b574: e1a02001 mov r2, r1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1b578: e5cd103c strb r1, [sp, #60] ; 0x3c 1b57c: ebffd1f7 bl fd60 <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
1b580: e2509000 subs r9, r0, #0
{
rtems_rfs_inode_close (fs, &parent_inode);
1b584: e28d1004 add r1, sp, #4 1b588: e1a00004 mov r0, r4
links = rtems_rfs_inode_get_links (&target_inode) + 1;
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
if (rc > 0)
1b58c: caffffe7 bgt 1b530 <rtems_rfs_link+0xf8>
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
1b590: ebffd19c bl fc08 <rtems_rfs_inode_close>
if (rc > 0)
1b594: e2509000 subs r9, r0, #0
{
rtems_rfs_inode_close (fs, &target_inode);
1b598: e28d102c add r1, sp, #44 ; 0x2c 1b59c: e1a00004 mov r0, r4
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
if (rc > 0)
1b5a0: caffffe5 bgt 1b53c <rtems_rfs_link+0x104>
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
1b5a4: ebffd197 bl fc08 <rtems_rfs_inode_close> 1b5a8: e1a09000 mov r9, r0
return rc;
}
1b5ac: e1a00009 mov r0, r9
1b5b0: e28dd054 add sp, sp, #84 ; 0x54
1b5b4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
0001bd58 <rtems_rfs_mutex_create>:
RTEMS_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
1bd58: e92d4011 push {r0, r4, lr}
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
1bd5c: e3a01001 mov r1, #1 1bd60: e58d0000 str r0, [sp] 1bd64: e3a02054 mov r2, #84 ; 0x54 1bd68: e59f0040 ldr r0, [pc, #64] ; 1bdb0 <rtems_rfs_mutex_create+0x58> 1bd6c: e3a03000 mov r3, #0 1bd70: ebffbb64 bl ab08 <rtems_semaphore_create>
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
1bd74: e2504000 subs r4, r0, #0
printf ("rtems-rfs: mutex: open failed: %s\n",
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
1bd78: 01a00004 moveq r0, r4
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
1bd7c: 0a00000a beq 1bdac <rtems_rfs_mutex_create+0x54>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1bd80: e3a00004 mov r0, #4 <== NOT EXECUTED 1bd84: e3a01000 mov r1, #0 <== NOT EXECUTED 1bd88: ebffd537 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1bd8c: e3500000 cmp r0, #0 <== NOT EXECUTED 1bd90: 0a000004 beq 1bda8 <rtems_rfs_mutex_create+0x50> <== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
1bd94: e1a00004 mov r0, r4 <== NOT EXECUTED 1bd98: ebffaa18 bl 6600 <rtems_status_text> <== NOT EXECUTED 1bd9c: e1a01000 mov r1, r0 <== NOT EXECUTED 1bda0: e59f000c ldr r0, [pc, #12] ; 1bdb4 <rtems_rfs_mutex_create+0x5c><== NOT EXECUTED 1bda4: eb000b20 bl 1ea2c <printf> <== NOT EXECUTED
rtems_status_text (sc));
return EIO;
1bda8: e3a00005 mov r0, #5 <== NOT EXECUTED
} #endif return 0; }
1bdac: e8bd8018 pop {r3, r4, pc}
0001bdb8 <rtems_rfs_mutex_destroy>:
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
1bdb8: e92d4010 push {r4, lr}
#if __rtems__ rtems_status_code sc; sc = rtems_semaphore_delete (*mutex);
1bdbc: e5900000 ldr r0, [r0] 1bdc0: ebffbbb8 bl aca8 <rtems_semaphore_delete>
if (sc != RTEMS_SUCCESSFUL)
1bdc4: e2504000 subs r4, r0, #0
printf ("rtems-rfs: mutex: close failed: %s\n",
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
1bdc8: 01a00004 moveq r0, r4
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
if (sc != RTEMS_SUCCESSFUL)
1bdcc: 08bd8010 popeq {r4, pc}
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1bdd0: e3a00004 mov r0, #4 <== NOT EXECUTED 1bdd4: e3a01000 mov r1, #0 <== NOT EXECUTED 1bdd8: ebffd523 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1bddc: e3500000 cmp r0, #0 <== NOT EXECUTED 1bde0: 0a000006 beq 1be00 <rtems_rfs_mutex_destroy+0x48> <== NOT EXECUTED
printf ("rtems-rfs: mutex: close failed: %s\n",
1bde4: e1a00004 mov r0, r4 <== NOT EXECUTED 1bde8: ebffaa04 bl 6600 <rtems_status_text> <== NOT EXECUTED 1bdec: e1a01000 mov r1, r0 <== NOT EXECUTED 1bdf0: e59f0010 ldr r0, [pc, #16] ; 1be08 <rtems_rfs_mutex_destroy+0x50><== NOT EXECUTED 1bdf4: eb000b0c bl 1ea2c <printf> <== NOT EXECUTED
rtems_status_text (sc));
return EIO;
1bdf8: e3a00005 mov r0, #5 <== NOT EXECUTED
1bdfc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
1be00: e3a00005 mov r0, #5 <== NOT EXECUTED
} #endif return 0; }
1be04: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00010f94 <rtems_rfs_mutex_lock.isra.2>:
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
10f94: e3a01000 mov r1, #0
* @param mutex The mutex to lock. * @retval true The mutex is locked. * @retval false The mutex could not be locked. */ static inline int rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
10f98: e92d4010 push {r4, lr}
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
10f9c: e1a02001 mov r2, r1 10fa0: ebffe767 bl ad44 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
10fa4: e2504000 subs r4, r0, #0
rtems_status_text (sc));
#endif
return EIO;
}
#endif
return 0;
10fa8: 01a00004 moveq r0, r4
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
10fac: 08bd8010 popeq {r4, pc}
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
10fb0: e3a00004 mov r0, #4 <== NOT EXECUTED 10fb4: e3a01000 mov r1, #0 <== NOT EXECUTED 10fb8: eb0000ab bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 10fbc: e3500000 cmp r0, #0 <== NOT EXECUTED 10fc0: 0a000006 beq 10fe0 <rtems_rfs_mutex_lock.isra.2+0x4c> <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
10fc4: e1a00004 mov r0, r4 <== NOT EXECUTED 10fc8: ebffd58c bl 6600 <rtems_status_text> <== NOT EXECUTED 10fcc: e1a01000 mov r1, r0 <== NOT EXECUTED 10fd0: e59f0010 ldr r0, [pc, #16] ; 10fe8 <rtems_rfs_mutex_lock.isra.2+0x54><== NOT EXECUTED 10fd4: eb003694 bl 1ea2c <printf> <== NOT EXECUTED
rtems_status_text (sc));
#endif
return EIO;
10fd8: e3a00005 mov r0, #5 <== NOT EXECUTED
10fdc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
10fe0: e3a00005 mov r0, #5 <== NOT EXECUTED
} #endif return 0; }
10fe4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
000106d4 <rtems_rfs_rtems_chown>:
static int
rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
106d4: e92d40f0 push {r4, r5, r6, r7, lr}
106d8: e1a02802 lsl r2, r2, #16
106dc: e1a06822 lsr r6, r2, #16
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
106e0: e5902014 ldr r2, [r0, #20] 106e4: e5924008 ldr r4, [r2, #8]
static int
rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
106e8: e1a03000 mov r3, r0 106ec: e24dd028 sub sp, sp, #40 ; 0x28 106f0: e1a01801 lsl r1, r1, #16 106f4: e1a05821 lsr r5, r1, #16
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);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
106f8: e1a00004 mov r0, r4 106fc: e5931008 ldr r1, [r3, #8] 10700: e1a0200d mov r2, sp 10704: e3a03001 mov r3, #1 10708: ebfffcc9 bl fa34 <rtems_rfs_inode_open>
if (rc > 0)
1070c: e2507000 subs r7, r0, #0
10710: da000002 ble 10720 <rtems_rfs_rtems_chown+0x4c>
{
return rtems_rfs_rtems_error ("chown: opening inode", rc);
10714: eb0033ae bl 1d5d4 <__errno> <== NOT EXECUTED 10718: e5807000 str r7, [r0] <== NOT EXECUTED 1071c: ea000024 b 107b4 <rtems_rfs_rtems_chown+0xe0> <== NOT EXECUTED
/*
* Verify I am the owner of the node or the super user.
*/
#if defined (RTEMS_POSIX_API)
uid = geteuid();
10720: eb000fab bl 145d4 <geteuid>
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
10724: e59d300c ldr r3, [sp, #12] 10728: e5d31006 ldrb r1, [r3, #6] 1072c: e5d32007 ldrb r2, [r3, #7]
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
10730: e1822401 orr r2, r2, r1, lsl #8 10734: e1500002 cmp r0, r2
10738: 0a000008 beq 10760 <rtems_rfs_rtems_chown+0x8c>
1073c: e3500000 cmp r0, #0 <== NOT EXECUTED 10740: 0a000006 beq 10760 <rtems_rfs_rtems_chown+0x8c> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
10744: e1a0100d mov r1, sp <== NOT EXECUTED 10748: e1a00004 mov r0, r4 <== NOT EXECUTED 1074c: ebfffd2d bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: not able", EPERM);
10750: eb00339f bl 1d5d4 <__errno> <== NOT EXECUTED 10754: e3a03001 mov r3, #1 <== NOT EXECUTED 10758: e5803000 str r3, [r0] <== NOT EXECUTED 1075c: ea000014 b 107b4 <rtems_rfs_rtems_chown+0xe0> <== 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);
10760: e1856806 orr r6, r5, r6, lsl #16 10764: e1a02c26 lsr r2, r6, #24 10768: e5c32004 strb r2, [r3, #4] 1076c: e59d300c ldr r3, [sp, #12] 10770: e1a02826 lsr r2, r6, #16 10774: e5c32005 strb r2, [r3, #5] 10778: e59d300c ldr r3, [sp, #12] 1077c: e1a06426 lsr r6, r6, #8 10780: e5c36006 strb r6, [r3, #6] 10784: e59d300c ldr r3, [sp, #12]
}
#endif
rtems_rfs_inode_set_uid_gid (&inode, owner, group);
rc = rtems_rfs_inode_close (fs, &inode);
10788: e1a00004 mov r0, r4 1078c: e5c35007 strb r5, [r3, #7] 10790: e1a0100d mov r1, sp
rtems_rfs_buffer_mark_dirty (&handle->buffer);
10794: e3a03001 mov r3, #1 10798: e5cd3010 strb r3, [sp, #16] 1079c: ebfffd19 bl fc08 <rtems_rfs_inode_close>
if (rc)
107a0: e2504000 subs r4, r0, #0
{
return rtems_rfs_rtems_error ("chown: closing inode", rc);
}
return 0;
107a4: 01a00004 moveq r0, r4
#endif
rtems_rfs_inode_set_uid_gid (&inode, owner, group);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc)
107a8: 0a000002 beq 107b8 <rtems_rfs_rtems_chown+0xe4>
{
return rtems_rfs_rtems_error ("chown: closing inode", rc);
107ac: eb003388 bl 1d5d4 <__errno> <== NOT EXECUTED 107b0: e5804000 str r4, [r0] <== NOT EXECUTED 107b4: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return 0;
}
107b8: e28dd028 add sp, sp, #40 ; 0x28
107bc: e8bd80f0 pop {r4, r5, r6, r7, pc}
0001be8c <rtems_rfs_rtems_device_close>:
rtems_device_major_number major;
rtems_device_minor_number minor;
rtems_rfs_rtems_device_get_major_and_minor (iop, &major, &minor);
return rtems_deviceio_close (iop, major, minor);
1be8c: e2801028 add r1, r0, #40 ; 0x28 <== NOT EXECUTED
1be90: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
1be94: ea0002fa b 1ca84 <rtems_deviceio_close> <== NOT EXECUTED
0001be3c <rtems_rfs_rtems_device_ftruncate>:
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, off_t length)
{
return 0;
}
1be3c: e3a00000 mov r0, #0 <== NOT EXECUTED 1be40: e12fff1e bx lr <== NOT EXECUTED
0001be44 <rtems_rfs_rtems_device_ioctl>:
static int
rtems_rfs_rtems_device_ioctl (rtems_libio_t* iop,
ioctl_command_t command,
void* buffer)
{
1be44: e92d4001 push {r0, lr} <== NOT EXECUTED
rtems_device_major_number major;
rtems_device_minor_number minor;
rtems_rfs_rtems_device_get_major_and_minor (iop, &major, &minor);
return rtems_deviceio_control (iop, command, buffer, major, minor);
1be48: e590c02c ldr ip, [r0, #44] ; 0x2c <== NOT EXECUTED 1be4c: e58dc000 str ip, [sp] <== NOT EXECUTED 1be50: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED 1be54: eb00034b bl 1cb88 <rtems_deviceio_control> <== NOT EXECUTED
}
1be58: e8bd8008 pop {r3, pc} <== NOT EXECUTED
0001bee4 <rtems_rfs_rtems_device_open>:
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode)
{
1bee4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
1bee8: e1a08003 mov r8, r3 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
1beec: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED 1bef0: e5934008 ldr r4, [r3, #8] <== NOT EXECUTED
.fstat_h = rtems_rfs_rtems_fstat, .ftruncate_h = rtems_rfs_rtems_device_ftruncate, .fsync_h = rtems_filesystem_default_fsync_or_fdatasync, .fdatasync_h = rtems_filesystem_default_fsync_or_fdatasync, .fcntl_h = rtems_filesystem_default_fcntl };
1bef4: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode)
{
1bef8: e1a07001 mov r7, r1 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
1befc: e3a01000 mov r1, #0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo); rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
1bf00: e590a018 ldr sl, [r0, #24] <== NOT EXECUTED
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode)
{
1bf04: e24dd030 sub sp, sp, #48 ; 0x30 <== NOT EXECUTED 1bf08: e1a05000 mov r5, r0 <== NOT EXECUTED 1bf0c: e1a06002 mov r6, r2 <== NOT EXECUTED 1bf10: e5930000 ldr r0, [r3] <== NOT EXECUTED 1bf14: e1a02001 mov r2, r1 <== NOT EXECUTED 1bf18: ebffbb89 bl ad44 <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
1bf1c: e2509000 subs r9, r0, #0 <== NOT EXECUTED 1bf20: 0a000009 beq 1bf4c <rtems_rfs_rtems_device_open+0x68> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1bf24: e3a00004 mov r0, #4 <== NOT EXECUTED 1bf28: e3a01000 mov r1, #0 <== NOT EXECUTED 1bf2c: ebffd4ce bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1bf30: e3500000 cmp r0, #0 <== NOT EXECUTED 1bf34: 0a000004 beq 1bf4c <rtems_rfs_rtems_device_open+0x68> <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
1bf38: e1a00009 mov r0, r9 <== NOT EXECUTED 1bf3c: ebffa9af bl 6600 <rtems_status_text> <== NOT EXECUTED 1bf40: e1a01000 mov r1, r0 <== NOT EXECUTED 1bf44: e59f00a8 ldr r0, [pc, #168] ; 1bff4 <rtems_rfs_rtems_device_open+0x110><== NOT EXECUTED 1bf48: eb000ab7 bl 1ea2c <printf> <== NOT EXECUTED
rtems_device_minor_number minor;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1bf4c: e1a0100a mov r1, sl <== NOT EXECUTED 1bf50: e1a00004 mov r0, r4 <== NOT EXECUTED 1bf54: e28d2008 add r2, sp, #8 <== NOT EXECUTED 1bf58: e3a03001 mov r3, #1 <== NOT EXECUTED 1bf5c: ebffceb4 bl fa34 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
1bf60: e250a000 subs sl, r0, #0 <== NOT EXECUTED 1bf64: da000004 ble 1bf7c <rtems_rfs_rtems_device_open+0x98> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1bf68: e1a00004 mov r0, r4 <== NOT EXECUTED 1bf6c: ebffffc9 bl 1be98 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
1bf70: eb000597 bl 1d5d4 <__errno> <== NOT EXECUTED 1bf74: e580a000 str sl, [r0] <== NOT EXECUTED 1bf78: ea000010 b 1bfc0 <rtems_rfs_rtems_device_open+0xdc> <== NOT EXECUTED
}
major = rtems_rfs_inode_get_block (&inode, 0);
1bf7c: e3a01000 mov r1, #0 <== NOT EXECUTED 1bf80: e28d0008 add r0, sp, #8 <== NOT EXECUTED 1bf84: ebffffa0 bl 1be0c <rtems_rfs_inode_get_block> <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
1bf88: e3a01001 mov r1, #1 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
}
major = rtems_rfs_inode_get_block (&inode, 0);
1bf8c: e1a0a000 mov sl, r0 <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
1bf90: e28d0008 add r0, sp, #8 <== NOT EXECUTED 1bf94: ebffff9c bl 1be0c <rtems_rfs_inode_get_block> <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
1bf98: e28d1008 add r1, sp, #8 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
}
major = rtems_rfs_inode_get_block (&inode, 0);
minor = rtems_rfs_inode_get_block (&inode, 1);
1bf9c: e1a09000 mov r9, r0 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
1bfa0: e1a00004 mov r0, r4 <== NOT EXECUTED 1bfa4: ebffcf17 bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
1bfa8: e250b000 subs fp, r0, #0 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1bfac: e1a00004 mov r0, r4 <== 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);
if (rc > 0)
1bfb0: da000004 ble 1bfc8 <rtems_rfs_rtems_device_open+0xe4> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
1bfb4: ebffffb7 bl 1be98 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
1bfb8: eb000585 bl 1d5d4 <__errno> <== NOT EXECUTED 1bfbc: e580b000 str fp, [r0] <== NOT EXECUTED 1bfc0: e3e00000 mvn r0, #0 <== NOT EXECUTED 1bfc4: ea000008 b 1bfec <rtems_rfs_rtems_device_open+0x108> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
1bfc8: ebffffb2 bl 1be98 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
iop->data0 = major;
1bfcc: e585a028 str sl, [r5, #40] ; 0x28 <== NOT EXECUTED
iop->data1 = (void *) minor;
1bfd0: e585902c str r9, [r5, #44] ; 0x2c <== NOT EXECUTED
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
1bfd4: e1a00005 mov r0, r5 <== NOT EXECUTED
1bfd8: e1a01007 mov r1, r7 <== NOT EXECUTED
1bfdc: e1a02006 mov r2, r6 <== NOT EXECUTED
1bfe0: e1a03008 mov r3, r8 <== NOT EXECUTED
1bfe4: e88d0600 stm sp, {r9, sl} <== NOT EXECUTED
1bfe8: eb00029b bl 1ca5c <rtems_deviceio_open> <== NOT EXECUTED
}
1bfec: e28dd030 add sp, sp, #48 ; 0x30 <== NOT EXECUTED
1bff0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0001be74 <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)
{
1be74: e92d4001 push {r0, lr} <== NOT EXECUTED
rtems_device_major_number major;
rtems_device_minor_number minor;
rtems_rfs_rtems_device_get_major_and_minor (iop, &major, &minor);
return rtems_deviceio_read (iop, buffer, count, major, minor);
1be78: e590c02c ldr ip, [r0, #44] ; 0x2c <== NOT EXECUTED 1be7c: e58dc000 str ip, [sp] <== NOT EXECUTED 1be80: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED 1be84: eb000309 bl 1cab0 <rtems_deviceio_read> <== NOT EXECUTED
}
1be88: e8bd8008 pop {r3, pc} <== NOT EXECUTED
0001be5c <rtems_rfs_rtems_device_write>:
static ssize_t
rtems_rfs_rtems_device_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
1be5c: e92d4001 push {r0, lr} <== NOT EXECUTED
rtems_device_major_number major;
rtems_device_minor_number minor;
rtems_rfs_rtems_device_get_major_and_minor (iop, &major, &minor);
return rtems_deviceio_write (iop, buffer, count, major, minor);
1be60: e590c02c ldr ip, [r0, #44] ; 0x2c <== NOT EXECUTED 1be64: e58dc000 str ip, [sp] <== NOT EXECUTED 1be68: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED 1be6c: eb00032a bl 1cb1c <rtems_deviceio_write> <== NOT EXECUTED
}
1be70: e8bd8008 pop {r3, pc} <== NOT EXECUTED
0001c194 <rtems_rfs_rtems_dir_open>:
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
1c194: e92d4070 push {r4, r5, r6, lr}
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
1c198: e5903024 ldr r3, [r0, #36] ; 0x24 1c19c: e5934008 ldr r4, [r3, #8]
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
1c1a0: e5906018 ldr r6, [r0, #24]
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
1c1a4: e24dd028 sub sp, sp, #40 ; 0x28 1c1a8: e1a05000 mov r5, r0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
1c1ac: e1a00004 mov r0, r4 1c1b0: ebffff92 bl 1c000 <rtems_rfs_rtems_lock>
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1c1b4: e1a01006 mov r1, r6 1c1b8: e1a00004 mov r0, r4 1c1bc: e1a0200d mov r2, sp 1c1c0: e3a03001 mov r3, #1 1c1c4: ebffce1a bl fa34 <rtems_rfs_inode_open>
if (rc)
1c1c8: e2506000 subs r6, r0, #0
1c1cc: 0a000004 beq 1c1e4 <rtems_rfs_rtems_dir_open+0x50>
{
rtems_rfs_rtems_unlock (fs);
1c1d0: e1a00004 mov r0, r4 <== NOT EXECUTED 1c1d4: ebffff9d bl 1c050 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
1c1d8: eb0004fd bl 1d5d4 <__errno> <== NOT EXECUTED 1c1dc: e5806000 str r6, [r0] <== NOT EXECUTED 1c1e0: ea00000d b 1c21c <rtems_rfs_rtems_dir_open+0x88> <== 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);
1c1e4: e59d300c ldr r3, [sp, #12] 1c1e8: e5d33002 ldrb r3, [r3, #2]
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
1c1ec: e1a03403 lsl r3, r3, #8 1c1f0: e2033a0f and r3, r3, #61440 ; 0xf000 1c1f4: e3530901 cmp r3, #16384 ; 0x4000
1c1f8: 0a000009 beq 1c224 <rtems_rfs_rtems_dir_open+0x90>
{
rtems_rfs_inode_close (fs, &inode);
1c1fc: e1a0100d mov r1, sp <== NOT EXECUTED 1c200: e1a00004 mov r0, r4 <== NOT EXECUTED 1c204: ebffce7f bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
1c208: e1a00004 mov r0, r4 <== NOT EXECUTED 1c20c: ebffff8f bl 1c050 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
1c210: eb0004ef bl 1d5d4 <__errno> <== NOT EXECUTED 1c214: e3a03014 mov r3, #20 <== NOT EXECUTED 1c218: e5803000 str r3, [r0] <== NOT EXECUTED 1c21c: e3e00000 mvn r0, #0 <== NOT EXECUTED 1c220: ea000008 b 1c248 <rtems_rfs_rtems_dir_open+0xb4> <== NOT EXECUTED
}
iop->offset = 0;
1c224: e3a02000 mov r2, #0
1c228: e3a03000 mov r3, #0
1c22c: e985000c stmib r5, {r2, r3}
rtems_rfs_inode_close (fs, &inode);
1c230: e1a0100d mov r1, sp 1c234: e1a00004 mov r0, r4 1c238: ebffce72 bl fc08 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
1c23c: e1a00004 mov r0, r4 1c240: ebffff82 bl 1c050 <rtems_rfs_rtems_unlock>
return 0;
1c244: e1a00006 mov r0, r6
}
1c248: e28dd028 add sp, sp, #40 ; 0x28
1c24c: e8bd8070 pop {r4, r5, r6, pc}
0001c09c <rtems_rfs_rtems_dir_read>:
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
1c09c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
1c0a0: e5903024 ldr r3, [r0, #36] ; 0x24
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
1c0a4: e24dd038 sub sp, sp, #56 ; 0x38
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo); rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
1c0a8: e5906018 ldr r6, [r0, #24]
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
1c0ac: e1a04000 mov r4, r0 1c0b0: e1a0b001 mov fp, r1
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
1c0b4: e1a00002 mov r0, r2 1c0b8: e3a01e11 mov r1, #272 ; 0x110
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);
1c0bc: e5935008 ldr r5, [r3, #8]
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
1c0c0: ebff961e bl 1940 <__aeabi_uidiv>
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1c0c4: e28d800c add r8, sp, #12
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
1c0c8: e1a09000 mov r9, r0
dirent = buffer;
rtems_rfs_rtems_lock (fs);
1c0cc: e1a00005 mov r0, r5 1c0d0: ebffffca bl 1c000 <rtems_rfs_rtems_lock>
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1c0d4: e1a01006 mov r1, r6 1c0d8: e1a00005 mov r0, r5 1c0dc: e1a02008 mov r2, r8 1c0e0: e3a03001 mov r3, #1 1c0e4: ebffce52 bl fa34 <rtems_rfs_inode_open>
if (rc)
1c0e8: e2507000 subs r7, r0, #0
* 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,
1c0ec: 01a06007 moveq r6, r7
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
1c0f0: 028da034 addeq sl, sp, #52 ; 0x34
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
1c0f4: 0a00001b beq 1c168 <rtems_rfs_rtems_dir_read+0xcc>
{
rtems_rfs_rtems_unlock (fs);
1c0f8: e1a00005 mov r0, r5 <== NOT EXECUTED 1c0fc: ebffffd3 bl 1c050 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
1c100: eb000533 bl 1d5d4 <__errno> <== NOT EXECUTED 1c104: e3e06000 mvn r6, #0 <== NOT EXECUTED 1c108: e5807000 str r7, [r0] <== NOT EXECUTED 1c10c: ea00001d b 1c188 <rtems_rfs_rtems_dir_read+0xec> <== 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);
1c110: e88d0402 stm sp, {r1, sl}
1c114: e994000c ldmib r4, {r2, r3}
1c118: e1a00005 mov r0, r5
1c11c: e1a01008 mov r1, r8
1c120: ebfff624 bl 199b8 <rtems_rfs_dir_read>
if (rc == ENOENT)
1c124: e3500002 cmp r0, #2
1c128: 0a000011 beq 1c174 <rtems_rfs_rtems_dir_read+0xd8>
{
rc = 0;
break;
}
if (rc > 0)
1c12c: e3500000 cmp r0, #0
1c130: da000005 ble 1c14c <rtems_rfs_rtems_dir_read+0xb0>
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
1c134: e58d0008 str r0, [sp, #8] <== NOT EXECUTED 1c138: eb000525 bl 1d5d4 <__errno> <== NOT EXECUTED 1c13c: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 1c140: e3e06000 mvn r6, #0 <== NOT EXECUTED 1c144: e5803000 str r3, [r0] <== NOT EXECUTED 1c148: ea000009 b 1c174 <rtems_rfs_rtems_dir_read+0xd8> <== NOT EXECUTED
break;
}
iop->offset += size;
1c14c: e994000c ldmib r4, {r2, r3}
1c150: e59d1034 ldr r1, [sp, #52] ; 0x34
1c154: e0922001 adds r2, r2, r1
1c158: e2a33000 adc r3, r3, #0
1c15c: e984000c stmib r4, {r2, r3}
* 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,
1c160: e2866e11 add r6, r6, #272 ; 0x110
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
1c164: e2877001 add r7, r7, #1 1c168: e1570009 cmp r7, r9
* 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,
1c16c: e08b1006 add r1, fp, r6
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
1c170: 1affffe6 bne 1c110 <rtems_rfs_rtems_dir_read+0x74>
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
1c174: e1a00005 mov r0, r5 1c178: e28d100c add r1, sp, #12 1c17c: ebffcea1 bl fc08 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
1c180: e1a00005 mov r0, r5 1c184: ebffffb1 bl 1c050 <rtems_rfs_rtems_unlock>
return bytes_transferred;
}
1c188: e1a00006 mov r0, r6
1c18c: e28dd038 add sp, sp, #56 ; 0x38
1c190: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00010a54 <rtems_rfs_rtems_eval_path>:
.eval_token = rtems_rfs_rtems_eval_token
};
static void
rtems_rfs_rtems_eval_path (rtems_filesystem_eval_path_context_t *ctx)
{
10a54: e92d4070 push {r4, r5, r6, lr}
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc (ctx);
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (currentloc);
10a58: e590302c ldr r3, [r0, #44] ; 0x2c 10a5c: e5935008 ldr r5, [r3, #8]
.eval_token = rtems_rfs_rtems_eval_token
};
static void
rtems_rfs_rtems_eval_path (rtems_filesystem_eval_path_context_t *ctx)
{
10a60: e24dd028 sub sp, sp, #40 ; 0x28 10a64: e1a04000 mov r4, r0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (currentloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (currentloc);
rtems_rfs_inode_handle inode;
int rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
10a68: e5941020 ldr r1, [r4, #32] 10a6c: e1a00005 mov r0, r5 10a70: e1a0200d mov r2, sp 10a74: e3a03001 mov r3, #1 10a78: ebfffbed bl fa34 <rtems_rfs_inode_open>
if (rc == 0) {
10a7c: e2506000 subs r6, r0, #0
10a80: 1a00000b bne 10ab4 <rtems_rfs_rtems_eval_path+0x60>
rtems_filesystem_eval_path_generic (
10a84: e1a00004 mov r0, r4 10a88: e1a0100d mov r1, sp 10a8c: e59f203c ldr r2, [pc, #60] ; 10ad0 <rtems_rfs_rtems_eval_path+0x7c> 10a90: eb000fb8 bl 14978 <rtems_filesystem_eval_path_generic>
ctx,
&inode,
&rtems_rfs_rtems_eval_config
);
rc = rtems_rfs_inode_close (fs, &inode);
10a94: e1a00005 mov r0, r5 10a98: e1a0100d mov r1, sp 10a9c: ebfffc59 bl fc08 <rtems_rfs_inode_close>
if (rc != 0) {
10aa0: e2505000 subs r5, r0, #0
10aa4: 0a000007 beq 10ac8 <rtems_rfs_rtems_eval_path+0x74>
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
10aa8: eb0032c9 bl 1d5d4 <__errno> <== NOT EXECUTED 10aac: e5805000 str r5, [r0] <== NOT EXECUTED 10ab0: ea000001 b 10abc <rtems_rfs_rtems_eval_path+0x68> <== NOT EXECUTED
);
}
} else {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: opening inode", rc)
10ab4: eb0032c6 bl 1d5d4 <__errno> <== NOT EXECUTED 10ab8: e5806000 str r6, [r0] <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
);
}
} else {
rtems_filesystem_eval_path_error (
10abc: e1a00004 mov r0, r4 <== NOT EXECUTED 10ac0: e3e01000 mvn r1, #0 <== NOT EXECUTED 10ac4: ebffdccd bl 7e00 <rtems_filesystem_eval_path_error> <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: opening inode", rc)
);
}
}
10ac8: e28dd028 add sp, sp, #40 ; 0x28
10acc: e8bd8070 pop {r4, r5, r6, pc}
00010d9c <rtems_rfs_rtems_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
10d9c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
10da0: e1a04000 mov r4, r0
10da4: e24dd014 sub sp, sp, #20
return rtems_filesystem_eval_path_check_access(
ctx,
eval_flags,
rtems_rfs_inode_get_mode (inode),
rtems_rfs_inode_get_uid (inode),
rtems_rfs_inode_get_gid (inode)
10da8: e1a00001 mov r0, r1
* @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);
10dac: e591600c ldr r6, [r1, #12]
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
10db0: e1a05001 mov r5, r1 10db4: e1a08002 mov r8, r2 10db8: e1a07003 mov r7, r3
return rtems_filesystem_eval_path_check_access(
ctx,
eval_flags,
rtems_rfs_inode_get_mode (inode),
rtems_rfs_inode_get_uid (inode),
rtems_rfs_inode_get_gid (inode)
10dbc: ebfffd3e bl 102bc <rtems_rfs_inode_get_gid> 10dc0: e5d6e002 ldrb lr, [r6, #2] 10dc4: e5d62003 ldrb r2, [r6, #3]
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
10dc8: e5d6c006 ldrb ip, [r6, #6] 10dcc: e5d63007 ldrb r3, [r6, #7]
static bool
rtems_rfs_rtems_eval_perms (rtems_filesystem_eval_path_context_t *ctx,
int eval_flags,
rtems_rfs_inode_handle* inode)
{
return rtems_filesystem_eval_path_check_access(
10dd0: e3a01001 mov r1, #1 10dd4: e58d0000 str r0, [sp] 10dd8: e182240e orr r2, r2, lr, lsl #8 10ddc: e1a00004 mov r0, r4 10de0: e183340c orr r3, r3, ip, lsl #8 10de4: eb000ed5 bl 14940 <rtems_filesystem_eval_path_check_access>
rtems_filesystem_eval_path_generic_status status =
RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
rtems_rfs_inode_handle* inode = arg;
bool access_ok = rtems_rfs_rtems_eval_perms (ctx, RTEMS_FS_PERMS_EXEC, inode);
if (access_ok) {
10de8: e3500000 cmp r0, #0
10dec: 0a000043 beq 10f00 <rtems_rfs_rtems_eval_token+0x164>
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
10df0: e3570001 cmp r7, #1
10df4: 1a000045 bne 10f10 <rtems_rfs_rtems_eval_token+0x174>
10df8: e5d83000 ldrb r3, [r8] 10dfc: e353002e cmp r3, #46 ; 0x2e
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
10e00: 03a03000 moveq r3, #0 10e04: 0584300c streq r3, [r4, #12]
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
10e08: 1a000040 bne 10f10 <rtems_rfs_rtems_eval_token+0x174>
10e0c: ea00003c b 10f04 <rtems_rfs_rtems_eval_token+0x168>
&entry_ino,
&entry_doff
);
if (rc == 0) {
rc = rtems_rfs_inode_close (fs, inode);
10e10: e1a00006 mov r0, r6 10e14: e1a01005 mov r1, r5 10e18: ebfffb7a bl fc08 <rtems_rfs_inode_close>
if (rc == 0) {
10e1c: e3500000 cmp r0, #0
10e20: 1a000006 bne 10e40 <rtems_rfs_rtems_eval_token+0xa4>
rc = rtems_rfs_inode_open (fs, entry_ino, inode, true);
10e24: e1a00006 mov r0, r6 10e28: e59d1008 ldr r1, [sp, #8] 10e2c: e1a02005 mov r2, r5 10e30: e3a03001 mov r3, #1 10e34: ebfffafe bl fa34 <rtems_rfs_inode_open>
}
if (rc != 0) {
10e38: e2508000 subs r8, r0, #0
10e3c: 0a000042 beq 10f4c <rtems_rfs_rtems_eval_token+0x1b0>
/*
* This prevents the rtems_rfs_inode_close() from doing something in
* rtems_rfs_rtems_eval_path().
*/
memset (inode, 0, sizeof(*inode));
10e40: e1a00005 mov r0, r5 <== NOT EXECUTED 10e44: e3a01000 mov r1, #0 <== NOT EXECUTED 10e48: e3a02028 mov r2, #40 ; 0x28 <== NOT EXECUTED 10e4c: eb003685 bl 1e868 <memset> <== NOT EXECUTED 10e50: ea00002a b 10f00 <rtems_rfs_rtems_eval_token+0x164> <== NOT EXECUTED
bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
10e54: e3130010 tst r3, #16
10e58: 1a000001 bne 10e64 <rtems_rfs_rtems_eval_token+0xc8>
10e5c: e3570000 cmp r7, #0
10e60: 1a00001c bne 10ed8 <rtems_rfs_rtems_eval_token+0x13c>
rtems_filesystem_eval_path_context_t* ctx,
rtems_rfs_file_system* fs,
rtems_rfs_ino ino
)
{
size_t len = MAXPATHLEN;
10e64: e3a07b01 mov r7, #1024 ; 0x400
char *link = malloc(len + 1);
10e68: e59f0120 ldr r0, [pc, #288] ; 10f90 <rtems_rfs_rtems_eval_token+0x1f4>
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
rtems_rfs_rtems_follow_link (ctx, fs, entry_ino);
10e6c: e59d8008 ldr r8, [sp, #8]
rtems_filesystem_eval_path_context_t* ctx,
rtems_rfs_file_system* fs,
rtems_rfs_ino ino
)
{
size_t len = MAXPATHLEN;
10e70: e58d7010 str r7, [sp, #16]
char *link = malloc(len + 1);
10e74: ebffd7d5 bl 6dd0 <malloc>
if (link != NULL) {
10e78: e2505000 subs r5, r0, #0
10e7c: 0a000012 beq 10ecc <rtems_rfs_rtems_eval_token+0x130>
int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);
10e80: e28d3010 add r3, sp, #16 10e84: e58d3000 str r3, [sp] 10e88: e1a00006 mov r0, r6 10e8c: e1a01008 mov r1, r8 10e90: e1a02005 mov r2, r5 10e94: e1a03007 mov r3, r7 10e98: eb002b41 bl 1bba4 <rtems_rfs_symlink_read>
if (rc == 0) {
10e9c: e3500000 cmp r0, #0
rtems_filesystem_eval_path_recursive (ctx, link, len);
10ea0: e1a00004 mov r0, r4
char *link = malloc(len + 1);
if (link != NULL) {
int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);
if (rc == 0) {
10ea4: 1a000003 bne 10eb8 <rtems_rfs_rtems_eval_token+0x11c>
rtems_filesystem_eval_path_recursive (ctx, link, len);
10ea8: e1a01005 mov r1, r5 10eac: e59d2010 ldr r2, [sp, #16] 10eb0: ebffdcbe bl 81b0 <rtems_filesystem_eval_path_recursive> 10eb4: ea000001 b 10ec0 <rtems_rfs_rtems_eval_token+0x124>
} else {
rtems_filesystem_eval_path_error (ctx, 0);
10eb8: e3a01000 mov r1, #0 <== NOT EXECUTED 10ebc: ebffdbcf bl 7e00 <rtems_filesystem_eval_path_error> <== NOT EXECUTED
}
free(link);
10ec0: e1a00005 mov r0, r5 10ec4: ebffd651 bl 6810 <free> 10ec8: ea00000c b 10f00 <rtems_rfs_rtems_eval_token+0x164>
} else {
rtems_filesystem_eval_path_error (ctx, ENOMEM);
10ecc: e1a00004 mov r0, r4 <== NOT EXECUTED 10ed0: e3a0100c mov r1, #12 <== NOT EXECUTED 10ed4: ea00002b b 10f88 <rtems_rfs_rtems_eval_token+0x1ec> <== NOT EXECUTED
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
rtems_rfs_rtems_follow_link (ctx, fs, entry_ino);
} else {
rc = rtems_rfs_rtems_set_handlers (currentloc, inode) ? 0 : EIO;
10ed8: e2840018 add r0, r4, #24 10edc: e1a01005 mov r1, r5 10ee0: eb0000ba bl 111d0 <rtems_rfs_rtems_set_handlers> 10ee4: e3500000 cmp r0, #0
10ee8: 0a000021 beq 10f74 <rtems_rfs_rtems_eval_token+0x1d8>
if (rc == 0) {
rtems_rfs_rtems_set_pathloc_ino (currentloc, entry_ino);
10eec: e59d3008 ldr r3, [sp, #8] 10ef0: e5843020 str r3, [r4, #32]
rtems_rfs_rtems_set_pathloc_doff (currentloc, entry_doff);
10ef4: e59d300c ldr r3, [sp, #12] 10ef8: e5843024 str r3, [r4, #36] ; 0x24 10efc: ea000000 b 10f04 <rtems_rfs_rtems_eval_token+0x168>
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
10f00: e3a07001 mov r7, #1
}
}
}
return status;
}
10f04: e1a00007 mov r0, r7
10f08: e28dd014 add sp, sp, #20
10f0c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
if (rtems_filesystem_is_current_directory (token, tokenlen)) {
rtems_filesystem_eval_path_clear_token (ctx);
} else {
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc( ctx );
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (currentloc);
10f10: e594302c ldr r3, [r4, #44] ; 0x2c 10f14: e5936008 ldr r6, [r3, #8]
rtems_rfs_ino entry_ino;
uint32_t entry_doff;
int rc = rtems_rfs_dir_lookup_ino (
10f18: e28d3008 add r3, sp, #8 10f1c: e58d3000 str r3, [sp] 10f20: e28d300c add r3, sp, #12 10f24: e58d3004 str r3, [sp, #4] 10f28: e1a00006 mov r0, r6 10f2c: e1a03007 mov r3, r7 10f30: e1a01005 mov r1, r5 10f34: e1a02008 mov r2, r8 10f38: eb001fa4 bl 18dd0 <rtems_rfs_dir_lookup_ino>
tokenlen,
&entry_ino,
&entry_doff
);
if (rc == 0) {
10f3c: e3500000 cmp r0, #0
* rtems_rfs_rtems_eval_path().
*/
memset (inode, 0, sizeof(*inode));
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
10f40: 13a07002 movne r7, #2
tokenlen,
&entry_ino,
&entry_doff
);
if (rc == 0) {
10f44: 1affffee bne 10f04 <rtems_rfs_rtems_eval_token+0x168>
10f48: eaffffb0 b 10e10 <rtems_rfs_rtems_eval_token+0x74>
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
rc = -1;
}
if (rc == 0) {
bool is_sym_link = rtems_rfs_rtems_node_type_by_inode (inode)
10f4c: e1a00005 mov r0, r5 10f50: ebfffd00 bl 10358 <rtems_rfs_rtems_node_type_by_inode>
== RTEMS_FILESYSTEM_SYM_LINK;
int eval_flags = rtems_filesystem_eval_path_get_flags (ctx);
bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
10f54: e5947004 ldr r7, [r4, #4] 10f58: e2777001 rsbs r7, r7, #1 10f5c: 33a07000 movcc r7, #0
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
10f60: e3500003 cmp r0, #3
static inline int rtems_filesystem_eval_path_get_flags(
const rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->flags;
10f64: e5943010 ldr r3, [r4, #16]
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
10f68: e584800c str r8, [r4, #12]
10f6c: 1affffd9 bne 10ed8 <rtems_rfs_rtems_eval_token+0x13c>
10f70: eaffffb7 b 10e54 <rtems_rfs_rtems_eval_token+0xb8>
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: set handlers", rc)
10f74: eb003196 bl 1d5d4 <__errno> <== NOT EXECUTED 10f78: e3a03005 mov r3, #5 <== NOT EXECUTED 10f7c: e5803000 str r3, [r0] <== NOT EXECUTED
if (!terminal) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
10f80: e3e01000 mvn r1, #0 <== NOT EXECUTED 10f84: e1a00004 mov r0, r4 <== NOT EXECUTED 10f88: ebffdb9c bl 7e00 <rtems_filesystem_eval_path_error> <== NOT EXECUTED 10f8c: eaffffdb b 10f00 <rtems_rfs_rtems_eval_token+0x164> <== NOT EXECUTED
000107c0 <rtems_rfs_rtems_fchmod>:
}
static int
rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
107c0: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
107c4: e5902014 ldr r2, [r0, #20] 107c8: e5924008 ldr r4, [r2, #8]
}
static int
rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
107cc: e1a03000 mov r3, r0 107d0: e24dd028 sub sp, sp, #40 ; 0x28 107d4: e1a05001 mov r5, r1
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);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
107d8: e1a00004 mov r0, r4 107dc: e5931008 ldr r1, [r3, #8] 107e0: e1a0200d mov r2, sp 107e4: e3a03001 mov r3, #1 107e8: ebfffc91 bl fa34 <rtems_rfs_inode_open>
if (rc)
107ec: e2506000 subs r6, r0, #0
107f0: 0a000002 beq 10800 <rtems_rfs_rtems_fchmod+0x40>
{
return rtems_rfs_rtems_error ("fchmod: opening inode", rc);
107f4: eb003376 bl 1d5d4 <__errno> <== NOT EXECUTED 107f8: e5806000 str r6, [r0] <== NOT EXECUTED 107fc: ea000026 b 1089c <rtems_rfs_rtems_fchmod+0xdc> <== 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);
10800: e59d300c ldr r3, [sp, #12] 10804: e5d37002 ldrb r7, [r3, #2] 10808: e5d36003 ldrb r6, [r3, #3]
/*
* Verify I am the owner of the node or the super user.
*/
#if defined (RTEMS_POSIX_API)
uid = geteuid();
1080c: eb000f70 bl 145d4 <geteuid>
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
10810: e59d300c ldr r3, [sp, #12] 10814: e5d31006 ldrb r1, [r3, #6] 10818: e5d32007 ldrb r2, [r3, #7]
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
1081c: e1822401 orr r2, r2, r1, lsl #8 10820: e1500002 cmp r0, r2
10824: 0a000008 beq 1084c <rtems_rfs_rtems_fchmod+0x8c>
10828: e3500000 cmp r0, #0 <== NOT EXECUTED 1082c: 0a000006 beq 1084c <rtems_rfs_rtems_fchmod+0x8c> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
10830: e1a0100d mov r1, sp <== NOT EXECUTED 10834: e1a00004 mov r0, r4 <== NOT EXECUTED 10838: ebfffcf2 bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
1083c: eb003364 bl 1d5d4 <__errno> <== NOT EXECUTED 10840: e3a03001 mov r3, #1 <== NOT EXECUTED 10844: e5803000 str r3, [r0] <== NOT EXECUTED 10848: ea000013 b 1089c <rtems_rfs_rtems_fchmod+0xdc> <== 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);
1084c: e1866407 orr r6, r6, r7, lsl #8
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
10850: e2066a0f and r6, r6, #61440 ; 0xf000
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
10854: e1a05a05 lsl r5, r5, #20 10858: e1865a25 orr r5, r6, r5, lsr #20 1085c: e1a05805 lsl r5, r5, #16 10860: e1a02825 lsr r2, r5, #16
* @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);
10864: e1a05c25 lsr r5, r5, #24 10868: e5c35002 strb r5, [r3, #2] 1086c: e59d300c ldr r3, [sp, #12]
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
10870: e1a00004 mov r0, r4 10874: e5c32003 strb r2, [r3, #3] 10878: e1a0100d mov r1, sp
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1087c: e3a03001 mov r3, #1 10880: e5cd3010 strb r3, [sp, #16] 10884: ebfffcdf bl fc08 <rtems_rfs_inode_close>
if (rc > 0)
10888: e2504000 subs r4, r0, #0
{
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
}
return 0;
1088c: d3a00000 movle r0, #0
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
10890: da000002 ble 108a0 <rtems_rfs_rtems_fchmod+0xe0>
{
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
10894: eb00334e bl 1d5d4 <__errno> <== NOT EXECUTED 10898: e5804000 str r4, [r0] <== NOT EXECUTED 1089c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return 0;
}
108a0: e28dd028 add sp, sp, #40 ; 0x28
108a4: e8bd80f0 pop {r4, r5, r6, r7, pc}
000111a0 <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));
111a0: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
111a4: e92d4010 push {r4, lr} <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
111a8: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 111ac: eb001e60 bl 18b34 <rtems_rfs_buffer_sync> <== NOT EXECUTED
if (rc)
111b0: e2504000 subs r4, r0, #0 <== NOT EXECUTED 111b4: 0a000003 beq 111c8 <rtems_rfs_rtems_fdatasync+0x28> <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
111b8: eb003105 bl 1d5d4 <__errno> <== NOT EXECUTED
111bc: e5804000 str r4, [r0] <== NOT EXECUTED
111c0: e3e00000 mvn r0, #0 <== NOT EXECUTED
111c4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
return 0;
111c8: e1a00004 mov r0, r4 <== NOT EXECUTED
}
111cc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0001c678 <rtems_rfs_rtems_file_close>:
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
1c678: e92d4030 push {r4, r5, lr}
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
1c67c: e590501c ldr r5, [r0, #28]
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
1c680: e595301c ldr r3, [r5, #28] 1c684: e5934098 ldr r4, [r3, #152] ; 0x98
int rc;
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);
1c688: e1a00004 mov r0, r4 1c68c: ebfffeef bl 1c250 <rtems_rfs_rtems_lock>
rc = rtems_rfs_file_close (fs, file);
1c690: e1a01005 mov r1, r5 1c694: e1a00004 mov r0, r4 1c698: ebfff607 bl 19ebc <rtems_rfs_file_close>
if (rc > 0)
1c69c: e2505000 subs r5, r0, #0
1c6a0: da000002 ble 1c6b0 <rtems_rfs_rtems_file_close+0x38>
rc = rtems_rfs_rtems_error ("file-close: file close", rc);
1c6a4: eb0003ca bl 1d5d4 <__errno> <== NOT EXECUTED 1c6a8: e5805000 str r5, [r0] <== NOT EXECUTED 1c6ac: e3e05000 mvn r5, #0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
1c6b0: e1a00004 mov r0, r4 1c6b4: ebfffef9 bl 1c2a0 <rtems_rfs_rtems_unlock>
return rc; }
1c6b8: e1a00005 mov r0, r5
1c6bc: e8bd8030 pop {r4, r5, pc}
0001c2ec <rtems_rfs_rtems_file_ftruncate>:
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
1c2ec: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
1c2f0: e590401c ldr r4, [r0, #28]
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))
printf("rtems-rfs: file-ftrunc: handle:%p length:%" PRIdoff_t "\n", file, length);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
1c2f4: e594301c ldr r3, [r4, #28]
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
1c2f8: e1a06001 mov r6, r1
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))
printf("rtems-rfs: file-ftrunc: handle:%p length:%" PRIdoff_t "\n", file, length);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
1c2fc: e5930098 ldr r0, [r3, #152] ; 0x98
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
1c300: e1a07002 mov r7, r2
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))
printf("rtems-rfs: file-ftrunc: handle:%p length:%" PRIdoff_t "\n", file, length);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
1c304: ebffffd1 bl 1c250 <rtems_rfs_rtems_lock>
rc = rtems_rfs_file_set_size (file, length);
1c308: e1a00004 mov r0, r4 1c30c: e1a01006 mov r1, r6 1c310: e1a02007 mov r2, r7 1c314: ebfff8cb bl 1a648 <rtems_rfs_file_set_size>
if (rc)
1c318: e2505000 subs r5, r0, #0
1c31c: 0a000002 beq 1c32c <rtems_rfs_rtems_file_ftruncate+0x40>
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
1c320: eb0004ab bl 1d5d4 <__errno> <== NOT EXECUTED 1c324: e5805000 str r5, [r0] <== NOT EXECUTED 1c328: e3e05000 mvn r5, #0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
1c32c: e594301c ldr r3, [r4, #28] 1c330: e5930098 ldr r0, [r3, #152] ; 0x98 1c334: ebffffd9 bl 1c2a0 <rtems_rfs_rtems_unlock>
return rc;
}
1c338: e1a00005 mov r0, r5
1c33c: e8bd80f0 pop {r4, r5, r6, r7, pc}
0001c340 <rtems_rfs_rtems_file_lseek>:
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
1c340: e92d4f7f push {r0, r1, r2, r3, r4, r5, r6, r8, r9, sl, fp, lr}
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
1c344: e590501c ldr r5, [r0, #28]
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
1c348: e1a06003 mov r6, r3
off_t new_offset;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
1c34c: e595301c ldr r3, [r5, #28]
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
1c350: e1a04000 mov r4, r0
off_t new_offset;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
1c354: e5930098 ldr r0, [r3, #152] ; 0x98
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
1c358: e1a09002 mov r9, r2 1c35c: e1a08001 mov r8, r1
off_t new_offset;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
1c360: ebffffba bl 1c250 <rtems_rfs_rtems_lock>
old_offset = iop->offset;
1c364: e994000c ldmib r4, {r2, r3}
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
1c368: e1a01008 mov r1, r8
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
old_offset = iop->offset;
1c36c: e88d000c stm sp, {r2, r3}
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
1c370: e1a00004 mov r0, r4 1c374: e1a02009 mov r2, r9 1c378: e1a03006 mov r3, r6 1c37c: eb00010a bl 1c7ac <rtems_filesystem_default_lseek_file>
if (new_offset != -1)
1c380: e3e0a000 mvn sl, #0
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
old_offset = iop->offset;
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
1c384: e1a08000 mov r8, r0 1c388: e1a09001 mov r9, r1
if (new_offset != -1)
1c38c: e3e0b000 mvn fp, #0 1c390: e159000b cmp r9, fp 1c394: 0158000a cmpeq r8, sl
1c398: 0a00000c beq 1c3d0 <rtems_rfs_rtems_file_lseek+0x90>
{
rtems_rfs_pos pos = iop->offset;
1c39c: e9940006 ldmib r4, {r1, r2}
1c3a0: e28d3010 add r3, sp, #16
1c3a4: e9230006 stmdb r3!, {r1, r2}
int rc = rtems_rfs_file_seek (file, pos, &pos);
1c3a8: e1a00005 mov r0, r5 1c3ac: ebfff86e bl 1a56c <rtems_rfs_file_seek>
if (rc)
1c3b0: e2506000 subs r6, r0, #0
1c3b4: 0a000005 beq 1c3d0 <rtems_rfs_rtems_file_lseek+0x90>
{
rtems_rfs_rtems_error ("file_lseek: lseek", rc);
1c3b8: eb000485 bl 1d5d4 <__errno> <== NOT EXECUTED
iop->offset = old_offset;
1c3bc: e89d000c ldm sp, {r2, r3} <== NOT EXECUTED
rtems_rfs_pos pos = iop->offset;
int rc = rtems_rfs_file_seek (file, pos, &pos);
if (rc)
{
rtems_rfs_rtems_error ("file_lseek: lseek", rc);
1c3c0: e5806000 str r6, [r0] <== NOT EXECUTED
iop->offset = old_offset;
1c3c4: e984000c stmib r4, {r2, r3} <== NOT EXECUTED
new_offset = -1;
1c3c8: e1a0800a mov r8, sl <== NOT EXECUTED 1c3cc: e1a0900b mov r9, fp <== NOT EXECUTED
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
1c3d0: e595301c ldr r3, [r5, #28] 1c3d4: e5930098 ldr r0, [r3, #152] ; 0x98 1c3d8: ebffffb0 bl 1c2a0 <rtems_rfs_rtems_unlock>
return new_offset;
}
1c3dc: e1a00008 mov r0, r8
1c3e0: e1a01009 mov r1, r9
1c3e4: e28dd010 add sp, sp, #16
1c3e8: e8bd8f70 pop {r4, r5, r6, r8, r9, sl, fp, pc}
0001c6c0 <rtems_rfs_rtems_file_open>:
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
1c6c0: e92d4071 push {r0, r4, r5, r6, lr}
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
1c6c4: e5903024 ldr r3, [r0, #36] ; 0x24 1c6c8: e5934008 ldr r4, [r3, #8]
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
1c6cc: e1a05000 mov r5, r0
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: path:%s ino:%" PRId32 " flags:%04i mode:%04" PRIu32 "\n",
pathname, ino, flags, mode);
rtems_rfs_rtems_lock (fs);
1c6d0: e1a00004 mov r0, r4 1c6d4: ebfffedd bl 1c250 <rtems_rfs_rtems_lock>
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
1c6d8: e1a00004 mov r0, r4 1c6dc: e5951018 ldr r1, [r5, #24] 1c6e0: e3a02000 mov r2, #0 1c6e4: e1a0300d mov r3, sp 1c6e8: ebfff89a bl 1a958 <rtems_rfs_file_open>
if (rc > 0)
1c6ec: e2506000 subs r6, r0, #0
1c6f0: da000005 ble 1c70c <rtems_rfs_rtems_file_open+0x4c>
{
rtems_rfs_rtems_unlock (fs);
1c6f4: e1a00004 mov r0, r4 <== NOT EXECUTED 1c6f8: ebfffee8 bl 1c2a0 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-open: open", rc);
1c6fc: eb0003b4 bl 1d5d4 <__errno> <== NOT EXECUTED 1c700: e5806000 str r6, [r0] <== NOT EXECUTED 1c704: e3e00000 mvn r0, #0 <== NOT EXECUTED 1c708: ea000004 b 1c720 <rtems_rfs_rtems_file_open+0x60> <== NOT EXECUTED
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
rtems_rfs_rtems_set_iop_file_handle (iop, file);
1c70c: e59d3000 ldr r3, [sp]
rtems_rfs_rtems_unlock (fs);
1c710: e1a00004 mov r0, r4
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
rtems_rfs_rtems_set_iop_file_handle (iop, file);
1c714: e585301c str r3, [r5, #28]
rtems_rfs_rtems_unlock (fs);
1c718: ebfffee0 bl 1c2a0 <rtems_rfs_rtems_unlock>
return 0;
1c71c: e3a00000 mov r0, #0
}
1c720: e8bd8078 pop {r3, r4, r5, r6, pc}
0001c574 <rtems_rfs_rtems_file_read>:
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
1c574: e92d45f7 push {r0, r1, r2, r4, r5, r6, r7, r8, sl, lr}
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
1c578: e590501c ldr r5, [r0, #28]
int rc;
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));
1c57c: e595301c ldr r3, [r5, #28]
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
1c580: e1a0a000 mov sl, r0
int rc;
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));
1c584: e5930098 ldr r0, [r3, #152] ; 0x98
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
1c588: e1a08001 mov r8, r1 1c58c: e1a06002 mov r6, r2
int rc;
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));
1c590: ebffff2e bl 1c250 <rtems_rfs_rtems_lock>
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
1c594: e595101c ldr r1, [r5, #28]
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;
1c598: e99a0018 ldmib sl, {r3, r4}
1c59c: e5910098 ldr r0, [r1, #152] ; 0x98
1c5a0: e2811084 add r1, r1, #132 ; 0x84
1c5a4: e88d0018 stm sp, {r3, r4}
1c5a8: ebffecab bl 1785c <rtems_rfs_block_get_size>
if (pos < rtems_rfs_file_size (file))
1c5ac: e89d0018 ldm sp, {r3, r4}
1c5b0: e1540001 cmp r4, r1
1c5b4: 01530000 cmpeq r3, r0
1c5b8: e3a04000 mov r4, #0
1c5bc: 3a000020 bcc 1c644 <rtems_rfs_rtems_file_read+0xd0>
1c5c0: ea000023 b 1c654 <rtems_rfs_rtems_file_read+0xe0>
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
1c5c4: e1a00005 mov r0, r5 1c5c8: e28d1008 add r1, sp, #8 1c5cc: e3a02001 mov r2, #1 1c5d0: ebfff6db bl 1a144 <rtems_rfs_file_io_start>
if (rc > 0)
1c5d4: e2507000 subs r7, r0, #0
1c5d8: ca000015 bgt 1c634 <rtems_rfs_rtems_file_read+0xc0>
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
break;
}
if (size == 0)
1c5dc: e59d3008 ldr r3, [sp, #8] 1c5e0: e3530000 cmp r3, #0
1c5e4: 0a000018 beq 1c64c <rtems_rfs_rtems_file_read+0xd8>
break;
if (size > count)
1c5e8: e1530006 cmp r3, r6
size = count;
1c5ec: 858d6008 strhi r6, [sp, #8]
memcpy (data, rtems_rfs_file_data (file), size);
1c5f0: e595300c ldr r3, [r5, #12] 1c5f4: e59d7008 ldr r7, [sp, #8] 1c5f8: e593101c ldr r1, [r3, #28] 1c5fc: e5953014 ldr r3, [r5, #20] 1c600: e1a02007 mov r2, r7 1c604: e0811003 add r1, r1, r3 1c608: e1a00008 mov r0, r8 1c60c: eb000812 bl 1e65c <memcpy>
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
1c610: e1a01007 mov r1, r7 1c614: e1a00005 mov r0, r5 1c618: e3a02001 mov r2, #1 1c61c: ebfff746 bl 1a33c <rtems_rfs_file_io_end>
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
1c620: e0888007 add r8, r8, r7
count -= size;
1c624: e0676006 rsb r6, r7, r6
read += size;
1c628: e0844007 add r4, r4, r7
rc = rtems_rfs_file_io_end (file, size, true);
if (rc > 0)
1c62c: e2507000 subs r7, r0, #0
1c630: da000003 ble 1c644 <rtems_rfs_rtems_file_read+0xd0>
{
read = rtems_rfs_rtems_error ("file-read: read: io-end", rc);
1c634: eb0003e6 bl 1d5d4 <__errno> <== NOT EXECUTED
size_t count)
{
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
rtems_rfs_pos pos;
uint8_t* data = buffer;
ssize_t read = 0;
1c638: e3e04000 mvn r4, #0 <== 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);
1c63c: e5807000 str r7, [r0] <== NOT EXECUTED 1c640: ea000007 b 1c664 <rtems_rfs_rtems_file_read+0xf0> <== NOT EXECUTED
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
1c644: e3560000 cmp r6, #0
1c648: 1affffdd bne 1c5c4 <rtems_rfs_rtems_file_read+0x50>
break;
}
}
}
if (read >= 0)
1c64c: e3540000 cmp r4, #0
1c650: ba000003 blt 1c664 <rtems_rfs_rtems_file_read+0xf0>
iop->offset = pos + read;
1c654: e89d000c ldm sp, {r2, r3}
1c658: e0922004 adds r2, r2, r4
1c65c: e0a33fc4 adc r3, r3, r4, asr #31
1c660: e98a000c stmib sl, {r2, r3}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
1c664: e595301c ldr r3, [r5, #28] 1c668: e5930098 ldr r0, [r3, #152] ; 0x98 1c66c: ebffff0b bl 1c2a0 <rtems_rfs_rtems_unlock>
return read;
}
1c670: e1a00004 mov r0, r4
1c674: e8bd85fe pop {r1, r2, r3, r4, r5, r6, r7, r8, sl, pc}
0001c3ec <rtems_rfs_rtems_file_write>:
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
1c3ec: e92d47f7 push {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, lr}
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
1c3f0: e590401c ldr r4, [r0, #28]
int rc;
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));
1c3f4: e594301c ldr r3, [r4, #28]
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
1c3f8: e1a07000 mov r7, r0
int rc;
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));
1c3fc: e5930098 ldr r0, [r3, #152] ; 0x98
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
1c400: e1a05001 mov r5, r1 1c404: e1a06002 mov r6, r2
int rc;
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));
1c408: ebffff90 bl 1c250 <rtems_rfs_rtems_lock>
pos = iop->offset;
file_size = rtems_rfs_file_size (file);
1c40c: e594101c ldr r1, [r4, #28]
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;
1c410: e997000c ldmib r7, {r2, r3}
1c414: e5910098 ldr r0, [r1, #152] ; 0x98
1c418: e2811084 add r1, r1, #132 ; 0x84
1c41c: e88d000c stm sp, {r2, r3}
1c420: ebffed0d bl 1785c <rtems_rfs_block_get_size>
file_size = rtems_rfs_file_size (file); if (pos > file_size)
1c424: e89d000c ldm sp, {r2, r3}
1c428: e1a08000 mov r8, r0
1c42c: e1a09001 mov r9, r1
1c430: e1590003 cmp r9, r3
1c434: 01580002 cmpeq r8, r2
1c438: 2a00000b bcs 1c46c <rtems_rfs_rtems_file_write+0x80>
/*
* If the iop position is past the physical end of the file we need to set
* the file size to the new length before writing. The
* rtems_rfs_file_io_end() will grow the file subsequently.
*/
rc = rtems_rfs_file_set_size (file, pos);
1c43c: e1a01002 mov r1, r2 1c440: e1a00004 mov r0, r4 1c444: e1a02003 mov r2, r3 1c448: ebfff87e bl 1a648 <rtems_rfs_file_set_size> 1c44c: e594301c ldr r3, [r4, #28]
if (rc)
1c450: e2508000 subs r8, r0, #0
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
1c454: e5930098 ldr r0, [r3, #152] ; 0x98
* If the iop position is past the physical end of the file we need to set
* the file size to the new length before writing. The
* rtems_rfs_file_io_end() will grow the file subsequently.
*/
rc = rtems_rfs_file_set_size (file, pos);
if (rc)
1c458: 1a000013 bne 1c4ac <rtems_rfs_rtems_file_write+0xc0>
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
rtems_rfs_file_set_bpos (file, pos);
1c45c: e89d0006 ldm sp, {r1, r2}
1c460: e2843010 add r3, r4, #16
1c464: ebffeccc bl 1779c <rtems_rfs_block_get_bpos>
1c468: ea000032 b 1c538 <rtems_rfs_rtems_file_write+0x14c>
} else if (pos < file_size && (iop->flags & LIBIO_FLAGS_APPEND) != 0)
1c46c: e1530009 cmp r3, r9 1c470: 01520008 cmpeq r2, r8
1c474: 2a00002f bcs 1c538 <rtems_rfs_rtems_file_write+0x14c>
1c478: e597300c ldr r3, [r7, #12] 1c47c: e3130c02 tst r3, #512 ; 0x200
1c480: 0a00002c beq 1c538 <rtems_rfs_rtems_file_write+0x14c>
{
pos = file_size;
rc = rtems_rfs_file_seek (file, pos, &pos);
1c484: e1a01008 mov r1, r8 1c488: e1a00004 mov r0, r4 1c48c: e1a02009 mov r2, r9 1c490: e1a0300d mov r3, sp
rtems_rfs_file_set_bpos (file, pos);
}
else if (pos < file_size && (iop->flags & LIBIO_FLAGS_APPEND) != 0)
{
pos = file_size;
1c494: e88d0300 stm sp, {r8, r9}
rc = rtems_rfs_file_seek (file, pos, &pos);
1c498: ebfff833 bl 1a56c <rtems_rfs_file_seek>
if (rc)
1c49c: e2508000 subs r8, r0, #0
1c4a0: 0a000024 beq 1c538 <rtems_rfs_rtems_file_write+0x14c>
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
1c4a4: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 1c4a8: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 1c4ac: ebffff7b bl 1c2a0 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
1c4b0: eb000447 bl 1d5d4 <__errno> <== NOT EXECUTED 1c4b4: e3e05000 mvn r5, #0 <== NOT EXECUTED 1c4b8: e5808000 str r8, [r0] <== NOT EXECUTED 1c4bc: ea00002a b 1c56c <rtems_rfs_rtems_file_write+0x180> <== NOT EXECUTED
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
1c4c0: e1a00004 mov r0, r4 1c4c4: e28d1008 add r1, sp, #8 1c4c8: e3a02000 mov r2, #0
}
}
while (count)
{
size_t size = count;
1c4cc: e58d6008 str r6, [sp, #8]
rc = rtems_rfs_file_io_start (file, &size, false);
1c4d0: ebfff71b bl 1a144 <rtems_rfs_file_io_start>
if (rc)
1c4d4: e250a000 subs sl, r0, #0
1c4d8: 1a000012 bne 1c528 <rtems_rfs_rtems_file_write+0x13c>
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
1c4dc: e59d3008 ldr r3, [sp, #8] 1c4e0: e1530006 cmp r3, r6
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
1c4e4: e594300c ldr r3, [r4, #12]
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
size = count;
1c4e8: 858d6008 strhi r6, [sp, #8]
memcpy (rtems_rfs_file_data (file), data, size);
1c4ec: e593001c ldr r0, [r3, #28] 1c4f0: e5943014 ldr r3, [r4, #20] 1c4f4: e1a01008 mov r1, r8 1c4f8: e0800003 add r0, r0, r3 1c4fc: e59d2008 ldr r2, [sp, #8] 1c500: eb000855 bl 1e65c <memcpy>
data += size;
1c504: e59d1008 ldr r1, [sp, #8]
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
1c508: e1a00004 mov r0, r4 1c50c: e3a02000 mov r2, #0
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
1c510: e0888001 add r8, r8, r1
count -= size;
1c514: e0616006 rsb r6, r1, r6
write += size;
1c518: e0855001 add r5, r5, r1
rc = rtems_rfs_file_io_end (file, size, false);
1c51c: ebfff786 bl 1a33c <rtems_rfs_file_io_end>
if (rc)
1c520: e250a000 subs sl, r0, #0
1c524: 0a000005 beq 1c540 <rtems_rfs_rtems_file_write+0x154>
{
write = rtems_rfs_rtems_error ("file-write: write close", rc);
1c528: eb000429 bl 1d5d4 <__errno>
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
}
}
while (count)
1c52c: e3e05000 mvn r5, #0
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
if (rc)
{
write = rtems_rfs_rtems_error ("file-write: write close", rc);
1c530: e580a000 str sl, [r0] 1c534: ea000009 b 1c560 <rtems_rfs_rtems_file_write+0x174>
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
1c538: e1a08005 mov r8, r5 1c53c: e3a05000 mov r5, #0
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
}
}
while (count)
1c540: e3560000 cmp r6, #0
1c544: 1affffdd bne 1c4c0 <rtems_rfs_rtems_file_write+0xd4>
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
if (write >= 0)
1c548: e3550000 cmp r5, #0
1c54c: ba000003 blt 1c560 <rtems_rfs_rtems_file_write+0x174>
iop->offset = pos + write;
1c550: e89d000c ldm sp, {r2, r3}
1c554: e0922005 adds r2, r2, r5
1c558: e0a33fc5 adc r3, r3, r5, asr #31
1c55c: e987000c stmib r7, {r2, r3}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
1c560: e594301c ldr r3, [r4, #28] 1c564: e5930098 ldr r0, [r3, #152] ; 0x98 1c568: ebffff4c bl 1c2a0 <rtems_rfs_rtems_unlock>
return write;
}
1c56c: e1a00005 mov r0, r5
1c570: e8bd87fe pop {r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, pc}
00010b4c <rtems_rfs_rtems_fstat>:
}
int
rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
10b4c: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
10b50: e5902014 ldr r2, [r0, #20] 10b54: e5925008 ldr r5, [r2, #8]
}
int
rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
10b58: e1a03000 mov r3, r0 10b5c: e24dd028 sub sp, sp, #40 ; 0x28 10b60: e1a04001 mov r4, r1
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
10b64: e1a00005 mov r0, r5 10b68: e5931008 ldr r1, [r3, #8] 10b6c: e1a0200d mov r2, sp 10b70: e3a03001 mov r3, #1 10b74: ebfffbae bl fa34 <rtems_rfs_inode_open>
if (rc)
10b78: e2507000 subs r7, r0, #0
10b7c: 0a000002 beq 10b8c <rtems_rfs_rtems_fstat+0x40>
{
return rtems_rfs_rtems_error ("stat: opening inode", rc);
10b80: eb003293 bl 1d5d4 <__errno> <== NOT EXECUTED 10b84: e5807000 str r7, [r0] <== NOT EXECUTED 10b88: ea00007f b 10d8c <rtems_rfs_rtems_fstat+0x240> <== 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);
10b8c: e59d300c ldr r3, [sp, #12] 10b90: e5d36002 ldrb r6, [r3, #2] 10b94: e5d33003 ldrb r3, [r3, #3]
}
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
10b98: e1836406 orr r6, r3, r6, lsl #8 10b9c: e2063a0f and r3, r6, #61440 ; 0xf000 10ba0: e3530a02 cmp r3, #8192 ; 0x2000 10ba4: 13530a06 cmpne r3, #24576 ; 0x6000
10ba8: 1a000008 bne 10bd0 <rtems_rfs_rtems_fstat+0x84>
{
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
10bac: e1a01007 mov r1, r7 <== NOT EXECUTED 10bb0: e1a0000d mov r0, sp <== NOT EXECUTED 10bb4: ebfffdc7 bl 102d8 <rtems_rfs_inode_get_block> <== NOT EXECUTED 10bb8: e3a01001 mov r1, #1 <== NOT EXECUTED 10bbc: e1a07000 mov r7, r0 <== NOT EXECUTED 10bc0: e1a0000d mov r0, sp <== NOT EXECUTED 10bc4: ebfffdc3 bl 102d8 <rtems_rfs_inode_get_block> <== NOT EXECUTED
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
{
buf->st_rdev =
10bc8: e5847018 str r7, [r4, #24] <== NOT EXECUTED 10bcc: e584001c str r0, [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);
10bd0: e5951010 ldr r1, [r5, #16]
buf->st_ino = rtems_rfs_inode_ino (&inode);
10bd4: e59d3008 ldr r3, [sp, #8]
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);
10bd8: e1a02fc1 asr r2, r1, #31 10bdc: e5841000 str r1, [r4] 10be0: e5842004 str r2, [r4, #4]
buf->st_ino = rtems_rfs_inode_ino (&inode);
10be4: e5843008 str r3, [r4, #8]
buf->st_mode = rtems_rfs_rtems_mode (mode);
10be8: e1a00006 mov r0, r6 10bec: eb00019d bl 11268 <rtems_rfs_rtems_mode>
*/
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);
10bf0: e59d300c ldr r3, [sp, #12] 10bf4: e584000c str r0, [r4, #12] 10bf8: e5d31000 ldrb r1, [r3] 10bfc: e5d32001 ldrb r2, [r3, #1] 10c00: e1822401 orr r2, r2, r1, lsl #8
if (links == 0xffff)
links = 0;
10c04: e59f118c ldr r1, [pc, #396] ; 10d98 <rtems_rfs_rtems_fstat+0x24c> 10c08: e1520001 cmp r2, r1 10c0c: 03a02000 moveq r2, #0
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
10c10: e1c421b0 strh r2, [r4, #16]
* @return uint16_t The user id (uid).
*/
static inline uint16_t
rtems_rfs_inode_get_uid (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->owner) & 0xffff;
10c14: e5d32006 ldrb r2, [r3, #6] 10c18: e5d33007 ldrb r3, [r3, #7] 10c1c: e1833402 orr r3, r3, r2, lsl #8
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
10c20: e1c431b2 strh r3, [r4, #18]
buf->st_gid = rtems_rfs_inode_get_gid (&inode);
10c24: e1a0000d mov r0, sp 10c28: ebfffda3 bl 102bc <rtems_rfs_inode_get_gid>
/*
* 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, rtems_rfs_inode_ino (&inode));
10c2c: e59d1008 ldr r1, [sp, #8]
buf->st_dev = rtems_rfs_fs_device (fs); buf->st_ino = rtems_rfs_inode_ino (&inode); 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);
10c30: e1c401b4 strh r0, [r4, #20]
/*
* 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, rtems_rfs_inode_ino (&inode));
10c34: e1a00005 mov r0, r5 10c38: eb002739 bl 1a924 <rtems_rfs_file_get_shared>
if (shared)
10c3c: e2501000 subs r1, r0, #0
10c40: 0a000013 beq 10c94 <rtems_rfs_rtems_fstat+0x148>
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
10c44: e591308c ldr r3, [r1, #140] ; 0x8c 10c48: e5843028 str r3, [r4, #40] ; 0x28
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
10c4c: e5913090 ldr r3, [r1, #144] ; 0x90 10c50: e5843030 str r3, [r4, #48] ; 0x30
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
10c54: e5913094 ldr r3, [r1, #148] ; 0x94 10c58: e5843038 str r3, [r4, #56] ; 0x38
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
10c5c: e5913084 ldr r3, [r1, #132] ; 0x84 10c60: e5843044 str r3, [r4, #68] ; 0x44
if (S_ISLNK (buf->st_mode))
10c64: e594300c ldr r3, [r4, #12] 10c68: e2033a0f and r3, r3, #61440 ; 0xf000 10c6c: e3530a0a cmp r3, #40960 ; 0xa000
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
10c70: 01d138b8 ldrheq r3, [r1, #136] ; 0x88 10c74: 05843020 streq r3, [r4, #32] 10c78: 03a03000 moveq r3, #0 10c7c: 05843024 streq r3, [r4, #36] ; 0x24
10c80: 0a000037 beq 10d64 <rtems_rfs_rtems_fstat+0x218>
*/
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);
10c84: e1a00005 mov r0, r5 10c88: e2811084 add r1, r1, #132 ; 0x84 10c8c: eb001af2 bl 1785c <rtems_rfs_block_get_size> 10c90: ea000031 b 10d5c <rtems_rfs_rtems_fstat+0x210>
* @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);
10c94: e59d300c ldr r3, [sp, #12] 10c98: e5d32011 ldrb r2, [r3, #17] 10c9c: e5d30010 ldrb r0, [r3, #16] 10ca0: e1a02802 lsl r2, r2, #16 10ca4: e1822c00 orr r2, r2, r0, lsl #24 10ca8: e5d30013 ldrb r0, [r3, #19] 10cac: e1822000 orr r2, r2, r0 10cb0: e5d30012 ldrb r0, [r3, #18] 10cb4: e1822400 orr r2, r2, r0, lsl #8
else
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
}
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
10cb8: e5842028 str r2, [r4, #40] ; 0x28
* @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);
10cbc: e5d32015 ldrb r2, [r3, #21] 10cc0: e5d30014 ldrb r0, [r3, #20] 10cc4: e1a02802 lsl r2, r2, #16 10cc8: e1822c00 orr r2, r2, r0, lsl #24 10ccc: e5d30017 ldrb r0, [r3, #23] 10cd0: e1822000 orr r2, r2, r0 10cd4: e5d30016 ldrb r0, [r3, #22] 10cd8: e1822400 orr r2, r2, r0, lsl #8
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
10cdc: e5842030 str r2, [r4, #48] ; 0x30
* @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);
10ce0: e5d32019 ldrb r2, [r3, #25] 10ce4: e5d30018 ldrb r0, [r3, #24] 10ce8: e1a02802 lsl r2, r2, #16 10cec: e1822c00 orr r2, r2, r0, lsl #24 10cf0: e5d3001b ldrb r0, [r3, #27] 10cf4: e1822000 orr r2, r2, r0 10cf8: e5d3001a ldrb r0, [r3, #26] 10cfc: e1822400 orr r2, r2, r0, lsl #8
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
10d00: e5842038 str r2, [r4, #56] ; 0x38
* @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);
10d04: e5d3200d ldrb r2, [r3, #13] 10d08: e5d3000c ldrb r0, [r3, #12] 10d0c: e1a02802 lsl r2, r2, #16 10d10: e1822c00 orr r2, r2, r0, lsl #24 10d14: e5d3000f ldrb r0, [r3, #15] 10d18: e1822000 orr r2, r2, r0 10d1c: e5d3000e ldrb r0, [r3, #14] 10d20: e1822400 orr r2, r2, r0, lsl #8
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
10d24: e5842044 str r2, [r4, #68] ; 0x44
if (S_ISLNK (buf->st_mode))
10d28: e594200c ldr r2, [r4, #12] 10d2c: e2022a0f and r2, r2, #61440 ; 0xf000 10d30: e3520a0a cmp r2, #40960 ; 0xa000
10d34: 1a000005 bne 10d50 <rtems_rfs_rtems_fstat+0x204>
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
10d38: e5d3200a ldrb r2, [r3, #10] 10d3c: e5d3300b ldrb r3, [r3, #11]
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
10d40: e1833402 orr r3, r3, r2, lsl #8 10d44: e5843020 str r3, [r4, #32] 10d48: e5841024 str r1, [r4, #36] ; 0x24 10d4c: ea000004 b 10d64 <rtems_rfs_rtems_fstat+0x218>
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
10d50: e1a00005 mov r0, r5 10d54: e1a0100d mov r1, sp 10d58: ebfffd45 bl 10274 <rtems_rfs_inode_get_size> 10d5c: e5840020 str r0, [r4, #32] 10d60: e5841024 str r1, [r4, #36] ; 0x24
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
10d64: e5953008 ldr r3, [r5, #8]
rc = rtems_rfs_inode_close (fs, &inode);
10d68: e1a00005 mov r0, r5
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);
10d6c: e5843040 str r3, [r4, #64] ; 0x40
rc = rtems_rfs_inode_close (fs, &inode);
10d70: e1a0100d mov r1, sp 10d74: ebfffba3 bl fc08 <rtems_rfs_inode_close>
if (rc > 0)
10d78: e2504000 subs r4, r0, #0
{
return rtems_rfs_rtems_error ("stat: closing inode", rc);
}
return 0;
10d7c: d3a00000 movle r0, #0
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
10d80: da000002 ble 10d90 <rtems_rfs_rtems_fstat+0x244>
{
return rtems_rfs_rtems_error ("stat: closing inode", rc);
10d84: eb003212 bl 1d5d4 <__errno> <== NOT EXECUTED 10d88: e5804000 str r4, [r0] <== NOT EXECUTED 10d8c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return 0;
}
10d90: e28dd028 add sp, sp, #40 ; 0x28
10d94: e8bd80f0 pop {r4, r5, r6, r7, pc}
00010ffc <rtems_rfs_rtems_initialise>:
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
10ffc: e92d41f3 push {r0, r1, r4, r5, r6, r7, r8, lr}
11000: e1a05000 mov r5, r0
11004: e1a04001 mov r4, r1
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;
11008: e3a07005 mov r7, #5
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
rtems_rfs_rtems_private* rtems;
rtems_rfs_file_system* fs;
uint32_t flags = 0;
1100c: e3a06000 mov r6, #0
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
11010: ea000027 b 110b4 <rtems_rfs_rtems_initialise+0xb8>
{
printf ("options=%s\n", options);
11014: e1a01004 mov r1, r4 <== NOT EXECUTED 11018: e59f0168 ldr r0, [pc, #360] ; 11188 <rtems_rfs_rtems_initialise+0x18c><== NOT EXECUTED 1101c: eb003682 bl 1ea2c <printf> <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
11020: e1a00004 mov r0, r4 <== NOT EXECUTED 11024: e59f1160 ldr r1, [pc, #352] ; 1118c <rtems_rfs_rtems_initialise+0x190><== NOT EXECUTED 11028: e3a0200c mov r2, #12 <== NOT EXECUTED 1102c: eb003b6a bl 1fddc <strncmp> <== NOT EXECUTED 11030: e3500000 cmp r0, #0 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
11034: 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",
11038: 0a000014 beq 11090 <rtems_rfs_rtems_initialise+0x94> <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
1103c: e1a00004 mov r0, r4 <== NOT EXECUTED 11040: e59f1148 ldr r1, [pc, #328] ; 11190 <rtems_rfs_rtems_initialise+0x194><== NOT EXECUTED 11044: e3a0200e mov r2, #14 <== NOT EXECUTED 11048: eb003b63 bl 1fddc <strncmp> <== NOT EXECUTED 1104c: e3500000 cmp r0, #0 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
11050: 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",
11054: 0a00000d beq 11090 <rtems_rfs_rtems_initialise+0x94> <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
11058: e59f1134 ldr r1, [pc, #308] ; 11194 <rtems_rfs_rtems_initialise+0x198><== NOT EXECUTED 1105c: e1a00004 mov r0, r4 <== NOT EXECUTED 11060: e3a0200d mov r2, #13 <== NOT EXECUTED 11064: eb003b5c bl 1fddc <strncmp> <== NOT EXECUTED 11068: e2501000 subs r1, r0, #0 <== NOT EXECUTED 1106c: 1a000004 bne 11084 <rtems_rfs_rtems_initialise+0x88> <== NOT EXECUTED
sizeof ("max-held-bufs") - 1) == 0)
{
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
11070: e284000e add r0, r4, #14 <== NOT EXECUTED 11074: e1a02001 mov r2, r1 <== NOT EXECUTED 11078: eb003c1a bl 200e8 <strtoul> <== NOT EXECUTED 1107c: e1a07000 mov r7, r0 <== NOT EXECUTED 11080: ea000002 b 11090 <rtems_rfs_rtems_initialise+0x94> <== NOT EXECUTED
}
else
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
11084: eb003152 bl 1d5d4 <__errno> <== NOT EXECUTED 11088: e3a03016 mov r3, #22 <== NOT EXECUTED 1108c: ea000010 b 110d4 <rtems_rfs_rtems_initialise+0xd8> <== NOT EXECUTED
options = strchr (options, ',');
11090: e1a00004 mov r0, r4 <== NOT EXECUTED 11094: e3a0102c mov r1, #44 ; 0x2c <== NOT EXECUTED 11098: eb003843 bl 1f1ac <strchr> <== NOT EXECUTED
if (options)
1109c: e2504000 subs r4, r0, #0 <== NOT EXECUTED 110a0: 0a000005 beq 110bc <rtems_rfs_rtems_initialise+0xc0> <== NOT EXECUTED
{
++options;
if (*options == '\0')
110a4: e5d43001 ldrb r3, [r4, #1] <== NOT EXECUTED 110a8: e3530000 cmp r3, #0 <== NOT EXECUTED 110ac: 0a000002 beq 110bc <rtems_rfs_rtems_initialise+0xc0> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
options = strchr (options, ',');
if (options)
{
++options;
110b0: e2844001 add r4, r4, #1 <== NOT EXECUTED
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
110b4: e3540000 cmp r4, #0
110b8: 1affffd5 bne 11014 <rtems_rfs_rtems_initialise+0x18>
if (*options == '\0')
options = NULL;
}
}
rtems = malloc (sizeof (rtems_rfs_rtems_private));
110bc: e3a00004 mov r0, #4 110c0: ebffd742 bl 6dd0 <malloc>
if (!rtems)
110c4: e2504000 subs r4, r0, #0
110c8: 1a000004 bne 110e0 <rtems_rfs_rtems_initialise+0xe4>
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
110cc: eb003140 bl 1d5d4 <__errno> <== NOT EXECUTED 110d0: e3a0300c mov r3, #12 <== NOT EXECUTED 110d4: e5803000 str r3, [r0] <== NOT EXECUTED 110d8: e3e00000 mvn r0, #0 <== NOT EXECUTED 110dc: ea000028 b 11184 <rtems_rfs_rtems_initialise+0x188> <== NOT EXECUTED
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
110e0: e3a03000 mov r3, #0 110e4: e5843000 str r3, [r4]
rc = rtems_rfs_mutex_create (&rtems->access);
110e8: eb002b1a bl 1bd58 <rtems_rfs_mutex_create>
if (rc > 0)
110ec: e2508000 subs r8, r0, #0
110f0: ca000005 bgt 1110c <rtems_rfs_rtems_initialise+0x110>
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
}
rc = rtems_rfs_mutex_lock (&rtems->access);
110f4: e5940000 ldr r0, [r4] 110f8: ebffffa5 bl 10f94 <rtems_rfs_mutex_lock.isra.2>
if (rc > 0)
110fc: e2508000 subs r8, r0, #0
11100: da000006 ble 11120 <rtems_rfs_rtems_initialise+0x124>
{
rtems_rfs_mutex_destroy (&rtems->access);
11104: e1a00004 mov r0, r4 <== NOT EXECUTED 11108: eb002b2a bl 1bdb8 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
free (rtems);
1110c: e1a00004 mov r0, r4 <== NOT EXECUTED 11110: ebffd5be bl 6810 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
11114: eb00312e bl 1d5d4 <__errno> <== NOT EXECUTED 11118: e5808000 str r8, [r0] <== NOT EXECUTED 1111c: eaffffed b 110d8 <rtems_rfs_rtems_initialise+0xdc> <== NOT EXECUTED
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
11120: e28d3004 add r3, sp, #4 11124: e58d3000 str r3, [sp] 11128: e1a02006 mov r2, r6 1112c: e5950038 ldr r0, [r5, #56] ; 0x38 11130: e1a01004 mov r1, r4 11134: e1a03007 mov r3, r7 11138: eb0026c3 bl 1ac4c <rtems_rfs_fs_open>
if (rc)
1113c: e2506000 subs r6, r0, #0
11140: 0a000004 beq 11158 <rtems_rfs_rtems_initialise+0x15c>
{
free (rtems);
11144: e1a00004 mov r0, r4 <== NOT EXECUTED 11148: ebffd5b0 bl 6810 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", rc);
1114c: eb003120 bl 1d5d4 <__errno> <== NOT EXECUTED 11150: e5806000 str r6, [r0] <== NOT EXECUTED 11154: eaffffdf b 110d8 <rtems_rfs_rtems_initialise+0xdc> <== NOT EXECUTED
}
mt_entry->fs_info = fs;
mt_entry->ops = &rtems_rfs_ops;
11158: e59f3038 ldr r3, [pc, #56] ; 11198 <rtems_rfs_rtems_initialise+0x19c>
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
1115c: e59d0004 ldr r0, [sp, #4]
mt_entry->ops = &rtems_rfs_ops;
11160: e585300c str r3, [r5, #12]
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
11164: e5953024 ldr r3, [r5, #36] ; 0x24 11168: e3a02001 mov r2, #1
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
1116c: e5850008 str r0, [r5, #8]
mt_entry->ops = &rtems_rfs_ops; mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
11170: e5832008 str r2, [r3, #8]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
11174: e59f2020 ldr r2, [pc, #32] ; 1119c <rtems_rfs_rtems_initialise+0x1a0> 11178: e5832010 str r2, [r3, #16]
rtems_rfs_rtems_unlock (fs);
1117c: ebfffe54 bl 10ad4 <rtems_rfs_rtems_unlock>
return 0;
11180: e1a00006 mov r0, r6
}
11184: e8bd81fc pop {r2, r3, r4, r5, r6, r7, r8, pc}
00010448 <rtems_rfs_rtems_link>:
static int
rtems_rfs_rtems_link (const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *targetloc,
const char *name,
size_t namelen)
{
10448: e92d4013 push {r0, r1, r4, lr}
1044c: e1a0c000 mov ip, r0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (targetloc);
10450: e5910014 ldr r0, [r1, #20]
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_LINK))
printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
parent, target);
rc = rtems_rfs_link (fs, name, namelen, parent, target, false);
10454: e5911008 ldr r1, [r1, #8] 10458: e58d1000 str r1, [sp] 1045c: e3a01000 mov r1, #0 10460: e58d1004 str r1, [sp, #4] 10464: e1a01002 mov r1, r2 10468: e5900008 ldr r0, [r0, #8] 1046c: e1a02003 mov r2, r3 10470: e59c3008 ldr r3, [ip, #8] 10474: eb002bef bl 1b438 <rtems_rfs_link>
if (rc)
10478: e2504000 subs r4, r0, #0
{
return rtems_rfs_rtems_error ("link: linking", rc);
}
return 0;
1047c: 01a00004 moveq r0, r4
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_LINK))
printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
parent, target);
rc = rtems_rfs_link (fs, name, namelen, parent, target, false);
if (rc)
10480: 0a000002 beq 10490 <rtems_rfs_rtems_link+0x48>
{
return rtems_rfs_rtems_error ("link: linking", rc);
10484: eb003452 bl 1d5d4 <__errno> <== NOT EXECUTED 10488: e5804000 str r4, [r0] <== NOT EXECUTED 1048c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return 0;
}
10490: e8bd801c pop {r2, r3, r4, pc}
0001c000 <rtems_rfs_rtems_lock>:
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_filesystem_default_ftruncate_directory,
.fsync_h = rtems_filesystem_default_fsync_or_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
1c000: e5903080 ldr r3, [r0, #128] ; 0x80
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
1c004: e3a01000 mov r1, #0
/**
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
1c008: e92d4010 push {r4, lr}
1c00c: e5930000 ldr r0, [r3]
1c010: e1a02001 mov r2, r1
1c014: ebffbb4a bl ad44 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
1c018: e2504000 subs r4, r0, #0
1c01c: 08bd8010 popeq {r4, pc}
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1c020: e3a00004 mov r0, #4 <== NOT EXECUTED
1c024: e3a01000 mov r1, #0 <== NOT EXECUTED
1c028: ebffd48f bl 1126c <rtems_rfs_trace> <== NOT EXECUTED
1c02c: e3500000 cmp r0, #0 <== NOT EXECUTED
1c030: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
1c034: e1a00004 mov r0, r4 <== NOT EXECUTED 1c038: ebffa970 bl 6600 <rtems_status_text> <== NOT EXECUTED 1c03c: e1a01000 mov r1, r0 <== NOT EXECUTED 1c040: e59f0004 ldr r0, [pc, #4] ; 1c04c <rtems_rfs_rtems_lock+0x4c><== NOT EXECUTED
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs); rtems_rfs_mutex_lock (&rtems->access); }
1c044: e8bd4010 pop {r4, lr} <== NOT EXECUTED
1c048: ea000a77 b 1ea2c <printf> <== NOT EXECUTED
0001091c <rtems_rfs_rtems_mknod>:
rtems_rfs_rtems_mknod (const rtems_filesystem_location_info_t *parentloc,
const char *name,
size_t namelen,
mode_t mode,
dev_t dev)
{
1091c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
10920: e1a06003 mov r6, r3
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parentloc);
10924: e5903014 ldr r3, [r0, #20]
rtems_rfs_rtems_mknod (const rtems_filesystem_location_info_t *parentloc,
const char *name,
size_t namelen,
mode_t mode,
dev_t dev)
{
10928: e24dd048 sub sp, sp, #72 ; 0x48 1092c: e1a07001 mov r7, r1 10930: e1a08002 mov r8, r2
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parentloc);
10934: e5934008 ldr r4, [r3, #8]
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parentloc);
10938: e590b008 ldr fp, [r0, #8]
rtems_rfs_rtems_mknod (const rtems_filesystem_location_info_t *parentloc,
const char *name,
size_t namelen,
mode_t mode,
dev_t dev)
{
1093c: e59da06c ldr sl, [sp, #108] ; 0x6c 10940: e59d9070 ldr r9, [sp, #112] ; 0x70
uid_t uid;
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
10944: eb000f22 bl 145d4 <geteuid>
gid = getegid ();
10948: e58d0014 str r0, [sp, #20] 1094c: eb000f1b bl 145c0 <getegid> 10950: e1a03000 mov r3, r0
uid = 0;
gid = 0;
#endif
rc = rtems_rfs_inode_create (fs, parent, name, namelen,
rtems_rfs_rtems_imode (mode),
10954: e1a00006 mov r0, r6 10958: e58d3018 str r3, [sp, #24] 1095c: eb00023e bl 1125c <rtems_rfs_rtems_imode>
#else
uid = 0;
gid = 0;
#endif
rc = rtems_rfs_inode_create (fs, parent, name, namelen,
10960: e59d3018 ldr r3, [sp, #24] 10964: e59d2014 ldr r2, [sp, #20] 10968: e58d300c str r3, [sp, #12] 1096c: e28d3044 add r3, sp, #68 ; 0x44 10970: e58d0000 str r0, [sp] 10974: e58d2008 str r2, [sp, #8] 10978: e58d3010 str r3, [sp, #16] 1097c: e1a02007 mov r2, r7 10980: e3a05001 mov r5, #1 10984: e1a00004 mov r0, r4 10988: e1a0100b mov r1, fp 1098c: e1a03008 mov r3, r8 10990: e58d5004 str r5, [sp, #4] 10994: ebfffd78 bl ff7c <rtems_rfs_inode_create>
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
10998: e2507000 subs r7, r0, #0
1099c: ca000006 bgt 109bc <rtems_rfs_rtems_mknod+0xa0>
{
return rtems_rfs_rtems_error ("mknod: inode create", rc);
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
109a0: e1a00004 mov r0, r4 109a4: e59d1044 ldr r1, [sp, #68] ; 0x44 109a8: e28d201c add r2, sp, #28 109ac: e1a03005 mov r3, r5 109b0: ebfffc1f bl fa34 <rtems_rfs_inode_open>
if (rc > 0)
109b4: e2507000 subs r7, r0, #0
109b8: da000002 ble 109c8 <rtems_rfs_rtems_mknod+0xac>
{
return rtems_rfs_rtems_error ("mknod: inode open", rc);
109bc: eb003304 bl 1d5d4 <__errno> 109c0: e5807000 str r7, [r0] 109c4: ea00001f b 10a48 <rtems_rfs_rtems_mknod+0x12c>
}
if (S_ISDIR(mode) || S_ISREG(mode))
109c8: e2066a0f and r6, r6, #61440 ; 0xf000 109cc: e3560901 cmp r6, #16384 ; 0x4000 109d0: 13560902 cmpne r6, #32768 ; 0x8000 109d4: 13a01000 movne r1, #0 109d8: 03a01001 moveq r1, #1
109dc: 0a000011 beq 10a28 <rtems_rfs_rtems_mknod+0x10c>
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
109e0: e3560a02 cmp r6, #8192 ; 0x2000 <== NOT EXECUTED 109e4: 13560a06 cmpne r6, #24576 ; 0x6000 <== NOT EXECUTED 109e8: 1a000007 bne 10a0c <rtems_rfs_rtems_mknod+0xf0> <== NOT EXECUTED
{
int major;
int minor;
rtems_filesystem_split_dev_t (dev, major, minor);
rtems_rfs_inode_set_block (&inode, 0, major);
109ec: e28d001c add r0, sp, #28 <== NOT EXECUTED 109f0: e1a0200a mov r2, sl <== NOT EXECUTED 109f4: ebfffe43 bl 10308 <rtems_rfs_inode_set_block> <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 1, minor);
109f8: e28d001c add r0, sp, #28 <== NOT EXECUTED 109fc: e1a01005 mov r1, r5 <== NOT EXECUTED 10a00: e1a02009 mov r2, r9 <== NOT EXECUTED 10a04: ebfffe3f bl 10308 <rtems_rfs_inode_set_block> <== NOT EXECUTED 10a08: ea000006 b 10a28 <rtems_rfs_rtems_mknod+0x10c> <== NOT EXECUTED
}
else
{
rtems_rfs_inode_close (fs, &inode);
10a0c: e28d101c add r1, sp, #28 <== NOT EXECUTED 10a10: e1a00004 mov r0, r4 <== NOT EXECUTED 10a14: ebfffc7b bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
10a18: eb0032ed bl 1d5d4 <__errno> <== NOT EXECUTED 10a1c: e3a03016 mov r3, #22 <== NOT EXECUTED 10a20: e5803000 str r3, [r0] <== NOT EXECUTED 10a24: ea000007 b 10a48 <rtems_rfs_rtems_mknod+0x12c> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
10a28: e1a00004 mov r0, r4 10a2c: e28d101c add r1, sp, #28 10a30: ebfffc74 bl fc08 <rtems_rfs_inode_close>
if (rc > 0)
10a34: e2504000 subs r4, r0, #0
{
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
}
return 0;
10a38: d3a00000 movle r0, #0
rtems_rfs_inode_close (fs, &inode);
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
10a3c: da000002 ble 10a4c <rtems_rfs_rtems_mknod+0x130>
{
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
10a40: eb0032e3 bl 1d5d4 <__errno> <== NOT EXECUTED 10a44: e5804000 str r4, [r0] <== NOT EXECUTED
10a48: e3e00000 mvn r0, #0
}
return 0;
}
10a4c: e28dd048 add sp, sp, #72 ; 0x48
10a50: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
000108a8 <rtems_rfs_rtems_node_type>:
* @return rtems_filesystem_node_types_t
*/
static rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (const rtems_filesystem_location_info_t* pathloc)
{
108a8: e92d4030 push {r4, r5, lr}
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
108ac: e5902014 ldr r2, [r0, #20] 108b0: e5924008 ldr r4, [r2, #8]
* @return rtems_filesystem_node_types_t
*/
static rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (const rtems_filesystem_location_info_t* pathloc)
{
108b4: e1a03000 mov r3, r0 108b8: e24dd028 sub sp, sp, #40 ; 0x28
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_filesystem_node_types_t type;
rtems_rfs_inode_handle inode;
int rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
108bc: e5931008 ldr r1, [r3, #8] 108c0: e1a00004 mov r0, r4 108c4: e1a0200d mov r2, sp 108c8: e3a03001 mov r3, #1 108cc: ebfffc58 bl fa34 <rtems_rfs_inode_open>
if (rc > 0)
108d0: e2505000 subs r5, r0, #0
108d4: da000002 ble 108e4 <rtems_rfs_rtems_node_type+0x3c>
{
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
108d8: eb00333d bl 1d5d4 <__errno> <== NOT EXECUTED 108dc: e5805000 str r5, [r0] <== NOT EXECUTED 108e0: ea000009 b 1090c <rtems_rfs_rtems_node_type+0x64> <== NOT EXECUTED
}
type = rtems_rfs_rtems_node_type_by_inode (&inode);
108e4: e1a0000d mov r0, sp 108e8: ebfffe9a bl 10358 <rtems_rfs_rtems_node_type_by_inode>
rc = rtems_rfs_inode_close (fs, &inode);
108ec: e1a0100d mov r1, sp
if (rc > 0)
{
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
}
type = rtems_rfs_rtems_node_type_by_inode (&inode);
108f0: e1a05000 mov r5, r0
rc = rtems_rfs_inode_close (fs, &inode);
108f4: e1a00004 mov r0, r4 108f8: ebfffcc2 bl fc08 <rtems_rfs_inode_close>
if (rc > 0)
108fc: e2504000 subs r4, r0, #0
10900: da000002 ble 10910 <rtems_rfs_rtems_node_type+0x68>
{
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
10904: eb003332 bl 1d5d4 <__errno> <== NOT EXECUTED 10908: e5804000 str r4, [r0] <== NOT EXECUTED 1090c: e3e05000 mvn r5, #0 <== NOT EXECUTED
}
return type;
}
10910: e1a00005 mov r0, r5
10914: e28dd028 add sp, sp, #40 ; 0x28
10918: e8bd8030 pop {r4, r5, pc}
00010564 <rtems_rfs_rtems_readlink>:
static ssize_t
rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
10564: e92d4013 push {r0, r1, r4, lr}
10568: e1a0e001 mov lr, r1
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_READLINK))
printf ("rtems-rfs-rtems: readlink: in: ino:%" PRId32 "\n", ino);
rc = rtems_rfs_symlink_read (fs, ino, buf, bufsize, &length);
1056c: e28d1004 add r1, sp, #4
static ssize_t
rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
10570: e1a03002 mov r3, r2
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
10574: e5902014 ldr r2, [r0, #20]
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_READLINK))
printf ("rtems-rfs-rtems: readlink: in: ino:%" PRId32 "\n", ino);
rc = rtems_rfs_symlink_read (fs, ino, buf, bufsize, &length);
10578: e58d1000 str r1, [sp]
static ssize_t
rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
1057c: e1a0c000 mov ip, r0
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_READLINK))
printf ("rtems-rfs-rtems: readlink: in: ino:%" PRId32 "\n", ino);
rc = rtems_rfs_symlink_read (fs, ino, buf, bufsize, &length);
10580: e59c1008 ldr r1, [ip, #8] 10584: e5920008 ldr r0, [r2, #8] 10588: e1a0200e mov r2, lr 1058c: eb002d84 bl 1bba4 <rtems_rfs_symlink_read>
if (rc)
10590: e2504000 subs r4, r0, #0
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
}
return (ssize_t) length;
10594: 059d0004 ldreq r0, [sp, #4]
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_READLINK))
printf ("rtems-rfs-rtems: readlink: in: ino:%" PRId32 "\n", ino);
rc = rtems_rfs_symlink_read (fs, ino, buf, bufsize, &length);
if (rc)
10598: 0a000002 beq 105a8 <rtems_rfs_rtems_readlink+0x44>
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
1059c: eb00340c bl 1d5d4 <__errno> <== NOT EXECUTED 105a0: e5804000 str r4, [r0] <== NOT EXECUTED 105a4: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return (ssize_t) length;
}
105a8: e8bd801c pop {r2, r3, r4, pc}
00010494 <rtems_rfs_rtems_rename>:
rtems_rfs_rtems_rename(const rtems_filesystem_location_info_t* old_parent_loc,
const rtems_filesystem_location_info_t* old_loc,
const rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name,
size_t new_name_len)
{
10494: e92d41f3 push {r0, r1, r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
10498: e1a0c002 mov ip, r2 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
1049c: e5912014 ldr r2, [r1, #20] <== NOT EXECUTED
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
doff = rtems_rfs_rtems_get_pathloc_doff (old_loc);
104a0: e2814008 add r4, r1, #8 <== NOT EXECUTED
const rtems_filesystem_location_info_t* old_loc,
const rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name,
size_t new_name_len)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
104a4: e5925008 ldr r5, [r2, #8] <== NOT EXECUTED
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
doff = rtems_rfs_rtems_get_pathloc_doff (old_loc);
104a8: e8940050 ldm r4, {r4, r6} <== NOT EXECUTED
/*
* Link to the inode before unlinking so the inode is not erased when
* unlinked.
*/
rc = rtems_rfs_link (fs, new_name, new_name_len, new_parent, ino, true);
104ac: e3a02001 mov r2, #1 <== 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);
104b0: e5907008 ldr r7, [r0, #8] <== NOT EXECUTED
/*
* Link to the inode before unlinking so the inode is not erased when
* unlinked.
*/
rc = rtems_rfs_link (fs, new_name, new_name_len, new_parent, ino, true);
104b4: e1a01003 mov r1, r3 <== NOT EXECUTED 104b8: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 104bc: e1a00005 mov r0, r5 <== NOT EXECUTED 104c0: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 104c4: e59c3008 ldr r3, [ip, #8] <== NOT EXECUTED 104c8: e58d4000 str r4, [sp] <== NOT EXECUTED 104cc: eb002bd9 bl 1b438 <rtems_rfs_link> <== NOT EXECUTED
if (rc)
104d0: e2508000 subs r8, r0, #0 <== NOT EXECUTED 104d4: 0a000002 beq 104e4 <rtems_rfs_rtems_rename+0x50> <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: linking", rc);
104d8: eb00343d bl 1d5d4 <__errno> <== NOT EXECUTED 104dc: e5808000 str r8, [r0] <== NOT EXECUTED 104e0: ea00000b b 10514 <rtems_rfs_rtems_rename+0x80> <== 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,
104e4: e3a03002 mov r3, #2 <== NOT EXECUTED 104e8: e58d3000 str r3, [sp] <== NOT EXECUTED 104ec: e1a02004 mov r2, r4 <== NOT EXECUTED 104f0: e1a00005 mov r0, r5 <== NOT EXECUTED 104f4: e1a01007 mov r1, r7 <== NOT EXECUTED 104f8: e1a03006 mov r3, r6 <== NOT EXECUTED 104fc: eb002c2f bl 1b5c0 <rtems_rfs_unlink> <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
10500: e2504000 subs r4, r0, #0 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: unlinking", rc);
}
return 0;
10504: 01a00004 moveq r0, r4 <== 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,
rtems_rfs_unlink_dir_allowed);
if (rc)
10508: 0a000002 beq 10518 <rtems_rfs_rtems_rename+0x84> <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: unlinking", rc);
1050c: eb003430 bl 1d5d4 <__errno> <== NOT EXECUTED 10510: e5804000 str r4, [r0] <== NOT EXECUTED 10514: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return 0;
}
10518: e8bd81fc pop {r2, r3, r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
000111d0 <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
111d0: e92d4010 push {r4, lr}
* @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);
111d4: e591300c ldr r3, [r1, #12] 111d8: e5d31002 ldrb r1, [r3, #2] 111dc: e5d33003 ldrb r3, [r3, #3] 111e0: e1831401 orr r1, r3, r1, lsl #8
uint16_t mode = rtems_rfs_inode_get_mode (inode); loc->handlers = NULL;
111e4: e3a03000 mov r3, #0 111e8: e5803010 str r3, [r0, #16]
if (RTEMS_RFS_S_ISDIR (mode))
111ec: e2013a0f and r3, r1, #61440 ; 0xf000 111f0: e3530901 cmp r3, #16384 ; 0x4000
loc->handlers = rtems_rfs_rtems_handlers (dir);
111f4: 059f304c ldreq r3, [pc, #76] ; 11248 <rtems_rfs_rtems_set_handlers+0x78>
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))
111f8: 0a00000b beq 1122c <rtems_rfs_rtems_set_handlers+0x5c>
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
111fc: e3530a02 cmp r3, #8192 ; 0x2000 11200: 13530a06 cmpne r3, #24576 ; 0x6000 11204: 13a04000 movne r4, #0 11208: 03a04001 moveq r4, #1
loc->handlers = rtems_rfs_rtems_handlers (device);
1120c: 059f3038 ldreq r3, [pc, #56] ; 1124c <rtems_rfs_rtems_set_handlers+0x7c>
{
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))
11210: 0a000005 beq 1122c <rtems_rfs_rtems_set_handlers+0x5c>
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
11214: e3530a0a cmp r3, #40960 ; 0xa000
loc->handlers = rtems_rfs_rtems_handlers (link);
11218: 059f3030 ldreq r3, [pc, #48] ; 11250 <rtems_rfs_rtems_set_handlers+0x80>
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))
1121c: 0a000002 beq 1122c <rtems_rfs_rtems_set_handlers+0x5c>
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
11220: e3530902 cmp r3, #32768 ; 0x8000
11224: 1a000003 bne 11238 <rtems_rfs_rtems_set_handlers+0x68>
loc->handlers = rtems_rfs_rtems_handlers (file);
11228: e59f3024 ldr r3, [pc, #36] ; 11254 <rtems_rfs_rtems_set_handlers+0x84> 1122c: e5803010 str r3, [r0, #16]
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
11230: e3a00001 mov r0, #1
11234: e8bd8010 pop {r4, pc}
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
loc->handlers = rtems_rfs_rtems_handlers (file);
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
11238: e59f0018 ldr r0, [pc, #24] ; 11258 <rtems_rfs_rtems_set_handlers+0x88><== NOT EXECUTED 1123c: eb0035fa bl 1ea2c <printf> <== NOT EXECUTED
return false;
11240: e1a00004 mov r0, r4 <== NOT EXECUTED
} return true; }
11244: e8bd8010 pop {r4, pc} <== NOT EXECUTED
000103b0 <rtems_rfs_rtems_statvfs>:
* @return int
*/
static int
rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
103b0: e92d4033 push {r0, r1, r4, r5, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
103b4: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 103b8: e5935008 ldr r5, [r3, #8] <== NOT EXECUTED
* @return int
*/
static int
rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
103bc: 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);
103c0: e28d2004 add r2, sp, #4 <== NOT EXECUTED 103c4: e1a00005 mov r0, r5 <== NOT EXECUTED 103c8: e1a0100d mov r1, sp <== NOT EXECUTED 103cc: ebfffd3f bl f8d0 <rtems_rfs_group_usage> <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
103d0: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 103d4: e5843000 str r3, [r4] <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
103d8: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED 103dc: e5932020 ldr r2, [r3, #32] <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
103e0: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
size_t inodes;
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);
103e4: e5842004 str r2, [r4, #4] <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
103e8: e5843008 str r3, [r4, #8] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
103ec: e5952004 ldr r2, [r5, #4] <== NOT EXECUTED 103f0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 103f4: e0633002 rsb r3, r3, r2 <== NOT EXECUTED 103f8: e5843010 str r3, [r4, #16] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
103fc: e5843018 str r3, [r4, #24] <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs); sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
10400: e59d2004 ldr r2, [sp, #4] <== 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);
10404: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED 10408: e5843020 str r3, [r4, #32] <== NOT EXECUTED
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
1040c: e0623003 rsb r3, r2, r3 <== NOT EXECUTED 10410: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
sb->f_favail = sb->f_ffree;
10414: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
10418: e59f3024 ldr r3, [pc, #36] ; 10444 <rtems_rfs_rtems_statvfs+0x94><== NOT EXECUTED 1041c: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
10420: e5953000 ldr r3, [r5] <== NOT EXECUTED 10424: e5843030 str r3, [r4, #48] ; 0x30 <== NOT EXECUTED
sb->f_namemax = rtems_rfs_fs_max_name (fs);
10428: e595301c ldr r3, [r5, #28] <== 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);
1042c: e3a00000 mov r0, #0 <== NOT EXECUTED 10430: e584000c str r0, [r4, #12] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
10434: e5840014 str r0, [r4, #20] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
10438: e584001c str r0, [r4, #28] <== 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);
1043c: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED
return 0;
}
10440: e8bd803c pop {r2, r3, r4, r5, pc} <== NOT EXECUTED
000105ac <rtems_rfs_rtems_symlink>:
static int
rtems_rfs_rtems_symlink (const rtems_filesystem_location_info_t* parent_loc,
const char* node_name,
size_t node_name_len,
const char* target)
{
105ac: e92d47ff push {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, sl, lr}
105b0: e1a04003 mov r4, r3
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
105b4: e5903014 ldr r3, [r0, #20]
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
105b8: e5908008 ldr r8, [r0, #8]
int rc;
rc = rtems_rfs_symlink (fs, node_name, node_name_len,
target, strlen (target),
105bc: e1a00004 mov r0, r4
rtems_rfs_rtems_symlink (const rtems_filesystem_location_info_t* parent_loc,
const char* node_name,
size_t node_name_len,
const char* target)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
105c0: e5937008 ldr r7, [r3, #8]
static int
rtems_rfs_rtems_symlink (const rtems_filesystem_location_info_t* parent_loc,
const char* node_name,
size_t node_name_len,
const char* target)
{
105c4: e1a06001 mov r6, r1 105c8: e1a05002 mov r5, r2
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
int rc;
rc = rtems_rfs_symlink (fs, node_name, node_name_len,
target, strlen (target),
105cc: eb003dea bl 1fd7c <strlen> 105d0: e1a09000 mov r9, r0
geteuid(), getegid(), parent);
105d4: eb000ffe bl 145d4 <geteuid> 105d8: e1a0a000 mov sl, r0 105dc: eb000ff7 bl 145c0 <getegid>
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
int rc;
rc = rtems_rfs_symlink (fs, node_name, node_name_len,
105e0: e1a03004 mov r3, r4
105e4: e58d0008 str r0, [sp, #8]
105e8: e1a01006 mov r1, r6
105ec: e1a00007 mov r0, r7
105f0: e1a02005 mov r2, r5
105f4: e88d0600 stm sp, {r9, sl}
105f8: e58d800c str r8, [sp, #12]
105fc: eb002ccb bl 1b930 <rtems_rfs_symlink>
target, strlen (target),
geteuid(), getegid(), parent);
if (rc)
10600: e2504000 subs r4, r0, #0
{
return rtems_rfs_rtems_error ("symlink: linking", rc);
}
return 0;
10604: 01a00004 moveq r0, r4
int rc;
rc = rtems_rfs_symlink (fs, node_name, node_name_len,
target, strlen (target),
geteuid(), getegid(), parent);
if (rc)
10608: 0a000002 beq 10618 <rtems_rfs_rtems_symlink+0x6c>
{
return rtems_rfs_rtems_error ("symlink: linking", rc);
1060c: eb0033f0 bl 1d5d4 <__errno> <== NOT EXECUTED 10610: e5804000 str r4, [r0] <== NOT EXECUTED 10614: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return 0;
}
10618: e28dd010 add sp, sp, #16
1061c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
00010ad4 <rtems_rfs_rtems_unlock>:
/**
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
10ad4: e92d4010 push {r4, lr}
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
10ad8: e5904080 ldr r4, [r0, #128] ; 0x80
rtems_rfs_buffers_release (fs);
10adc: eb002031 bl 18ba8 <rtems_rfs_buffers_release>
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
10ae0: e5940000 ldr r0, [r4] 10ae4: ebffe8dd bl ae60 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
10ae8: e2504000 subs r4, r0, #0
10aec: 08bd8010 popeq {r4, pc}
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
10af0: e3a00004 mov r0, #4 <== NOT EXECUTED
10af4: e3a01000 mov r1, #0 <== NOT EXECUTED
10af8: eb0001db bl 1126c <rtems_rfs_trace> <== NOT EXECUTED
10afc: e3500000 cmp r0, #0 <== NOT EXECUTED
10b00: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
10b04: e1a00004 mov r0, r4 <== NOT EXECUTED 10b08: ebffd6bc bl 6600 <rtems_status_text> <== NOT EXECUTED 10b0c: e1a01000 mov r1, r0 <== NOT EXECUTED 10b10: e59f0004 ldr r0, [pc, #4] ; 10b1c <rtems_rfs_rtems_unlock+0x48><== NOT EXECUTED
rtems_rfs_mutex_unlock (&rtems->access); }
10b14: e8bd4010 pop {r4, lr} <== NOT EXECUTED
10b18: ea0037c3 b 1ea2c <printf> <== NOT EXECUTED
00010620 <rtems_rfs_rtems_utime>:
static int
rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
10620: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
10624: e1a04002 mov r4, r2 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
10628: e5902014 ldr r2, [r0, #20] <== NOT EXECUTED 1062c: e5926008 ldr r6, [r2, #8] <== NOT EXECUTED
static int
rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
10630: e1a03000 mov r3, r0 <== NOT EXECUTED 10634: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED 10638: e1a05001 mov r5, r1 <== 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;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1063c: e1a00006 mov r0, r6 <== NOT EXECUTED 10640: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED 10644: e1a0200d mov r2, sp <== NOT EXECUTED 10648: e3a03001 mov r3, #1 <== NOT EXECUTED 1064c: ebfffcf8 bl fa34 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
10650: e2507000 subs r7, r0, #0 <== NOT EXECUTED 10654: 0a000002 beq 10664 <rtems_rfs_rtems_utime+0x44> <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: read inode", rc);
10658: eb0033dd bl 1d5d4 <__errno> <== NOT EXECUTED 1065c: e5807000 str r7, [r0] <== NOT EXECUTED 10660: ea000018 b 106c8 <rtems_rfs_rtems_utime+0xa8> <== 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);
10664: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 10668: e1a02c25 lsr r2, r5, #24 <== NOT EXECUTED 1066c: e5c32010 strb r2, [r3, #16] <== NOT EXECUTED 10670: e1a02825 lsr r2, r5, #16 <== NOT EXECUTED 10674: e5c32011 strb r2, [r3, #17] <== NOT EXECUTED 10678: e1a02425 lsr r2, r5, #8 <== NOT EXECUTED 1067c: e5c32012 strb r2, [r3, #18] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
10680: e3a02001 mov r2, #1 <== NOT EXECUTED 10684: e5cd2010 strb r2, [sp, #16] <== 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);
10688: e1a02c24 lsr r2, r4, #24 <== NOT EXECUTED 1068c: e5c32014 strb r2, [r3, #20] <== NOT EXECUTED 10690: e1a02824 lsr r2, r4, #16 <== NOT EXECUTED 10694: e5c32015 strb r2, [r3, #21] <== NOT EXECUTED 10698: e1a02424 lsr r2, r4, #8 <== NOT EXECUTED 1069c: e5c34017 strb r4, [r3, #23] <== 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);
106a0: e5c35013 strb r5, [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);
106a4: e5c32016 strb r2, [r3, #22] <== NOT EXECUTED
}
rtems_rfs_inode_set_atime (&inode, atime);
rtems_rfs_inode_set_mtime (&inode, mtime);
rc = rtems_rfs_inode_close (fs, &inode);
106a8: e1a00006 mov r0, r6 <== NOT EXECUTED 106ac: e1a0100d mov r1, sp <== NOT EXECUTED 106b0: ebfffd54 bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc)
106b4: e2504000 subs r4, r0, #0 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: closing inode", rc);
}
return 0;
106b8: 01a00004 moveq r0, r4 <== NOT EXECUTED
rtems_rfs_inode_set_atime (&inode, atime);
rtems_rfs_inode_set_mtime (&inode, mtime);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc)
106bc: 0a000002 beq 106cc <rtems_rfs_rtems_utime+0xac> <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: closing inode", rc);
106c0: eb0033c3 bl 1d5d4 <__errno> <== NOT EXECUTED 106c4: e5804000 str r4, [r0] <== NOT EXECUTED 106c8: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return 0;
}
106cc: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
106d0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
000184dc <rtems_rfs_scan_chain>:
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
184dc: e92d40f0 push {r4, r5, r6, r7, lr}
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
184e0: e5904008 ldr r4, [r0, #8] 184e4: e1a07000 mov r7, r0 184e8: e1a05001 mov r5, r1
rtems_rfs_buffer* buffer;
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
184ec: e3a00080 mov r0, #128 ; 0x80 184f0: e3a01000 mov r1, #0
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
184f4: e1a06002 mov r6, r2
rtems_rfs_buffer* buffer;
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
184f8: ebffe35b bl 1126c <rtems_rfs_trace> 184fc: e3500000 cmp r0, #0
18500: 0a00001e beq 18580 <rtems_rfs_scan_chain+0xa4>
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
18504: e5951000 ldr r1, [r5] <== NOT EXECUTED 18508: e1a02006 mov r2, r6 <== NOT EXECUTED 1850c: e59f0098 ldr r0, [pc, #152] ; 185ac <rtems_rfs_scan_chain+0xd0><== NOT EXECUTED 18510: eb001945 bl 1ea2c <printf> <== NOT EXECUTED 18514: ea000019 b 18580 <rtems_rfs_scan_chain+0xa4> <== NOT EXECUTED
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
18518: ebffe353 bl 1126c <rtems_rfs_trace> 1851c: e3500000 cmp r0, #0
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
18520: 159f0088 ldrne r0, [pc, #136] ; 185b0 <rtems_rfs_scan_chain+0xd4> 18524: 15941034 ldrne r1, [r4, #52] ; 0x34 18528: 1b00193f blne 1ea2c <printf>
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
1852c: e5943034 ldr r3, [r4, #52] ; 0x34 18530: e1530006 cmp r3, r6
18534: 1a000010 bne 1857c <rtems_rfs_scan_chain+0xa0>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
18538: e3a00080 mov r0, #128 ; 0x80 1853c: e3a01000 mov r1, #0 18540: ebffe349 bl 1126c <rtems_rfs_trace> 18544: e3500000 cmp r0, #0
printf (": found block=%" PRIuPTR "\n",
18548: 159f0064 ldrne r0, [pc, #100] ; 185b4 <rtems_rfs_scan_chain+0xd8> 1854c: 15941034 ldrne r1, [r4, #52] ; 0x34 18550: 1b001935 blne 1ea2c <printf>
((intptr_t)(buffer->user)));
(*count)--;
18554: e5953000 ldr r3, [r5] 18558: e2433001 sub r3, r3, #1 1855c: e5853000 str r3, [r5]
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
18560: e1a00004 mov r0, r4 18564: ebfff4f9 bl 15950 <_Chain_Extract>
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
18568: e3a03000 mov r3, #0 1856c: e5843004 str r3, [r4, #4] 18570: e5843000 str r3, [r4]
rtems_chain_extract (node);
rtems_chain_set_off_chain (node);
return buffer;
18574: e1a00004 mov r0, r4
18578: e8bd80f0 pop {r4, r5, r6, r7, pc}
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Previous(
Chain_Node *the_node
)
{
return the_node->previous;
1857c: e5944004 ldr r4, [r4, #4]
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))
18580: e1540007 cmp r4, r7
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
18584: e3a00080 mov r0, #128 ; 0x80 18588: e3a01000 mov r1, #0
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))
1858c: 1affffe1 bne 18518 <rtems_rfs_scan_chain+0x3c>
return buffer;
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
18590: ebffe335 bl 1126c <rtems_rfs_trace>
18594: e3500000 cmp r0, #0
18598: 08bd80f0 popeq {r4, r5, r6, r7, pc}
printf (": not found\n");
1859c: e59f0014 ldr r0, [pc, #20] ; 185b8 <rtems_rfs_scan_chain+0xdc><== NOT EXECUTED 185a0: eb0019b9 bl 1ec8c <puts> <== NOT EXECUTED
return NULL;
185a4: e3a00000 mov r0, #0 <== NOT EXECUTED
}
185a8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
0001b930 <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
1b930: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1b934: e1a04000 mov r4, r0
1b938: e24dd0a4 sub sp, sp, #164 ; 0xa4
1b93c: e1a07001 mov r7, r1
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
1b940: e3a00000 mov r0, #0 1b944: e3a01002 mov r1, #2
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
1b948: e1a06002 mov r6, r2 1b94c: e1a08003 mov r8, r3 1b950: e59d50c8 ldr r5, [sp, #200] ; 0xc8 1b954: e59db0d4 ldr fp, [sp, #212] ; 0xd4 1b958: e1dd9cbc ldrh r9, [sp, #204] ; 0xcc 1b95c: e1ddadb0 ldrh sl, [sp, #208] ; 0xd0
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
1b960: ebffd641 bl 1126c <rtems_rfs_trace> 1b964: e3500000 cmp r0, #0
1b968: 0a000014 beq 1b9c0 <rtems_rfs_symlink+0x90>
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
1b96c: e59f0224 ldr r0, [pc, #548] ; 1bb98 <rtems_rfs_symlink+0x268><== NOT EXECUTED 1b970: e1a0100b mov r1, fp <== NOT EXECUTED 1b974: eb000c2c bl 1ea2c <printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
1b978: e3a03000 mov r3, #0 <== NOT EXECUTED 1b97c: ea000004 b 1b994 <rtems_rfs_symlink+0x64> <== NOT EXECUTED
printf ("%c", name[c]);
1b980: e7d70003 ldrb r0, [r7, r3] <== NOT EXECUTED 1b984: e58d3014 str r3, [sp, #20] <== NOT EXECUTED 1b988: eb000c91 bl 1ebd4 <putchar> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
1b98c: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 1b990: e2833001 add r3, r3, #1 <== NOT EXECUTED 1b994: e1530006 cmp r3, r6 <== NOT EXECUTED 1b998: bafffff8 blt 1b980 <rtems_rfs_symlink+0x50> <== NOT EXECUTED
printf ("%c", name[c]);
printf (" link:");
1b99c: e59f01f8 ldr r0, [pc, #504] ; 1bb9c <rtems_rfs_symlink+0x26c><== NOT EXECUTED 1b9a0: eb000c21 bl 1ea2c <printf> <== NOT EXECUTED
for (c = 0; c < link_length; c++)
1b9a4: e3a06000 mov r6, #0 <== NOT EXECUTED 1b9a8: ea000002 b 1b9b8 <rtems_rfs_symlink+0x88> <== NOT EXECUTED
printf ("%c", link[c]);
1b9ac: e7d80006 ldrb r0, [r8, r6] <== NOT EXECUTED 1b9b0: eb000c87 bl 1ebd4 <putchar> <== NOT EXECUTED
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (" link:");
for (c = 0; c < link_length; c++)
1b9b4: e2866001 add r6, r6, #1 <== NOT EXECUTED 1b9b8: e1560005 cmp r6, r5 <== NOT EXECUTED 1b9bc: bafffffa blt 1b9ac <rtems_rfs_symlink+0x7c> <== NOT EXECUTED
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
1b9c0: e5943008 ldr r3, [r4, #8] 1b9c4: e1550003 cmp r5, r3
return ENAMETOOLONG;
1b9c8: 23a0705b movcs r7, #91 ; 0x5b
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
1b9cc: 2a00006e bcs 1bb8c <rtems_rfs_symlink+0x25c>
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
1b9d0: e1a00007 mov r0, r7
1b9d4: eb0010e8 bl 1fd7c <strlen>
1b9d8: e59f21c0 ldr r2, [pc, #448] ; 1bba0 <rtems_rfs_symlink+0x270>
1b9dc: e3a06001 mov r6, #1
1b9e0: e88d0044 stm sp, {r2, r6}
1b9e4: e28d209c add r2, sp, #156 ; 0x9c
1b9e8: e1a03000 mov r3, r0
1b9ec: e58d2010 str r2, [sp, #16]
1b9f0: e1a00004 mov r0, r4
1b9f4: e1a02007 mov r2, r7
1b9f8: e1a0100b mov r1, fp
1b9fc: e58d9008 str r9, [sp, #8]
1ba00: e58da00c str sl, [sp, #12]
1ba04: ebffd15c bl ff7c <rtems_rfs_inode_create>
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
1ba08: e2507000 subs r7, r0, #0
1ba0c: ca00005e bgt 1bb8c <rtems_rfs_symlink+0x25c>
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1ba10: e1a00004 mov r0, r4 1ba14: e59d109c ldr r1, [sp, #156] ; 0x9c 1ba18: e28d2068 add r2, sp, #104 ; 0x68 1ba1c: e1a03006 mov r3, r6 1ba20: ebffd003 bl fa34 <rtems_rfs_inode_open>
if (rc > 0)
1ba24: e2507000 subs r7, r0, #0
1ba28: ca000057 bgt 1bb8c <rtems_rfs_symlink+0x25c> /* * 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)
1ba2c: e3550013 cmp r5, #19
1ba30: 8a000013 bhi 1ba84 <rtems_rfs_symlink+0x154>
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
1ba34: e59d0074 ldr r0, [sp, #116] ; 0x74 1ba38: e3a01000 mov r1, #0 1ba3c: e3a02014 mov r2, #20 1ba40: e280001c add r0, r0, #28 1ba44: eb000b87 bl 1e868 <memset>
memcpy (inode.node->data.name, link, link_length);
1ba48: e59d0074 ldr r0, [sp, #116] ; 0x74 1ba4c: e1a02005 mov r2, r5 1ba50: e280001c add r0, r0, #28 1ba54: e1a01008 mov r1, r8 1ba58: eb000aff bl 1e65c <memcpy>
* @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);
1ba5c: e59d2074 ldr r2, [sp, #116] ; 0x74 1ba60: e3a03000 mov r3, #0 1ba64: e5c2300c strb r3, [r2, #12] 1ba68: e59d2074 ldr r2, [sp, #116] ; 0x74 1ba6c: e5c2300d strb r3, [r2, #13] 1ba70: e59d2074 ldr r2, [sp, #116] ; 0x74 1ba74: e5c2300e strb r3, [r2, #14] 1ba78: e59d2074 ldr r2, [sp, #116] ; 0x74 1ba7c: e5c2300f strb r3, [r2, #15] 1ba80: ea000034 b 1bb58 <rtems_rfs_symlink+0x228>
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);
1ba84: e1a00004 mov r0, r4 <== NOT EXECUTED 1ba88: e28d1068 add r1, sp, #104 ; 0x68 <== NOT EXECUTED 1ba8c: e28d2018 add r2, sp, #24 <== NOT EXECUTED 1ba90: ebffef80 bl 17898 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
1ba94: e2507000 subs r7, r0, #0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
1ba98: e1a00004 mov r0, r4 <== NOT EXECUTED
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
uint8_t* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
if (rc > 0)
1ba9c: ca00002a bgt 1bb4c <rtems_rfs_symlink+0x21c> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
1baa0: e28d1018 add r1, sp, #24 <== NOT EXECUTED 1baa4: e1a02006 mov r2, r6 <== NOT EXECUTED 1baa8: e28d30a0 add r3, sp, #160 ; 0xa0 <== NOT EXECUTED 1baac: ebfff0c3 bl 17dc0 <rtems_rfs_block_map_grow> <== NOT EXECUTED
if (rc > 0)
1bab0: e2507000 subs r7, r0, #0 <== NOT EXECUTED 1bab4: ca00000a bgt 1bae4 <rtems_rfs_symlink+0x1b4> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
1bab8: 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);
1babc: e1a00004 mov r0, r4 <== NOT EXECUTED 1bac0: e28d1090 add r1, sp, #144 ; 0x90 <== NOT EXECUTED 1bac4: e59d20a0 ldr r2, [sp, #160] ; 0xa0 <== NOT EXECUTED 1bac8: e1a03006 mov r3, r6 <== NOT EXECUTED 1bacc: e5cd6090 strb r6, [sp, #144] ; 0x90 <== NOT EXECUTED
handle->bnum = 0;
1bad0: e58d6094 str r6, [sp, #148] ; 0x94 <== NOT EXECUTED
handle->buffer = NULL;
1bad4: e58d6098 str r6, [sp, #152] ; 0x98 <== NOT EXECUTED 1bad8: ebfff323 bl 1876c <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
1badc: e2507000 subs r7, r0, #0 <== NOT EXECUTED 1bae0: da000003 ble 1baf4 <rtems_rfs_symlink+0x1c4> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
1bae4: e1a00004 mov r0, r4 <== NOT EXECUTED 1bae8: e28d1018 add r1, sp, #24 <== NOT EXECUTED 1baec: ebffefc2 bl 179fc <rtems_rfs_block_map_close> <== NOT EXECUTED 1baf0: ea000014 b 1bb48 <rtems_rfs_symlink+0x218> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
1baf4: e59d3098 ldr r3, [sp, #152] ; 0x98 <== NOT EXECUTED 1baf8: e593701c ldr r7, [r3, #28] <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
1bafc: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED 1bb00: e1a00007 mov r0, r7 <== NOT EXECUTED 1bb04: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 1bb08: eb000b56 bl 1e868 <memset> <== NOT EXECUTED
memcpy (data, link, link_length);
1bb0c: e1a02005 mov r2, r5 <== NOT EXECUTED 1bb10: e1a00007 mov r0, r7 <== NOT EXECUTED 1bb14: e1a01008 mov r1, r8 <== NOT EXECUTED 1bb18: eb000acf bl 1e65c <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);
1bb1c: e28d1090 add r1, sp, #144 ; 0x90 <== NOT EXECUTED 1bb20: e1a00004 mov r0, r4 <== NOT EXECUTED 1bb24: ebfff2a4 bl 185bc <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);
1bb28: e1a00004 mov r0, r4 <== NOT EXECUTED 1bb2c: e28d1018 add r1, sp, #24 <== NOT EXECUTED
handle->dirty = false;
1bb30: e5cd6090 strb r6, [sp, #144] ; 0x90 <== NOT EXECUTED
handle->bnum = 0;
1bb34: e58d6094 str r6, [sp, #148] ; 0x94 <== NOT EXECUTED
handle->buffer = NULL;
1bb38: e58d6098 str r6, [sp, #152] ; 0x98 <== NOT EXECUTED 1bb3c: ebffefae bl 179fc <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
1bb40: e2507000 subs r7, r0, #0 <== NOT EXECUTED 1bb44: da000003 ble 1bb58 <rtems_rfs_symlink+0x228> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
1bb48: e1a00004 mov r0, r4 <== NOT EXECUTED 1bb4c: e28d1068 add r1, sp, #104 ; 0x68 <== NOT EXECUTED 1bb50: ebffd02c bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
1bb54: ea00000c b 1bb8c <rtems_rfs_symlink+0x25c> <== 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);
1bb58: e59d3074 ldr r3, [sp, #116] ; 0x74
}
}
rtems_rfs_inode_set_block_offset (&inode, link_length);
1bb5c: e1a05805 lsl r5, r5, #16 1bb60: e1a02825 lsr r2, r5, #16 1bb64: e1a05c25 lsr r5, r5, #24 1bb68: e5c3500a strb r5, [r3, #10] 1bb6c: e59d3074 ldr r3, [sp, #116] ; 0x74
rc = rtems_rfs_inode_close (fs, &inode);
1bb70: e1a00004 mov r0, r4 1bb74: e5c3200b strb r2, [r3, #11] 1bb78: e28d1068 add r1, sp, #104 ; 0x68
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1bb7c: e3a03001 mov r3, #1 1bb80: e5cd3078 strb r3, [sp, #120] ; 0x78 1bb84: ebffd01f bl fc08 <rtems_rfs_inode_close> 1bb88: e1a07000 mov r7, r0
return rc;
}
1bb8c: e1a00007 mov r0, r7
1bb90: e28dd0a4 add sp, sp, #164 ; 0xa4
1bb94: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0001bba4 <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)
{
1bba4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
1bba8: e1a04000 mov r4, r0
1bbac: e24dd08c sub sp, sp, #140 ; 0x8c
1bbb0: e1a06001 mov r6, r1
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
1bbb4: e3a00000 mov r0, #0 1bbb8: e3a01004 mov r1, #4
rtems_rfs_symlink_read (rtems_rfs_file_system* fs,
rtems_rfs_ino link,
char* path,
size_t size,
size_t* length)
{
1bbbc: e1a05002 mov r5, r2 1bbc0: e1a07003 mov r7, r3 1bbc4: e59d80a8 ldr r8, [sp, #168] ; 0xa8
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
1bbc8: ebffd5a7 bl 1126c <rtems_rfs_trace> 1bbcc: e3500000 cmp r0, #0
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
1bbd0: 159f017c ldrne r0, [pc, #380] ; 1bd54 <rtems_rfs_symlink_read+0x1b0> 1bbd4: 11a01006 movne r1, r6 1bbd8: 1b000b93 blne 1ea2c <printf>
rc = rtems_rfs_inode_open (fs, link, &inode, true);
1bbdc: e1a00004 mov r0, r4 1bbe0: e1a01006 mov r1, r6 1bbe4: e28d2054 add r2, sp, #84 ; 0x54 1bbe8: e3a03001 mov r3, #1 1bbec: ebffcf90 bl fa34 <rtems_rfs_inode_open>
if (rc)
1bbf0: e250a000 subs sl, r0, #0
1bbf4: 1a000053 bne 1bd48 <rtems_rfs_symlink_read+0x1a4>
* @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);
1bbf8: e59d1060 ldr r1, [sp, #96] ; 0x60 1bbfc: e5d13002 ldrb r3, [r1, #2]
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
1bc00: e1a03403 lsl r3, r3, #8 1bc04: e2033a0f and r3, r3, #61440 ; 0xf000 1bc08: e3530a0a cmp r3, #40960 ; 0xa000
1bc0c: 0a000004 beq 1bc24 <rtems_rfs_symlink_read+0x80>
{
rtems_rfs_inode_close (fs, &inode);
1bc10: e1a00004 mov r0, r4 <== NOT EXECUTED 1bc14: e28d1054 add r1, sp, #84 ; 0x54 <== NOT EXECUTED 1bc18: ebffcffa bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED
return EINVAL;
1bc1c: e3a0a016 mov sl, #22 <== NOT EXECUTED 1bc20: ea000048 b 1bd48 <rtems_rfs_symlink_read+0x1a4> <== NOT EXECUTED
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
1bc24: e5d1300b ldrb r3, [r1, #11] 1bc28: e5d1200a ldrb r2, [r1, #10]
}
*length = rtems_rfs_inode_get_block_offset (&inode);
1bc2c: e1832402 orr r2, r3, r2, lsl #8
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
1bc30: e1520007 cmp r2, r7 1bc34: 21a02007 movcs r2, r7 1bc38: e5882000 str r2, [r8]
* @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);
1bc3c: e5d1300d ldrb r3, [r1, #13] 1bc40: e5d1000c ldrb r0, [r1, #12] 1bc44: e1a03803 lsl r3, r3, #16 1bc48: e1833c00 orr r3, r3, r0, lsl #24 1bc4c: e5d1000f ldrb r0, [r1, #15] 1bc50: e1833000 orr r3, r3, r0 1bc54: e5d1000e ldrb r0, [r1, #14]
if (size < *length)
{
*length = size;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
1bc58: e1930400 orrs r0, r3, r0, lsl #8
1bc5c: 1a000003 bne 1bc70 <rtems_rfs_symlink_read+0xcc>
{
memcpy (path, inode.node->data.name, *length);
1bc60: e1a00005 mov r0, r5 1bc64: e281101c add r1, r1, #28 1bc68: eb000a7b bl 1e65c <memcpy> 1bc6c: ea000031 b 1bd38 <rtems_rfs_symlink_read+0x194>
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);
1bc70: e1a00004 mov r0, r4 <== NOT EXECUTED 1bc74: e28d1054 add r1, sp, #84 ; 0x54 <== NOT EXECUTED 1bc78: e28d2004 add r2, sp, #4 <== NOT EXECUTED 1bc7c: ebffef05 bl 17898 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
1bc80: e250a000 subs sl, r0, #0 <== NOT EXECUTED 1bc84: ca000027 bgt 1bd28 <rtems_rfs_symlink_read+0x184> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
1bc88: e28d3088 add r3, sp, #136 ; 0x88 <== NOT EXECUTED 1bc8c: e58d3000 str r3, [sp] <== NOT EXECUTED 1bc90: e1a00004 mov r0, r4 <== NOT EXECUTED 1bc94: e28d1004 add r1, sp, #4 <== NOT EXECUTED 1bc98: e3a02000 mov r2, #0 <== NOT EXECUTED 1bc9c: e3a03000 mov r3, #0 <== NOT EXECUTED 1bca0: ebfff01f bl 17d24 <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
1bca4: e250a000 subs sl, r0, #0 <== NOT EXECUTED 1bca8: ca00000a bgt 1bcd8 <rtems_rfs_symlink_read+0x134> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
1bcac: 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);
1bcb0: e1a00004 mov r0, r4 <== NOT EXECUTED 1bcb4: e28d107c add r1, sp, #124 ; 0x7c <== NOT EXECUTED 1bcb8: e59d2088 ldr r2, [sp, #136] ; 0x88 <== NOT EXECUTED 1bcbc: e1a03006 mov r3, r6 <== NOT EXECUTED 1bcc0: e5cd607c strb r6, [sp, #124] ; 0x7c <== NOT EXECUTED
handle->bnum = 0;
1bcc4: e58d6080 str r6, [sp, #128] ; 0x80 <== NOT EXECUTED
handle->buffer = NULL;
1bcc8: e58d6084 str r6, [sp, #132] ; 0x84 <== NOT EXECUTED 1bccc: ebfff2a6 bl 1876c <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
1bcd0: e250a000 subs sl, r0, #0 <== NOT EXECUTED 1bcd4: da000003 ble 1bce8 <rtems_rfs_symlink_read+0x144> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
1bcd8: e1a00004 mov r0, r4 <== NOT EXECUTED 1bcdc: e28d1004 add r1, sp, #4 <== NOT EXECUTED 1bce0: ebffef45 bl 179fc <rtems_rfs_block_map_close> <== NOT EXECUTED 1bce4: ea00000f b 1bd28 <rtems_rfs_symlink_read+0x184> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
memcpy (path, data, *length);
1bce8: e59d3084 ldr r3, [sp, #132] ; 0x84 <== NOT EXECUTED 1bcec: e5982000 ldr r2, [r8] <== NOT EXECUTED 1bcf0: e593101c ldr r1, [r3, #28] <== NOT EXECUTED 1bcf4: e1a00005 mov r0, r5 <== NOT EXECUTED 1bcf8: eb000a57 bl 1e65c <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);
1bcfc: e28d107c add r1, sp, #124 ; 0x7c <== NOT EXECUTED 1bd00: e1a00004 mov r0, r4 <== NOT EXECUTED 1bd04: ebfff22c bl 185bc <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);
1bd08: e1a00004 mov r0, r4 <== NOT EXECUTED 1bd0c: e28d1004 add r1, sp, #4 <== NOT EXECUTED
handle->dirty = false;
1bd10: e5cd607c strb r6, [sp, #124] ; 0x7c <== NOT EXECUTED
handle->bnum = 0;
1bd14: e58d6080 str r6, [sp, #128] ; 0x80 <== NOT EXECUTED
handle->buffer = NULL;
1bd18: e58d6084 str r6, [sp, #132] ; 0x84 <== NOT EXECUTED 1bd1c: ebffef36 bl 179fc <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
1bd20: e250a000 subs sl, r0, #0 <== NOT EXECUTED 1bd24: da000003 ble 1bd38 <rtems_rfs_symlink_read+0x194> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
1bd28: e1a00004 mov r0, r4 <== NOT EXECUTED 1bd2c: e28d1054 add r1, sp, #84 ; 0x54 <== NOT EXECUTED 1bd30: ebffcfb4 bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
1bd34: ea000003 b 1bd48 <rtems_rfs_symlink_read+0x1a4> <== NOT EXECUTED
}
}
rc = rtems_rfs_inode_close (fs, &inode);
1bd38: e1a00004 mov r0, r4 1bd3c: e28d1054 add r1, sp, #84 ; 0x54 1bd40: ebffcfb0 bl fc08 <rtems_rfs_inode_close> 1bd44: e1a0a000 mov sl, r0
return rc;
}
1bd48: e1a0000a mov r0, sl
1bd4c: e28dd08c add sp, sp, #140 ; 0x8c
1bd50: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
000112b4 <rtems_rfs_trace_clear_mask>:
rtems_rfs_trace_mask
rtems_rfs_trace_clear_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
112b4: e59fc018 ldr ip, [pc, #24] ; 112d4 <rtems_rfs_trace_clear_mask+0x20><== NOT EXECUTED
112b8: e89c000c ldm ip, {r2, r3} <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
112bc: e1c20000 bic r0, r2, r0 <== NOT EXECUTED
112c0: e1c31001 bic r1, r3, r1 <== NOT EXECUTED
112c4: e88c0003 stm ip, {r0, r1} <== NOT EXECUTED
return state; }
112c8: e1a00002 mov r0, r2 <== NOT EXECUTED 112cc: e1a01003 mov r1, r3 <== NOT EXECUTED 112d0: e12fff1e bx lr <== NOT EXECUTED
00011290 <rtems_rfs_trace_set_mask>:
rtems_rfs_trace_mask
rtems_rfs_trace_set_mask (rtems_rfs_trace_mask mask)
{
rtems_rfs_trace_mask state = rtems_rfs_trace_flags;
11290: e59fc018 ldr ip, [pc, #24] ; 112b0 <rtems_rfs_trace_set_mask+0x20><== NOT EXECUTED
11294: e89c000c ldm ip, {r2, r3} <== NOT EXECUTED
rtems_rfs_trace_flags |= mask;
11298: e1800002 orr r0, r0, r2 <== NOT EXECUTED
1129c: e1811003 orr r1, r1, r3 <== NOT EXECUTED
112a0: e88c0003 stm ip, {r0, r1} <== NOT EXECUTED
return state; }
112a4: e1a00002 mov r0, r2 <== NOT EXECUTED 112a8: e1a01003 mov r1, r3 <== NOT EXECUTED 112ac: e12fff1e bx lr <== NOT EXECUTED
000112d8 <rtems_rfs_trace_shell_command>:
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
112d8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
112dc: e24dd0ac sub sp, sp, #172 ; 0xac <== NOT EXECUTED
112e0: e1a0a001 mov sl, r1 <== NOT EXECUTED
112e4: e1a0b000 mov fp, r0 <== NOT EXECUTED
const char* table[] =
112e8: e59f11a8 ldr r1, [pc, #424] ; 11498 <rtems_rfs_trace_shell_command+0x1c0><== NOT EXECUTED 112ec: e28d0010 add r0, sp, #16 <== NOT EXECUTED 112f0: e3a0209c mov r2, #156 ; 0x9c <== NOT EXECUTED 112f4: eb0034d8 bl 1e65c <memcpy> <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
112f8: e3a05001 mov r5, #1 <== NOT EXECUTED
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
112fc: e3a00000 mov r0, #0 <== NOT EXECUTED 11300: e3a01000 mov r1, #0 <== NOT EXECUTED
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
const char* table[] =
11304: e1a0900a mov r9, sl <== NOT EXECUTED
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
11308: e1a04005 mov r4, r5 <== NOT EXECUTED
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
1130c: e88d0003 stm sp, {r0, r1} <== NOT EXECUTED
"file-close",
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
11310: e58d0008 str r0, [sp, #8] <== NOT EXECUTED 11314: e58d100c str r1, [sp, #12] <== NOT EXECUTED
}
}
}
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
11318: e59f817c ldr r8, [pc, #380] ; 1149c <rtems_rfs_trace_shell_command+0x1c4><== NOT EXECUTED 1131c: e1a07005 mov r7, r5 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
11320: ea000057 b 11484 <rtems_rfs_trace_shell_command+0x1ac> <== NOT EXECUTED
{
if (argv[arg][0] == '-')
11324: e5b96004 ldr r6, [r9, #4]! <== NOT EXECUTED 11328: e5d63000 ldrb r3, [r6] <== NOT EXECUTED 1132c: e353002d cmp r3, #45 ; 0x2d <== NOT EXECUTED 11330: 1a00001a bne 113a0 <rtems_rfs_trace_shell_command+0xc8> <== NOT EXECUTED
{
switch (argv[arg][1])
11334: e5d63001 ldrb r3, [r6, #1] <== NOT EXECUTED 11338: e3530068 cmp r3, #104 ; 0x68 <== NOT EXECUTED 1133c: 0a000002 beq 1134c <rtems_rfs_trace_shell_command+0x74> <== NOT EXECUTED 11340: e353006c cmp r3, #108 ; 0x6c <== NOT EXECUTED 11344: 1a000011 bne 11390 <rtems_rfs_trace_shell_command+0xb8> <== NOT EXECUTED 11348: ea000003 b 1135c <rtems_rfs_trace_shell_command+0x84> <== NOT EXECUTED
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
1134c: e59a1000 ldr r1, [sl] <== NOT EXECUTED 11350: e59f0148 ldr r0, [pc, #328] ; 114a0 <rtems_rfs_trace_shell_command+0x1c8><== NOT EXECUTED 11354: eb0035b4 bl 1ea2c <printf> <== NOT EXECUTED 11358: ea00004b b 1148c <rtems_rfs_trace_shell_command+0x1b4> <== NOT EXECUTED
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
1135c: e59f0140 ldr r0, [pc, #320] ; 114a4 <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED 11360: e59a1000 ldr r1, [sl] <== NOT EXECUTED 11364: eb0035b0 bl 1ea2c <printf> <== NOT EXECUTED 11368: e3a04000 mov r4, #0 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
1136c: e2843010 add r3, r4, #16 <== NOT EXECUTED 11370: e1a0200d mov r2, sp <== NOT EXECUTED 11374: e59f012c ldr r0, [pc, #300] ; 114a8 <rtems_rfs_trace_shell_command+0x1d0><== NOT EXECUTED 11378: e7931002 ldr r1, [r3, r2] <== NOT EXECUTED 1137c: e2844004 add r4, r4, #4 <== NOT EXECUTED 11380: eb0035a9 bl 1ea2c <printf> <== NOT EXECUTED
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
11384: e354009c cmp r4, #156 ; 0x9c <== NOT EXECUTED 11388: 1afffff7 bne 1136c <rtems_rfs_trace_shell_command+0x94> <== NOT EXECUTED 1138c: ea00003e b 1148c <rtems_rfs_trace_shell_command+0x1b4> <== NOT EXECUTED
printf (" %s\n", table[t]);
return 0;
default:
printf ("error: unknown option\n");
11390: e59f0114 ldr r0, [pc, #276] ; 114ac <rtems_rfs_trace_shell_command+0x1d4><== NOT EXECUTED 11394: eb00363c bl 1ec8c <puts> <== NOT EXECUTED
return 1;
11398: e3a00001 mov r0, #1 <== NOT EXECUTED 1139c: ea00003b b 11490 <rtems_rfs_trace_shell_command+0x1b8> <== NOT EXECUTED
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
113a0: e59f1108 ldr r1, [pc, #264] ; 114b0 <rtems_rfs_trace_shell_command+0x1d8><== NOT EXECUTED 113a4: e1a00006 mov r0, r6 <== NOT EXECUTED 113a8: eb0037f4 bl 1f380 <strcmp> <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
113ac: e59f1100 ldr r1, [pc, #256] ; 114b4 <rtems_rfs_trace_shell_command+0x1dc><== NOT EXECUTED
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
set = true;
113b0: e3500000 cmp r0, #0 <== NOT EXECUTED
if (strcmp (argv[arg], "clear") == 0)
113b4: e1a00006 mov r0, r6 <== NOT EXECUTED
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
set = true;
113b8: 03a04001 moveq r4, #1 <== NOT EXECUTED
if (strcmp (argv[arg], "clear") == 0)
113bc: eb0037ef bl 1f380 <strcmp> <== NOT EXECUTED 113c0: e3500000 cmp r0, #0 <== NOT EXECUTED
set = false;
113c4: 01a04000 moveq r4, r0 <== NOT EXECUTED
}
else
{
if (strcmp (argv[arg], "set") == 0)
set = true;
if (strcmp (argv[arg], "clear") == 0)
113c8: 0a000023 beq 1145c <rtems_rfs_trace_shell_command+0x184> <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
113cc: e1a00006 mov r0, r6 <== NOT EXECUTED 113d0: e59f10e0 ldr r1, [pc, #224] ; 114b8 <rtems_rfs_trace_shell_command+0x1e0><== NOT EXECUTED 113d4: eb0037e9 bl 1f380 <strcmp> <== NOT EXECUTED 113d8: e3500000 cmp r0, #0 <== NOT EXECUTED 113dc: 13a05000 movne r5, #0 <== NOT EXECUTED 113e0: 1a000006 bne 11400 <rtems_rfs_trace_shell_command+0x128> <== NOT EXECUTED
{
if (set)
113e4: e3540000 cmp r4, #0 <== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
113e8: e3e00000 mvn r0, #0 <== NOT EXECUTED 113ec: e3e01000 mvn r1, #0 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
113f0: 0a000018 beq 11458 <rtems_rfs_trace_shell_command+0x180> <== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
113f4: e58d0008 str r0, [sp, #8] <== NOT EXECUTED 113f8: e58d100c str r1, [sp, #12] <== NOT EXECUTED 113fc: ea000016 b 1145c <rtems_rfs_trace_shell_command+0x184> <== NOT EXECUTED
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
11400: e28d2010 add r2, sp, #16 <== NOT EXECUTED 11404: e1a00006 mov r0, r6 <== NOT EXECUTED 11408: e7921105 ldr r1, [r2, r5, lsl #2] <== NOT EXECUTED 1140c: eb0037db bl 1f380 <strcmp> <== NOT EXECUTED 11410: e3500000 cmp r0, #0 <== NOT EXECUTED 11414: 1a00000b bne 11448 <rtems_rfs_trace_shell_command+0x170> <== NOT EXECUTED
{
if (set)
11418: e3540000 cmp r4, #0 <== NOT EXECUTED
set_value = 1ULL << t;
1141c: e3a00001 mov r0, #1 <== NOT EXECUTED 11420: e3a01000 mov r1, #0 <== NOT EXECUTED 11424: e1a02005 mov r2, r5 <== NOT EXECUTED
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
{
if (set)
11428: 0a000003 beq 1143c <rtems_rfs_trace_shell_command+0x164> <== NOT EXECUTED
set_value = 1ULL << t;
1142c: eb00675d bl 2b1a8 <__aeabi_llsl> <== NOT EXECUTED 11430: e58d0008 str r0, [sp, #8] <== NOT EXECUTED 11434: e58d100c str r1, [sp, #12] <== NOT EXECUTED 11438: ea000007 b 1145c <rtems_rfs_trace_shell_command+0x184> <== NOT EXECUTED
else
clear_value = 1ULL << t;
1143c: eb006759 bl 2b1a8 <__aeabi_llsl> <== NOT EXECUTED
11440: e88d0003 stm sp, {r0, r1} <== NOT EXECUTED
11444: ea000004 b 1145c <rtems_rfs_trace_shell_command+0x184> <== NOT EXECUTED
else
clear_value = RTEMS_RFS_TRACE_ALL;
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
11448: e2855001 add r5, r5, #1 <== NOT EXECUTED 1144c: e3550027 cmp r5, #39 ; 0x27 <== NOT EXECUTED 11450: 1affffea bne 11400 <rtems_rfs_trace_shell_command+0x128> <== NOT EXECUTED 11454: ea000000 b 1145c <rtems_rfs_trace_shell_command+0x184> <== NOT EXECUTED
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
set_value = RTEMS_RFS_TRACE_ALL;
else
clear_value = RTEMS_RFS_TRACE_ALL;
11458: e88d0003 stm sp, {r0, r1} <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
1145c: e898000c ldm r8, {r2, r3} <== NOT EXECUTED
11460: e28d1008 add r1, sp, #8 <== NOT EXECUTED
11464: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
11468: e1822000 orr r2, r2, r0 <== NOT EXECUTED
1146c: e1833001 orr r3, r3, r1 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~clear_value;
11470: e89d0003 ldm sp, {r0, r1} <== NOT EXECUTED
11474: e1c22000 bic r2, r2, r0 <== NOT EXECUTED
11478: e1c33001 bic r3, r3, r1 <== NOT EXECUTED
1147c: e888000c stm r8, {r2, r3} <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
11480: e2877001 add r7, r7, #1 <== NOT EXECUTED 11484: e157000b cmp r7, fp <== NOT EXECUTED 11488: baffffa5 blt 11324 <rtems_rfs_trace_shell_command+0x4c> <== NOT EXECUTED
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
}
}
return 0;
1148c: e3a00000 mov r0, #0 <== NOT EXECUTED
}
11490: e28dd0ac add sp, sp, #172 ; 0xac <== NOT EXECUTED
11494: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0001b5c0 <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)
{
1b5c0: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
1b5c4: e1a04000 mov r4, r0
1b5c8: e24dd050 sub sp, sp, #80 ; 0x50
1b5cc: e1a07001 mov r7, r1
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1b5d0: e3a00402 mov r0, #33554432 ; 0x2000000 1b5d4: e3a01000 mov r1, #0
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)
{
1b5d8: e1a05002 mov r5, r2 1b5dc: e1a09003 mov r9, r3 1b5e0: e59d8070 ldr r8, [sp, #112] ; 0x70
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1b5e4: ebffd720 bl 1126c <rtems_rfs_trace> 1b5e8: e3500000 cmp r0, #0
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
1b5ec: 159f0314 ldrne r0, [pc, #788] ; 1b908 <rtems_rfs_unlink+0x348> 1b5f0: 11a01007 movne r1, r7 1b5f4: 11a02005 movne r2, r5 1b5f8: 1b000d0b blne 1ea2c <printf>
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
1b5fc: e1a00004 mov r0, r4 1b600: e1a01005 mov r1, r5 1b604: e28d2028 add r2, sp, #40 ; 0x28 1b608: e3a03001 mov r3, #1 1b60c: ebffd108 bl fa34 <rtems_rfs_inode_open>
if (rc)
1b610: e250a000 subs sl, r0, #0
1b614: 1a0000b8 bne 1b8fc <rtems_rfs_unlink+0x33c>
* @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);
1b618: e59d3034 ldr r3, [sp, #52] ; 0x34 1b61c: e5d36002 ldrb r6, [r3, #2]
/*
* If a directory process the unlink mode.
*/
dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
1b620: e1a06406 lsl r6, r6, #8 1b624: e2066a0f and r6, r6, #61440 ; 0xf000 1b628: e2463901 sub r3, r6, #16384 ; 0x4000 1b62c: e2736000 rsbs r6, r3, #0 1b630: e0a66003 adc r6, r6, r3
if (dir)
1b634: e3560000 cmp r6, #0
1b638: 0a00001e beq 1b6b8 <rtems_rfs_unlink+0xf8>
{
switch (dir_mode)
1b63c: e3580000 cmp r8, #0
1b640: 0a000002 beq 1b650 <rtems_rfs_unlink+0x90>
1b644: e3580001 cmp r8, #1
1b648: 1a00001a bne 1b6b8 <rtems_rfs_unlink+0xf8>
1b64c: ea00000a b 1b67c <rtems_rfs_unlink+0xbc>
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1b650: e3a00402 mov r0, #33554432 ; 0x2000000 <== NOT EXECUTED 1b654: e3a01000 mov r1, #0 <== NOT EXECUTED 1b658: ebffd703 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1b65c: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
1b660: 159f02a4 ldrne r0, [pc, #676] ; 1b90c <rtems_rfs_unlink+0x34c><== NOT EXECUTED 1b664: 1b000d88 blne 1ec8c <puts> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
1b668: e1a00004 mov r0, r4 <== NOT EXECUTED 1b66c: e28d1028 add r1, sp, #40 ; 0x28 <== NOT EXECUTED 1b670: ebffd164 bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED
return EISDIR;
1b674: e3a0a015 mov sl, #21 <== NOT EXECUTED 1b678: ea00009f b 1b8fc <rtems_rfs_unlink+0x33c> <== NOT EXECUTED
case rtems_rfs_unlink_dir_if_empty:
rc = rtems_rfs_dir_empty (fs, &target_inode);
1b67c: e1a00004 mov r0, r4 1b680: e28d1028 add r1, sp, #40 ; 0x28 1b684: ebfff998 bl 19cec <rtems_rfs_dir_empty>
if (rc > 0)
1b688: e250a000 subs sl, r0, #0
1b68c: da000009 ble 1b6b8 <rtems_rfs_unlink+0xf8>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1b690: e3a00402 mov r0, #33554432 ; 0x2000000 1b694: e3a01000 mov r1, #0 1b698: ebffd6f3 bl 1126c <rtems_rfs_trace> 1b69c: e3500000 cmp r0, #0
1b6a0: 0a000081 beq 1b8ac <rtems_rfs_unlink+0x2ec>
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
1b6a4: e1a0000a mov r0, sl <== NOT EXECUTED 1b6a8: eb00118d bl 1fce4 <strerror> <== NOT EXECUTED 1b6ac: e1a02000 mov r2, r0 <== NOT EXECUTED 1b6b0: e59f0258 ldr r0, [pc, #600] ; 1b910 <rtems_rfs_unlink+0x350><== NOT EXECUTED 1b6b4: ea00007a b 1b8a4 <rtems_rfs_unlink+0x2e4> <== NOT EXECUTED
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
1b6b8: e1a00004 mov r0, r4 1b6bc: e1a01007 mov r1, r7 1b6c0: e1a0200d mov r2, sp 1b6c4: e3a03001 mov r3, #1 1b6c8: ebffd0d9 bl fa34 <rtems_rfs_inode_open>
if (rc)
1b6cc: e250a000 subs sl, r0, #0
1b6d0: 0a000009 beq 1b6fc <rtems_rfs_unlink+0x13c>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1b6d4: e3a00402 mov r0, #33554432 ; 0x2000000 <== NOT EXECUTED 1b6d8: e3a01000 mov r1, #0 <== NOT EXECUTED 1b6dc: ebffd6e2 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1b6e0: e3500000 cmp r0, #0 <== NOT EXECUTED 1b6e4: 0a000070 beq 1b8ac <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
1b6e8: e1a0000a mov r0, sl <== NOT EXECUTED 1b6ec: eb00117c bl 1fce4 <strerror> <== NOT EXECUTED 1b6f0: e1a02000 mov r2, r0 <== NOT EXECUTED 1b6f4: e59f0218 ldr r0, [pc, #536] ; 1b914 <rtems_rfs_unlink+0x354><== NOT EXECUTED 1b6f8: ea000069 b 1b8a4 <rtems_rfs_unlink+0x2e4> <== 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);
1b6fc: e1a00004 mov r0, r4 1b700: e1a0100d mov r1, sp 1b704: e1a02005 mov r2, r5 1b708: e1a03009 mov r3, r9 1b70c: ebfff7b8 bl 195f4 <rtems_rfs_dir_del_entry>
if (rc > 0)
1b710: e250a000 subs sl, r0, #0
1b714: da000009 ble 1b740 <rtems_rfs_unlink+0x180>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1b718: e3a00402 mov r0, #33554432 ; 0x2000000 <== NOT EXECUTED 1b71c: e3a01000 mov r1, #0 <== NOT EXECUTED 1b720: ebffd6d1 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1b724: e3500000 cmp r0, #0 <== NOT EXECUTED 1b728: 0a00004b beq 1b85c <rtems_rfs_unlink+0x29c> <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
1b72c: e1a0000a mov r0, sl <== NOT EXECUTED 1b730: eb00116b bl 1fce4 <strerror> <== NOT EXECUTED 1b734: e1a02000 mov r2, r0 <== NOT EXECUTED 1b738: e59f01d8 ldr r0, [pc, #472] ; 1b918 <rtems_rfs_unlink+0x358><== NOT EXECUTED 1b73c: ea000044 b 1b854 <rtems_rfs_unlink+0x294> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode);
1b740: e28d0028 add r0, sp, #40 ; 0x28 1b744: ebffff32 bl 1b414 <rtems_rfs_inode_get_links>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1b748: e3a01000 mov r1, #0
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode);
1b74c: e1a07000 mov r7, r0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1b750: e3a00402 mov r0, #33554432 ; 0x2000000 1b754: ebffd6c4 bl 1126c <rtems_rfs_trace> 1b758: e3500000 cmp r0, #0
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
1b75c: 159f01b8 ldrne r0, [pc, #440] ; 1b91c <rtems_rfs_unlink+0x35c> 1b760: 11a01005 movne r1, r5 1b764: 11a02007 movne r2, r7 1b768: 1b000caf blne 1ea2c <printf>
if (links > 1)
1b76c: e3570001 cmp r7, #1
1b770: 9a00000a bls 1b7a0 <rtems_rfs_unlink+0x1e0>
{
links--;
1b774: e2477001 sub r7, r7, #1
* @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);
1b778: e59d3034 ldr r3, [sp, #52] ; 0x34 1b77c: e1a07807 lsl r7, r7, #16 1b780: e1a02827 lsr r2, r7, #16 1b784: e1a07c27 lsr r7, r7, #24 1b788: e5c37000 strb r7, [r3] 1b78c: e59d3034 ldr r3, [sp, #52] ; 0x34 1b790: e5c32001 strb r2, [r3, #1]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1b794: e3a03001 mov r3, #1 1b798: e5cd3038 strb r3, [sp, #56] ; 0x38 1b79c: ea00001d b 1b818 <rtems_rfs_unlink+0x258>
else
{
/*
* Erasing the inode releases all blocks attached to it.
*/
rc = rtems_rfs_inode_delete (fs, &target_inode);
1b7a0: e1a00004 mov r0, r4 1b7a4: e28d1028 add r1, sp, #40 ; 0x28 1b7a8: ebffd136 bl fc88 <rtems_rfs_inode_delete>
if (rc > 0)
1b7ac: e250a000 subs sl, r0, #0
1b7b0: da000009 ble 1b7dc <rtems_rfs_unlink+0x21c>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1b7b4: e3a00402 mov r0, #33554432 ; 0x2000000 <== NOT EXECUTED 1b7b8: e3a01000 mov r1, #0 <== NOT EXECUTED 1b7bc: ebffd6aa bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1b7c0: e3500000 cmp r0, #0 <== NOT EXECUTED 1b7c4: 0a000024 beq 1b85c <rtems_rfs_unlink+0x29c> <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
1b7c8: e1a0000a mov r0, sl <== NOT EXECUTED 1b7cc: eb001144 bl 1fce4 <strerror> <== NOT EXECUTED 1b7d0: e1a02000 mov r2, r0 <== NOT EXECUTED 1b7d4: e59f0144 ldr r0, [pc, #324] ; 1b920 <rtems_rfs_unlink+0x360><== NOT EXECUTED 1b7d8: ea00001d b 1b854 <rtems_rfs_unlink+0x294> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
if (dir)
1b7dc: e3560000 cmp r6, #0
1b7e0: 0a00000c beq 1b818 <rtems_rfs_unlink+0x258>
{
links = rtems_rfs_inode_get_links (&parent_inode);
1b7e4: e1a0000d mov r0, sp 1b7e8: ebffff09 bl 1b414 <rtems_rfs_inode_get_links>
if (links > 1)
1b7ec: e3500001 cmp r0, #1
links--;
1b7f0: 82400001 subhi r0, r0, #1 1b7f4: 81a00800 lslhi r0, r0, #16
* @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);
1b7f8: e59d300c ldr r3, [sp, #12] 1b7fc: 81a00820 lsrhi r0, r0, #16 1b800: e1a02420 lsr r2, r0, #8 1b804: e5c32000 strb r2, [r3] 1b808: e59d300c ldr r3, [sp, #12] 1b80c: e5c30001 strb r0, [r3, #1]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1b810: e3a03001 mov r3, #1 1b814: e5cd3010 strb r3, [sp, #16]
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
1b818: e3a01001 mov r1, #1 1b81c: e1a0000d mov r0, sp 1b820: e1a02001 mov r2, r1 1b824: ebffd14d bl fd60 <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
1b828: e250a000 subs sl, r0, #0
1b82c: da00000e ble 1b86c <rtems_rfs_unlink+0x2ac>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1b830: e3a00402 mov r0, #33554432 ; 0x2000000 <== NOT EXECUTED 1b834: e3a01000 mov r1, #0 <== NOT EXECUTED 1b838: ebffd68b bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1b83c: e3500000 cmp r0, #0 <== NOT EXECUTED 1b840: 0a000005 beq 1b85c <rtems_rfs_unlink+0x29c> <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
1b844: e1a0000a mov r0, sl <== NOT EXECUTED 1b848: eb001125 bl 1fce4 <strerror> <== NOT EXECUTED 1b84c: e1a02000 mov r2, r0 <== NOT EXECUTED 1b850: e59f00cc ldr r0, [pc, #204] ; 1b924 <rtems_rfs_unlink+0x364><== NOT EXECUTED 1b854: e1a0100a mov r1, sl <== NOT EXECUTED 1b858: eb000c73 bl 1ea2c <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
1b85c: e1a00004 mov r0, r4 <== NOT EXECUTED 1b860: e1a0100d mov r1, sp <== NOT EXECUTED 1b864: ebffd0e7 bl fc08 <rtems_rfs_inode_close> <== NOT EXECUTED 1b868: ea00000f b 1b8ac <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
1b86c: e1a00004 mov r0, r4 1b870: e1a0100d mov r1, sp 1b874: ebffd0e3 bl fc08 <rtems_rfs_inode_close>
if (rc > 0)
1b878: e250a000 subs sl, r0, #0
1b87c: da00000e ble 1b8bc <rtems_rfs_unlink+0x2fc>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1b880: e3a00402 mov r0, #33554432 ; 0x2000000 <== NOT EXECUTED 1b884: e3a01000 mov r1, #0 <== NOT EXECUTED 1b888: ebffd677 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1b88c: e3500000 cmp r0, #0 <== NOT EXECUTED 1b890: 0a000005 beq 1b8ac <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
1b894: e1a0000a mov r0, sl <== NOT EXECUTED 1b898: eb001111 bl 1fce4 <strerror> <== NOT EXECUTED 1b89c: e1a02000 mov r2, r0 <== NOT EXECUTED 1b8a0: e59f0080 ldr r0, [pc, #128] ; 1b928 <rtems_rfs_unlink+0x368><== NOT EXECUTED 1b8a4: e1a0100a mov r1, sl <== NOT EXECUTED 1b8a8: eb000c5f bl 1ea2c <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
1b8ac: e1a00004 mov r0, r4 1b8b0: e28d1028 add r1, sp, #40 ; 0x28 1b8b4: ebffd0d3 bl fc08 <rtems_rfs_inode_close>
return rc;
1b8b8: ea00000f b 1b8fc <rtems_rfs_unlink+0x33c>
}
rc = rtems_rfs_inode_close (fs, &target_inode);
1b8bc: e1a00004 mov r0, r4 1b8c0: e28d1028 add r1, sp, #40 ; 0x28 1b8c4: ebffd0cf bl fc08 <rtems_rfs_inode_close>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1b8c8: e250a000 subs sl, r0, #0
1b8cc: da00000a ble 1b8fc <rtems_rfs_unlink+0x33c>
1b8d0: e3a00402 mov r0, #33554432 ; 0x2000000 <== NOT EXECUTED 1b8d4: e3a01000 mov r1, #0 <== NOT EXECUTED 1b8d8: ebffd663 bl 1126c <rtems_rfs_trace> <== NOT EXECUTED 1b8dc: e3500000 cmp r0, #0 <== NOT EXECUTED 1b8e0: 0a000005 beq 1b8fc <rtems_rfs_unlink+0x33c> <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
1b8e4: e1a0000a mov r0, sl <== NOT EXECUTED 1b8e8: eb0010fd bl 1fce4 <strerror> <== NOT EXECUTED 1b8ec: e1a0100a mov r1, sl <== NOT EXECUTED 1b8f0: e1a02000 mov r2, r0 <== NOT EXECUTED 1b8f4: e59f0030 ldr r0, [pc, #48] ; 1b92c <rtems_rfs_unlink+0x36c><== NOT EXECUTED 1b8f8: eb000c4b bl 1ea2c <printf> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
1b8fc: e1a0000a mov r0, sl
1b900: e28dd050 add sp, sp, #80 ; 0x50
1b904: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
0001d8b0 <rtems_shell_rfs_format>:
int
rtems_shell_rfs_format (int argc, char* argv[])
{
1d8b0: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
1d8b4: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
1d8b8: e1a07000 mov r7, r0 <== NOT EXECUTED
1d8bc: 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));
1d8c0: e1a0000d mov r0, sp <== NOT EXECUTED 1d8c4: e3a01000 mov r1, #0 <== NOT EXECUTED 1d8c8: e3a02018 mov r2, #24 <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
1d8cc: e3a04001 mov r4, #1 <== NOT EXECUTED
{
rtems_rfs_format_config config;
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
1d8d0: eb005d42 bl 34de0 <memset> <== NOT EXECUTED
int
rtems_shell_rfs_format (int argc, char* argv[])
{
rtems_rfs_format_config config;
const char* driver = NULL;
1d8d4: e3a05000 mov r5, #0 <== NOT EXECUTED
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
{
case 'v':
config.verbose = true;
1d8d8: 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++)
1d8dc: ea000048 b 1da04 <rtems_shell_rfs_format+0x154> <== NOT EXECUTED
{
if (argv[arg][0] == '-')
1d8e0: e7961104 ldr r1, [r6, r4, lsl #2] <== NOT EXECUTED 1d8e4: e5d13000 ldrb r3, [r1] <== NOT EXECUTED 1d8e8: e353002d cmp r3, #45 ; 0x2d <== NOT EXECUTED 1d8ec: 1a00003d bne 1d9e8 <rtems_shell_rfs_format+0x138> <== NOT EXECUTED
{
switch (argv[arg][1])
1d8f0: e5d13001 ldrb r3, [r1, #1] <== NOT EXECUTED 1d8f4: e3530069 cmp r3, #105 ; 0x69 <== NOT EXECUTED 1d8f8: 0a000022 beq 1d988 <rtems_shell_rfs_format+0xd8> <== NOT EXECUTED 1d8fc: 8a000004 bhi 1d914 <rtems_shell_rfs_format+0x64> <== NOT EXECUTED 1d900: e3530049 cmp r3, #73 ; 0x49 <== NOT EXECUTED 1d904: 0a000029 beq 1d9b0 <rtems_shell_rfs_format+0x100> <== NOT EXECUTED 1d908: e3530062 cmp r3, #98 ; 0x62 <== NOT EXECUTED 1d90c: 1a000033 bne 1d9e0 <rtems_shell_rfs_format+0x130> <== NOT EXECUTED 1d910: ea000012 b 1d960 <rtems_shell_rfs_format+0xb0> <== NOT EXECUTED 1d914: e3530073 cmp r3, #115 ; 0x73 <== NOT EXECUTED 1d918: 0a000006 beq 1d938 <rtems_shell_rfs_format+0x88> <== NOT EXECUTED 1d91c: e3530076 cmp r3, #118 ; 0x76 <== NOT EXECUTED 1d920: 0a000002 beq 1d930 <rtems_shell_rfs_format+0x80> <== NOT EXECUTED 1d924: e353006f cmp r3, #111 ; 0x6f <== NOT EXECUTED 1d928: 1a00002c bne 1d9e0 <rtems_shell_rfs_format+0x130> <== NOT EXECUTED 1d92c: ea000021 b 1d9b8 <rtems_shell_rfs_format+0x108> <== NOT EXECUTED
{
case 'v':
config.verbose = true;
1d930: e5cd8015 strb r8, [sp, #21] <== NOT EXECUTED
break;
1d934: ea000031 b 1da00 <rtems_shell_rfs_format+0x150> <== NOT EXECUTED
case 's':
arg++;
1d938: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (arg >= argc)
1d93c: e1540007 cmp r4, r7 <== NOT EXECUTED
{
printf ("error: block size needs an argument\n");
1d940: a59f0118 ldrge r0, [pc, #280] ; 1da60 <rtems_shell_rfs_format+0x1b0><== NOT EXECUTED 1d944: aa000033 bge 1da18 <rtems_shell_rfs_format+0x168> <== NOT EXECUTED
return 1;
}
config.block_size = strtoul (argv[arg], 0, 0);
1d948: e3a01000 mov r1, #0 <== NOT EXECUTED 1d94c: e7960104 ldr r0, [r6, r4, lsl #2] <== NOT EXECUTED 1d950: e1a02001 mov r2, r1 <== NOT EXECUTED 1d954: eb00715d bl 39ed0 <strtoul> <== NOT EXECUTED 1d958: e58d0000 str r0, [sp] <== NOT EXECUTED
break;
1d95c: ea000027 b 1da00 <rtems_shell_rfs_format+0x150> <== NOT EXECUTED
case 'b':
arg++;
1d960: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (arg >= argc)
1d964: e1540007 cmp r4, r7 <== NOT EXECUTED
{
printf ("error: group block count needs an argument\n");
1d968: a59f00f4 ldrge r0, [pc, #244] ; 1da64 <rtems_shell_rfs_format+0x1b4><== NOT EXECUTED 1d96c: aa000029 bge 1da18 <rtems_shell_rfs_format+0x168> <== NOT EXECUTED
return 1;
}
config.group_blocks = strtoul (argv[arg], 0, 0);
1d970: e3a01000 mov r1, #0 <== NOT EXECUTED 1d974: e7960104 ldr r0, [r6, r4, lsl #2] <== NOT EXECUTED 1d978: e1a02001 mov r2, r1 <== NOT EXECUTED 1d97c: eb007153 bl 39ed0 <strtoul> <== NOT EXECUTED 1d980: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
break;
1d984: ea00001d b 1da00 <rtems_shell_rfs_format+0x150> <== NOT EXECUTED
case 'i':
arg++;
1d988: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (arg >= argc)
1d98c: e1540007 cmp r4, r7 <== NOT EXECUTED
{
printf ("error: group inode count needs an argument\n");
1d990: a59f00d0 ldrge r0, [pc, #208] ; 1da68 <rtems_shell_rfs_format+0x1b8><== NOT EXECUTED 1d994: aa00001f bge 1da18 <rtems_shell_rfs_format+0x168> <== NOT EXECUTED
return 1;
}
config.group_inodes = strtoul (argv[arg], 0, 0);
1d998: e3a01000 mov r1, #0 <== NOT EXECUTED 1d99c: e7960104 ldr r0, [r6, r4, lsl #2] <== NOT EXECUTED 1d9a0: e1a02001 mov r2, r1 <== NOT EXECUTED 1d9a4: eb007149 bl 39ed0 <strtoul> <== NOT EXECUTED 1d9a8: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
break;
1d9ac: ea000013 b 1da00 <rtems_shell_rfs_format+0x150> <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
1d9b0: e5cd8014 strb r8, [sp, #20] <== NOT EXECUTED
break;
1d9b4: ea000011 b 1da00 <rtems_shell_rfs_format+0x150> <== NOT EXECUTED
case 'o':
arg++;
1d9b8: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (arg >= argc)
1d9bc: e1540007 cmp r4, r7 <== NOT EXECUTED
{
printf ("error: inode percentage overhead needs an argument\n");
1d9c0: a59f00a4 ldrge r0, [pc, #164] ; 1da6c <rtems_shell_rfs_format+0x1bc><== NOT EXECUTED 1d9c4: aa000013 bge 1da18 <rtems_shell_rfs_format+0x168> <== NOT EXECUTED
return 1;
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
1d9c8: e3a01000 mov r1, #0 <== NOT EXECUTED 1d9cc: e7960104 ldr r0, [r6, r4, lsl #2] <== NOT EXECUTED 1d9d0: e1a02001 mov r2, r1 <== NOT EXECUTED 1d9d4: eb00713d bl 39ed0 <strtoul> <== NOT EXECUTED 1d9d8: e58d000c str r0, [sp, #12] <== NOT EXECUTED
break;
1d9dc: ea000007 b 1da00 <rtems_shell_rfs_format+0x150> <== NOT EXECUTED
default:
printf ("error: invalid option: %s\n", argv[arg]);
1d9e0: e59f0088 ldr r0, [pc, #136] ; 1da70 <rtems_shell_rfs_format+0x1c0><== NOT EXECUTED 1d9e4: ea000002 b 1d9f4 <rtems_shell_rfs_format+0x144> <== NOT EXECUTED
return 1;
}
}
else
{
if (!driver)
1d9e8: e3550000 cmp r5, #0 <== NOT EXECUTED 1d9ec: 0a000002 beq 1d9fc <rtems_shell_rfs_format+0x14c> <== NOT EXECUTED
driver = argv[arg];
else
{
printf ("error: only one driver name allowed: %s\n", argv[arg]);
1d9f0: e59f007c ldr r0, [pc, #124] ; 1da74 <rtems_shell_rfs_format+0x1c4><== NOT EXECUTED 1d9f4: eb006167 bl 35f98 <printf> <== NOT EXECUTED 1d9f8: ea000015 b 1da54 <rtems_shell_rfs_format+0x1a4> <== NOT EXECUTED
return 1;
}
}
else
{
if (!driver)
1d9fc: e1a05001 mov r5, r1 <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
1da00: e2844001 add r4, r4, #1 <== NOT EXECUTED 1da04: e1540007 cmp r4, r7 <== NOT EXECUTED 1da08: baffffb4 blt 1d8e0 <rtems_shell_rfs_format+0x30> <== NOT EXECUTED
return 1;
}
}
}
if (!driver) {
1da0c: e3550000 cmp r5, #0 <== NOT EXECUTED 1da10: 1a000002 bne 1da20 <rtems_shell_rfs_format+0x170> <== NOT EXECUTED
printf ("error: no driver name provided\n");
1da14: e59f005c ldr r0, [pc, #92] ; 1da78 <rtems_shell_rfs_format+0x1c8><== NOT EXECUTED 1da18: eb0061f6 bl 361f8 <puts> <== NOT EXECUTED 1da1c: ea00000c b 1da54 <rtems_shell_rfs_format+0x1a4> <== NOT EXECUTED
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
1da20: e1a00005 mov r0, r5 <== NOT EXECUTED 1da24: e1a0100d mov r1, sp <== NOT EXECUTED 1da28: eb003001 bl 29a34 <rtems_rfs_format> <== NOT EXECUTED 1da2c: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("error: format of %s failed: %s\n",
driver, strerror (errno));
return 1;
}
return 0;
1da30: a3a00000 movge r0, #0 <== NOT EXECUTED
if (!driver) {
printf ("error: no driver name provided\n");
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
1da34: aa000007 bge 1da58 <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
{
printf ("error: format of %s failed: %s\n",
driver, strerror (errno));
1da38: eb004fa3 bl 318cc <__errno> <== NOT EXECUTED
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
{
printf ("error: format of %s failed: %s\n",
1da3c: e5900000 ldr r0, [r0] <== NOT EXECUTED 1da40: eb006af2 bl 38610 <strerror> <== NOT EXECUTED 1da44: e1a01005 mov r1, r5 <== NOT EXECUTED 1da48: e1a02000 mov r2, r0 <== NOT EXECUTED 1da4c: e59f0028 ldr r0, [pc, #40] ; 1da7c <rtems_shell_rfs_format+0x1cc><== NOT EXECUTED 1da50: eb006150 bl 35f98 <printf> <== NOT EXECUTED
driver, strerror (errno));
return 1;
1da54: e3a00001 mov r0, #1 <== NOT EXECUTED
}
return 0;
}
1da58: e28dd018 add sp, sp, #24 <== NOT EXECUTED
1da5c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
0000d070 <rtems_sparse_disk_register>:
uint32_t media_block_size,
rtems_blkdev_bnum blocks_with_buffer,
rtems_blkdev_bnum media_block_count,
uint8_t fill_pattern,
rtems_sparse_disk_delete_handler sparse_disk_delete )
{
d070: e92d4ff3 push {r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr}
d074: e59d902c ldr r9, [sp, #44] ; 0x2c
rtems_status_code sc;
if ( blocks_with_buffer <= media_block_count ) {
d078: e1530009 cmp r3, r9
uint32_t media_block_size,
rtems_blkdev_bnum blocks_with_buffer,
rtems_blkdev_bnum media_block_count,
uint8_t fill_pattern,
rtems_sparse_disk_delete_handler sparse_disk_delete )
{
d07c: e1a0c000 mov ip, r0
d080: e1a04001 mov r4, r1
d084: e1a06002 mov r6, r2
d088: e1a05003 mov r5, r3
d08c: e59db034 ldr fp, [sp, #52] ; 0x34
d090: e5dd8030 ldrb r8, [sp, #48] ; 0x30
sparse_disk_ioctl,
sparse_disk
);
}
} else {
sc = RTEMS_INVALID_NUMBER;
d094: 83a0000a movhi r0, #10
uint8_t fill_pattern,
rtems_sparse_disk_delete_handler sparse_disk_delete )
{
rtems_status_code sc;
if ( blocks_with_buffer <= media_block_count ) {
d098: 8a00002d bhi d154 <rtems_sparse_disk_register+0xe4>
const uint8_t fill_pattern )
{
rtems_status_code sc;
rtems_blkdev_bnum i;
if ( NULL == sd )
d09c: e3510000 cmp r1, #0
d0a0: 0a00002a beq d150 <rtems_sparse_disk_register+0xe0>
return RTEMS_INVALID_ADDRESS;
uint8_t *data = (uint8_t *) sd;
size_t const key_table_size = blocks_with_buffer
d0a4: e1a07183 lsl r7, r3, #3
* sizeof( rtems_sparse_disk_key );
size_t const data_size = blocks_with_buffer * media_block_size;
memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );
d0a8: e287a01c add sl, r7, #28
d0ac: e1a00001 mov r0, r1
d0b0: e1a0200a mov r2, sl
d0b4: e3a01000 mov r1, #0
d0b8: e58dc004 str ip, [sp, #4]
d0bc: eb0030c6 bl 193dc <memset>
sd->fill_pattern = fill_pattern;
memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
d0c0: e1a01008 mov r1, r8
d0c4: e0020596 mul r2, r6, r5
* sizeof( rtems_sparse_disk_key );
size_t const data_size = blocks_with_buffer * media_block_size;
memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );
sd->fill_pattern = fill_pattern;
d0c8: e5c48014 strb r8, [r4, #20]
memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
d0cc: e084000a add r0, r4, sl
d0d0: eb0030c1 bl 193dc <memset>
sd->fill_pattern,
data_size );
sd->delete_handler = sparse_disk_delete;
d0d4: e584b010 str fp, [r4, #16]
sc = rtems_semaphore_create(
d0d8: e59f007c ldr r0, [pc, #124] ; d15c <rtems_sparse_disk_register+0xec>
d0dc: e3a01001 mov r1, #1
d0e0: e3a02054 mov r2, #84 ; 0x54
d0e4: e3a03000 mov r3, #0
d0e8: e58d4000 str r4, [sp]
d0ec: ebffeb54 bl 7e44 <rtems_semaphore_create>
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY,
0,
&sd->mutex
);
if ( sc != RTEMS_SUCCESSFUL ) {
d0f0: e3500000 cmp r0, #0
d0f4: e59dc004 ldr ip, [sp, #4]
d0f8: 1a000015 bne d154 <rtems_sparse_disk_register+0xe4>
return sc;
}
data += sizeof( rtems_sparse_disk );
d0fc: e284301c add r3, r4, #28
sd->blocks_with_buffer = blocks_with_buffer;
sd->key_table = (rtems_sparse_disk_key *) data;
d100: e5843018 str r3, [r4, #24]
data += key_table_size;
d104: e0837007 add r7, r3, r7
return sc;
}
data += sizeof( rtems_sparse_disk );
sd->blocks_with_buffer = blocks_with_buffer;
d108: e5845004 str r5, [r4, #4]
sd->key_table = (rtems_sparse_disk_key *) data;
data += key_table_size;
d10c: e1a03004 mov r3, r4
d110: ea000002 b d120 <rtems_sparse_disk_register+0xb0>
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
sd->key_table[i].data = data;
d114: e5837018 str r7, [r3, #24]
sd->blocks_with_buffer = blocks_with_buffer;
sd->key_table = (rtems_sparse_disk_key *) data;
data += key_table_size;
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
d118: e2800001 add r0, r0, #1
d11c: e0877006 add r7, r7, r6
d120: e1500005 cmp r0, r5
d124: e2833008 add r3, r3, #8
d128: 1afffff9 bne d114 <rtems_sparse_disk_register+0xa4>
sparse_disk_delete,
fill_pattern
);
if ( RTEMS_SUCCESSFUL == sc ) {
sc = rtems_blkdev_create(
d12c: e59f302c ldr r3, [pc, #44] ; d160 <rtems_sparse_disk_register+0xf0>
d130: e1a0000c mov r0, ip
d134: e1a01006 mov r1, r6
d138: e1a02009 mov r2, r9
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
sd->key_table[i].data = data;
}
sd->media_block_size = media_block_size;
d13c: e584600c str r6, [r4, #12]
sparse_disk_delete,
fill_pattern
);
if ( RTEMS_SUCCESSFUL == sc ) {
sc = rtems_blkdev_create(
d140: e58d402c str r4, [sp, #44] ; 0x2c
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
d144: e28dd008 add sp, sp, #8
d148: e8bd4ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, lr}
sparse_disk_delete,
fill_pattern
);
if ( RTEMS_SUCCESSFUL == sc ) {
sc = rtems_blkdev_create(
d14c: ea0009ed b f908 <rtems_blkdev_create>
{
rtems_status_code sc;
rtems_blkdev_bnum i;
if ( NULL == sd )
return RTEMS_INVALID_ADDRESS;
d150: e3a00009 mov r0, #9 <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
d154: e28dd008 add sp, sp, #8 <== NOT EXECUTED
d158: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0001f174 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
1f174: e92d4810 push {r4, fp, lr}
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
1f178: e59f3078 ldr r3, [pc, #120] ; 1f1f8 <rtems_stack_checker_is_blown+0x84> 1f17c: e5933008 ldr r3, [r3, #8]
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
1f180: e59300b8 ldr r0, [r3, #184] ; 0xb8
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
1f184: e28db008 add fp, sp, #8
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
1f188: e15b0000 cmp fp, r0
return false;
1f18c: 33a04000 movcc r4, #0
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
1f190: 3a000004 bcc 1f1a8 <rtems_stack_checker_is_blown+0x34>
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
1f194: e59340b4 ldr r4, [r3, #180] ; 0xb4 1f198: e0804004 add r4, r0, r4
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
1f19c: e15b0004 cmp fp, r4 1f1a0: 83a04000 movhi r4, #0 1f1a4: 93a04001 movls r4, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
1f1a8: e59f304c ldr r3, [pc, #76] ; 1f1fc <rtems_stack_checker_is_blown+0x88> 1f1ac: e5933008 ldr r3, [r3, #8] 1f1b0: e3530000 cmp r3, #0
*/
bool rtems_stack_checker_is_blown( void )
{
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
bool sp_ok;
bool pattern_ok = true;
1f1b4: 03a01001 moveq r1, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
1f1b8: 0a000005 beq 1f1d4 <rtems_stack_checker_is_blown+0x60>
pattern_ok = (!memcmp(
1f1bc: e59f103c ldr r1, [pc, #60] ; 1f200 <rtems_stack_checker_is_blown+0x8c> 1f1c0: e2800008 add r0, r0, #8 1f1c4: e3a02010 mov r2, #16 1f1c8: eb005654 bl 34b20 <memcmp> 1f1cc: e2701001 rsbs r1, r0, #1 1f1d0: 33a01000 movcc r1, #0
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
1f1d4: e3540000 cmp r4, #0
1f1d8: 0a000001 beq 1f1e4 <rtems_stack_checker_is_blown+0x70>
1f1dc: e3510000 cmp r1, #0
1f1e0: 1a000002 bne 1f1f0 <rtems_stack_checker_is_blown+0x7c>
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
1f1e4: e59f300c ldr r3, [pc, #12] ; 1f1f8 <rtems_stack_checker_is_blown+0x84><== NOT EXECUTED 1f1e8: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 1f1ec: ebffff9c bl 1f064 <Stack_check_report_blown_task> <== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
1f1f0: e3a00000 mov r0, #0
1f1f4: e8bd8810 pop {r4, fp, pc}
00004238 <rtems_termios_close>:
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
4238: e5903000 ldr r3, [r0]
rtems_interrupt_enable (level);
}
rtems_status_code
rtems_termios_close (void *arg)
{
423c: e92d4030 push {r4, r5, lr}
rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
4240: e593402c ldr r4, [r3, #44] ; 0x2c
rtems_status_code sc;
sc = rtems_semaphore_obtain(
4244: e59f3188 ldr r3, [pc, #392] ; 43d4 <rtems_termios_close+0x19c>
4248: e3a01000 mov r1, #0
rtems_interrupt_enable (level);
}
rtems_status_code
rtems_termios_close (void *arg)
{
424c: 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(
4250: e1a02001 mov r2, r1
4254: e5930000 ldr r0, [r3]
4258: eb000751 bl 5fa4 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
425c: e3500000 cmp r0, #0
4260: 1a000026 bne 4300 <rtems_termios_close+0xc8>
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
4264: e5943008 ldr r3, [r4, #8]
4268: e2433001 sub r3, r3, #1
426c: e3530000 cmp r3, #0
4270: e5843008 str r3, [r4, #8]
4274: 1a000051 bne 43c0 <rtems_termios_close+0x188>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
4278: e59420cc ldr r2, [r4, #204] ; 0xcc
427c: e59f3154 ldr r3, [pc, #340] ; 43d8 <rtems_termios_close+0x1a0>
4280: e0833282 add r3, r3, r2, lsl #5
4284: e5931004 ldr r1, [r3, #4]
4288: e3510000 cmp r1, #0
428c: 0a000003 beq 42a0 <rtems_termios_close+0x68>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
4290: e1a00004 mov r0, r4
4294: e1a0e00f mov lr, pc
4298: e12fff11 bx r1
429c: ea00000a b 42cc <rtems_termios_close+0x94>
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
42a0: e5940018 ldr r0, [r4, #24]
42a4: e1a02001 mov r2, r1
42a8: eb00073d bl 5fa4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
42ac: e3500000 cmp r0, #0
42b0: 1a000012 bne 4300 <rtems_termios_close+0xc8>
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
42b4: e59430b4 ldr r3, [r4, #180] ; 0xb4
42b8: e3530000 cmp r3, #0
42bc: 11a00004 movne r0, r4
42c0: 1bfffeb5 blne 3d9c <drainOutput.part.0>
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
42c4: e5940018 ldr r0, [r4, #24]
42c8: eb00077c bl 60c0 <rtems_semaphore_release>
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
42cc: e59430b4 ldr r3, [r4, #180] ; 0xb4
42d0: e3530002 cmp r3, #2
42d4: 1a00000a bne 4304 <rtems_termios_close+0xcc>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
42d8: e59400c4 ldr r0, [r4, #196] ; 0xc4
42dc: e3a01001 mov r1, #1
42e0: eb000626 bl 5b80 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
42e4: e3500000 cmp r0, #0
42e8: 1a000004 bne 4300 <rtems_termios_close+0xc8>
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
42ec: e59400c8 ldr r0, [r4, #200] ; 0xc8
42f0: e3a01001 mov r1, #1
42f4: eb000621 bl 5b80 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
42f8: e3500000 cmp r0, #0
42fc: 0a000000 beq 4304 <rtems_termios_close+0xcc>
rtems_fatal_error_occurred (sc);
4300: eb0008f2 bl 66d0 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
if (tty->device.lastClose)
4304: e594309c ldr r3, [r4, #156] ; 0x9c
4308: e3530000 cmp r3, #0
(*tty->device.lastClose)(tty->major, tty->minor, arg);
430c: 1284000c addne r0, r4, #12
4310: 18900003 ldmne r0, {r0, r1}
4314: 11a02005 movne r2, r5
4318: 11a0e00f movne lr, pc
431c: 112fff13 bxne r3
if (tty->forw == NULL) {
4320: e5942000 ldr r2, [r4]
4324: e5943004 ldr r3, [r4, #4]
4328: e3520000 cmp r2, #0
rtems_termios_ttyTail = tty->back;
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
}
} else {
tty->forw->back = tty->back;
432c: 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) {
4330: 1a000003 bne 4344 <rtems_termios_close+0x10c>
rtems_termios_ttyTail = tty->back;
4334: e59f10a0 ldr r1, [pc, #160] ; 43dc <rtems_termios_close+0x1a4>
if ( rtems_termios_ttyTail != NULL ) {
4338: 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;
433c: e5813000 str r3, [r1]
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
4340: 15832000 strne r2, [r3]
}
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
4344: e5942004 ldr r2, [r4, #4]
4348: e5943000 ldr r3, [r4]
434c: e3520000 cmp r2, #0
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
} else {
tty->back->forw = tty->forw;
4350: 15823000 strne r3, [r2]
}
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
4354: 1a000003 bne 4368 <rtems_termios_close+0x130>
rtems_termios_ttyHead = tty->forw;
4358: e59f1080 ldr r1, [pc, #128] ; 43e0 <rtems_termios_close+0x1a8>
if ( rtems_termios_ttyHead != NULL ) {
435c: e3530000 cmp r3, #0
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
4360: e5813000 str r3, [r1]
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
4364: 15832004 strne r2, [r3, #4]
}
} else {
tty->back->forw = tty->forw;
}
rtems_semaphore_delete (tty->isem);
4368: e5940014 ldr r0, [r4, #20]
436c: eb0006e5 bl 5f08 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
4370: e5940018 ldr r0, [r4, #24]
4374: eb0006e3 bl 5f08 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
4378: e594008c ldr r0, [r4, #140] ; 0x8c
437c: eb0006e1 bl 5f08 <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
4380: e59430a0 ldr r3, [r4, #160] ; 0xa0
4384: e3530000 cmp r3, #0
4388: 0a000002 beq 4398 <rtems_termios_close+0x160>
438c: e59430b4 ldr r3, [r4, #180] ; 0xb4
4390: e3530002 cmp r3, #2
4394: 1a000001 bne 43a0 <rtems_termios_close+0x168>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
4398: e5940068 ldr r0, [r4, #104] ; 0x68
439c: eb0006d9 bl 5f08 <rtems_semaphore_delete>
free (tty->rawInBuf.theBuf);
43a0: e5940058 ldr r0, [r4, #88] ; 0x58
43a4: ebfff7df bl 2328 <free>
free (tty->rawOutBuf.theBuf);
43a8: e594007c ldr r0, [r4, #124] ; 0x7c
43ac: ebfff7dd bl 2328 <free>
free (tty->cbuf);
43b0: e594001c ldr r0, [r4, #28]
43b4: ebfff7db bl 2328 <free>
free (tty);
43b8: e1a00004 mov r0, r4
43bc: ebfff7d9 bl 2328 <free>
} rtems_semaphore_release (rtems_termios_ttyMutex);
43c0: e59f300c ldr r3, [pc, #12] ; 43d4 <rtems_termios_close+0x19c>
43c4: e5930000 ldr r0, [r3]
43c8: eb00073c bl 60c0 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL; }
43cc: e3a00000 mov r0, #0
43d0: e8bd8030 pop {r4, r5, pc}
000055a0 <rtems_termios_dequeue_characters>:
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
55a0: e5902090 ldr r2, [r0, #144] ; 0x90
55a4: e0822001 add r2, r2, r1
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
55a8: e59010b4 ldr r1, [r0, #180] ; 0xb4
55ac: e3510002 cmp r1, #2
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
55b0: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
55b4: e5802090 str r2, [r0, #144] ; 0x90
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
55b8: 1a000004 bne 55d0 <rtems_termios_dequeue_characters+0x30>
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
55bc: e59000c8 ldr r0, [r0, #200] ; 0xc8
55c0: eb00016e bl 5b80 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
55c4: e2503000 subs r3, r0, #0
55c8: 0a00000d beq 5604 <rtems_termios_dequeue_characters+0x64>
rtems_fatal_error_occurred (sc);
55cc: eb00043f bl 66d0 <rtems_fatal_error_occurred> <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
55d0: e59030cc ldr r3, [r0, #204] ; 0xcc
55d4: e3530005 cmp r3, #5
55d8: 1a000007 bne 55fc <rtems_termios_dequeue_characters+0x5c>
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
55dc: e59f3028 ldr r3, [pc, #40] ; 560c <rtems_termios_dequeue_characters+0x6c>
55e0: e59330b4 ldr r3, [r3, #180] ; 0xb4
55e4: e3530000 cmp r3, #0
55e8: 0a000005 beq 5604 <rtems_termios_dequeue_characters+0x64>
rtems_termios_linesw[tty->t_line].l_start(tty);
55ec: e1a0e00f mov lr, pc
55f0: e12fff13 bx r3
}
return 0; /* nothing to output in IRQ... */
55f4: e3a03000 mov r3, #0
55f8: ea000001 b 5604 <rtems_termios_dequeue_characters+0x64>
}
return rtems_termios_refill_transmitter(tty);
}
55fc: e49de004 pop {lr} ; (ldr lr, [sp], #4)
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
5600: eafff95b b 3b74 <rtems_termios_refill_transmitter>
}
5604: e1a00003 mov r0, r3
5608: e49df004 pop {pc} ; (ldr pc, [sp], #4)
000052a4 <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, const char *buf, int len)
{
52a4: e92d4ff3 push {r0, r1, r4, r5, r6, r7, r8, r9, sl, fp, lr}
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) {
52a8: e59030cc ldr r3, [r0, #204] ; 0xcc
52ac: e59f6288 ldr r6, [pc, #648] ; 553c <rtems_termios_enqueue_raw_characters+0x298>
52b0: e0863283 add r3, r6, r3, lsl #5
52b4: e5937010 ldr r7, [r3, #16]
52b8: e3570000 cmp r7, #0
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
{
52bc: e1a04000 mov r4, r0
52c0: e1a09001 mov r9, r1
52c4: e1a08002 mov r8, r2
* NOTE: This routine runs in the context of the * device receive interrupt handler. * Returns the number of characters dropped because of overflow. */ int rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
52c8: 13a05000 movne r5, #0
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) {
52cc: 1a00000c bne 5304 <rtems_termios_enqueue_raw_characters+0x60>
/*
* 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);
52d0: e2803030 add r3, r0, #48 ; 0x30
52d4: e58d3000 str r3, [sp]
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,
52d8: e280304a add r3, r0, #74 ; 0x4a
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) {
52dc: e1a05007 mov r5, r7
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,
52e0: e58d3004 str r3, [sp, #4]
52e4: ea00008b b 5518 <rtems_termios_enqueue_raw_characters+0x274>
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);
52e8: e59430cc ldr r3, [r4, #204] ; 0xcc
52ec: e7d90005 ldrb r0, [r9, r5]
52f0: e0863283 add r3, r6, r3, lsl #5
52f4: e1a01004 mov r1, r4
52f8: e1a0e00f mov lr, pc
52fc: e593f010 ldr pc, [r3, #16]
5300: e2855001 add r5, r5, #1
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--) {
5304: e1550008 cmp r5, r8
5308: 1afffff6 bne 52e8 <rtems_termios_enqueue_raw_characters+0x44>
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
530c: e59450e4 ldr r5, [r4, #228] ; 0xe4
5310: e3550000 cmp r5, #0
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
5314: 13a05000 movne r5, #0
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
5318: 1a000085 bne 5534 <rtems_termios_enqueue_raw_characters+0x290>
531c: e59430dc ldr r3, [r4, #220] ; 0xdc
5320: e3530000 cmp r3, #0
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
5324: 01a05003 moveq r5, r3
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
5328: 0a000081 beq 5534 <rtems_termios_enqueue_raw_characters+0x290>
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
532c: e2840030 add r0, r4, #48 ; 0x30
5330: e59410e0 ldr r1, [r4, #224] ; 0xe0
5334: e1a0e00f mov lr, pc
5338: e12fff13 bx r3
tty->tty_rcvwakeup = 1;
533c: e3a03001 mov r3, #1
5340: e58430e4 str r3, [r4, #228] ; 0xe4
5344: ea00007a b 5534 <rtems_termios_enqueue_raw_characters+0x290>
while (len--) {
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
5348: e59430b8 ldr r3, [r4, #184] ; 0xb8
534c: e3130c02 tst r3, #512 ; 0x200
}
return 0;
}
while (len--) {
c = *buf++;
5350: e4d9a001 ldrb sl, [r9], #1
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
5354: 0a00000e beq 5394 <rtems_termios_enqueue_raw_characters+0xf0>
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
5358: e5d4204a ldrb r2, [r4, #74] ; 0x4a
535c: e152000a cmp r2, sl
5360: e5d43049 ldrb r3, [r4, #73] ; 0x49
5364: 1a000006 bne 5384 <rtems_termios_enqueue_raw_characters+0xe0>
if (c == tty->termios.c_cc[VSTART]) {
5368: e1530002 cmp r3, r2
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
536c: e59430b8 ldr r3, [r4, #184] ; 0xb8
5370: 02233010 eoreq r3, r3, #16
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
5374: 13833010 orrne r3, r3, #16
5378: e58430b8 str r3, [r4, #184] ; 0xb8
* NOTE: This routine runs in the context of the * device receive interrupt handler. * Returns the number of characters dropped because of overflow. */ int rtems_termios_enqueue_raw_characters (void *ttyp, const char *buf, int len)
537c: e3a07001 mov r7, #1
5380: ea000005 b 539c <rtems_termios_enqueue_raw_characters+0xf8>
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
5384: e153000a cmp r3, sl
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
5388: 059430b8 ldreq r3, [r4, #184] ; 0xb8
538c: 03c33010 biceq r3, r3, #16
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
5390: 0afffff8 beq 5378 <rtems_termios_enqueue_raw_characters+0xd4>
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
5394: e3570000 cmp r7, #0
5398: 0a000014 beq 53f0 <rtems_termios_enqueue_raw_characters+0x14c>
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
539c: e59430b8 ldr r3, [r4, #184] ; 0xb8
53a0: e2033030 and r3, r3, #48 ; 0x30
53a4: e3530020 cmp r3, #32
53a8: 1a000059 bne 5514 <rtems_termios_enqueue_raw_characters+0x270>
/* disable interrupts */
rtems_interrupt_disable(level);
53ac: ebfff9ec bl 3b64 <arm_interrupt_disable> <== NOT EXECUTED
53b0: e1a06000 mov r6, r0 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
53b4: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
53b8: e3c33020 bic r3, r3, #32 <== NOT EXECUTED
53bc: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
53c0: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
53c4: e3530000 cmp r3, #0 <== NOT EXECUTED
53c8: 0a000006 beq 53e8 <rtems_termios_enqueue_raw_characters+0x144><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
53cc: 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)(
53d0: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED
53d4: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
53d8: e0811003 add r1, r1, r3 <== NOT EXECUTED
53dc: e3a02001 mov r2, #1 <== NOT EXECUTED
53e0: e1a0e00f mov lr, pc <== NOT EXECUTED
53e4: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
53e8: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
53ec: ea000048 b 5514 <rtems_termios_enqueue_raw_characters+0x270><== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
53f0: e5940060 ldr r0, [r4, #96] ; 0x60
53f4: e5941064 ldr r1, [r4, #100] ; 0x64
53f8: e2800001 add r0, r0, #1
53fc: eb004503 bl 16810 <__umodsi3>
5400: e1a06000 mov r6, r0
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
5404: ebfff9d6 bl 3b64 <arm_interrupt_disable>
5408: e1a0b000 mov fp, r0
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
540c: e594305c ldr r3, [r4, #92] ; 0x5c
5410: e5940064 ldr r0, [r4, #100] ; 0x64
5414: e0630000 rsb r0, r3, r0
% tty->rawInBuf.Size) > tty->highwater) &&
5418: e5941064 ldr r1, [r4, #100] ; 0x64
541c: e0800006 add r0, r0, r6
5420: eb0044fa bl 16810 <__umodsi3>
}
} 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)
5424: e59430c0 ldr r3, [r4, #192] ; 0xc0
5428: e1500003 cmp r0, r3
542c: 9a000024 bls 54c4 <rtems_termios_enqueue_raw_characters+0x220>
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
5430: 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)
% tty->rawInBuf.Size) > tty->highwater) &&
5434: e3130001 tst r3, #1 <== NOT EXECUTED
5438: 1a000021 bne 54c4 <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
543c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
5440: e3833001 orr r3, r3, #1 <== NOT EXECUTED
5444: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
5448: e59f30f0 ldr r3, [pc, #240] ; 5540 <rtems_termios_enqueue_raw_characters+0x29c><== NOT EXECUTED
544c: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
5450: e0023003 and r3, r2, r3 <== NOT EXECUTED
5454: e3530b01 cmp r3, #1024 ; 0x400 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
5458: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
545c: 1a00000d bne 5498 <rtems_termios_enqueue_raw_characters+0x1f4><== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
5460: e3130020 tst r3, #32 <== NOT EXECUTED
5464: 1a000002 bne 5474 <rtems_termios_enqueue_raw_characters+0x1d0><== NOT EXECUTED
5468: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
546c: e3530000 cmp r3, #0 <== NOT EXECUTED
5470: 1a000013 bne 54c4 <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
5474: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
5478: e3833002 orr r3, r3, #2 <== NOT EXECUTED
547c: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
5480: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
5484: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
5488: e3a02001 mov r2, #1 <== NOT EXECUTED
548c: e1a0e00f mov lr, pc <== NOT EXECUTED
5490: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
5494: ea00000a b 54c4 <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
5498: e2033f41 and r3, r3, #260 ; 0x104 <== NOT EXECUTED
549c: e3530c01 cmp r3, #256 ; 0x100 <== NOT EXECUTED
54a0: 1a000007 bne 54c4 <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
54a4: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
54a8: e3833004 orr r3, r3, #4 <== NOT EXECUTED
54ac: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
54b0: e59430ac ldr r3, [r4, #172] ; 0xac <== NOT EXECUTED
54b4: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
54b8: 15940010 ldrne r0, [r4, #16] <== NOT EXECUTED
54bc: 11a0e00f movne lr, pc <== NOT EXECUTED
54c0: 112fff13 bxne r3 <== NOT EXECUTED
54c4: e129f00b msr CPSR_fc, fp
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
54c8: e594305c ldr r3, [r4, #92] ; 0x5c
54cc: e1560003 cmp r6, r3
dropped++;
54d0: 02855001 addeq r5, r5, #1
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
54d4: 0a00000e beq 5514 <rtems_termios_enqueue_raw_characters+0x270>
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
54d8: e5943058 ldr r3, [r4, #88] ; 0x58
54dc: e7c3a006 strb sl, [r3, r6]
tty->rawInBuf.Tail = newTail;
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
54e0: e59430e4 ldr r3, [r4, #228] ; 0xe4
54e4: e3530000 cmp r3, #0
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
54e8: e5846060 str r6, [r4, #96] ; 0x60
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
54ec: 1a000008 bne 5514 <rtems_termios_enqueue_raw_characters+0x270>
54f0: e59430dc ldr r3, [r4, #220] ; 0xdc
54f4: e3530000 cmp r3, #0
54f8: 0a000005 beq 5514 <rtems_termios_enqueue_raw_characters+0x270>
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
54fc: e59d0000 ldr r0, [sp] <== NOT EXECUTED
5500: e59410e0 ldr r1, [r4, #224] ; 0xe0 <== NOT EXECUTED
5504: e1a0e00f mov lr, pc <== NOT EXECUTED
5508: e12fff13 bx r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
550c: e3a03001 mov r3, #1 <== NOT EXECUTED
5510: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
5514: e2488001 sub r8, r8, #1
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
5518: e3580000 cmp r8, #0
551c: 1affff89 bne 5348 <rtems_termios_enqueue_raw_characters+0xa4>
}
}
}
}
tty->rawInBufDropped += dropped;
5520: e5943078 ldr r3, [r4, #120] ; 0x78
5524: e0833005 add r3, r3, r5
5528: e5843078 str r3, [r4, #120] ; 0x78
rtems_semaphore_release (tty->rawInBuf.Semaphore);
552c: e5940068 ldr r0, [r4, #104] ; 0x68
5530: eb0002e2 bl 60c0 <rtems_semaphore_release>
return dropped; }
5534: e1a00005 mov r0, r5
5538: e8bd8ffc pop {r2, r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
000043fc <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;
43fc: e5903000 ldr r3, [r0]
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
4400: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
4404: e593402c ldr r4, [r3, #44] ; 0x2c
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
4408: e3a01000 mov r1, #0
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;
440c: e5907008 ldr r7, [r0, #8]
rtems_status_code sc;
args->ioctl_return = 0;
4410: e580100c str r1, [r0, #12]
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
4414: e1a06000 mov r6, 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);
4418: e1a02001 mov r2, r1
441c: e5940018 ldr r0, [r4, #24]
4420: eb0006df bl 5fa4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
4424: e2505000 subs r5, r0, #0
4428: 1a0000f7 bne 480c <rtems_termios_ioctl+0x410>
return sc;
}
switch (args->command) {
442c: e5963004 ldr r3, [r6, #4]
4430: e3530005 cmp r3, #5
4434: 0a0000c7 beq 4758 <rtems_termios_ioctl+0x35c>
4438: 8a00000a bhi 4468 <rtems_termios_ioctl+0x6c>
443c: e3530002 cmp r3, #2
4440: 0a00002d beq 44fc <rtems_termios_ioctl+0x100>
4444: 8a000002 bhi 4454 <rtems_termios_ioctl+0x58>
4448: e3530001 cmp r3, #1
444c: 1a000015 bne 44a8 <rtems_termios_ioctl+0xac>
4450: ea000020 b 44d8 <rtems_termios_ioctl+0xdc>
4454: e3530003 cmp r3, #3
4458: 0a00009c beq 46d0 <rtems_termios_ioctl+0x2d4>
445c: e3530004 cmp r3, #4
4460: 1a000010 bne 44a8 <rtems_termios_ioctl+0xac>
4464: ea0000bf b 4768 <rtems_termios_ioctl+0x36c>
4468: e59f23a4 ldr r2, [pc, #932] ; 4814 <rtems_termios_ioctl+0x418>
446c: e1530002 cmp r3, r2
4470: 0a0000d8 beq 47d8 <rtems_termios_ioctl+0x3dc>
4474: 8a000002 bhi 4484 <rtems_termios_ioctl+0x88>
4478: e3530006 cmp r3, #6
447c: 1a000009 bne 44a8 <rtems_termios_ioctl+0xac>
4480: ea000098 b 46e8 <rtems_termios_ioctl+0x2ec>
4484: e59f238c ldr r2, [pc, #908] ; 4818 <rtems_termios_ioctl+0x41c>
4488: e1530002 cmp r3, r2
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;
448c: 059420cc ldreq r2, [r4, #204] ; 0xcc
4490: 05963008 ldreq r3, [r6, #8]
4494: 05832000 streq r2, [r3]
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
4498: 0a0000d9 beq 4804 <rtems_termios_ioctl+0x408>
449c: e2822105 add r2, r2, #1073741825 ; 0x40000001
44a0: e1530002 cmp r3, r2
44a4: 0a0000b3 beq 4778 <rtems_termios_ioctl+0x37c>
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
44a8: e59420cc ldr r2, [r4, #204] ; 0xcc
44ac: e59f3368 ldr r3, [pc, #872] ; 481c <rtems_termios_ioctl+0x420>
44b0: e0833282 add r3, r3, r2, lsl #5
44b4: e5933018 ldr r3, [r3, #24]
44b8: e3530000 cmp r3, #0
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
}
else {
sc = RTEMS_INVALID_NUMBER;
44bc: 03a0500a moveq r5, #10
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
44c0: 0a0000cf beq 4804 <rtems_termios_ioctl+0x408>
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
44c4: e1a00004 mov r0, r4
44c8: e1a01006 mov r1, r6
44cc: e1a0e00f mov lr, pc
44d0: e12fff13 bx r3
44d4: ea0000bd b 47d0 <rtems_termios_ioctl+0x3d4>
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
44d8: e284e030 add lr, r4, #48 ; 0x30
44dc: e8be000f ldm lr!, {r0, r1, r2, r3}
44e0: e596c008 ldr ip, [r6, #8]
44e4: e8ac000f stmia ip!, {r0, r1, r2, r3}
44e8: e8be000f ldm lr!, {r0, r1, r2, r3}
44ec: e8ac000f stmia ip!, {r0, r1, r2, r3}
44f0: e59e3000 ldr r3, [lr]
44f4: e58c3000 str r3, [ip]
break;
44f8: ea0000c1 b 4804 <rtems_termios_ioctl+0x408>
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
44fc: e596e008 ldr lr, [r6, #8]
4500: e8be000f ldm lr!, {r0, r1, r2, r3}
4504: e284c030 add ip, r4, #48 ; 0x30
4508: e8ac000f stmia ip!, {r0, r1, r2, r3}
450c: e8be000f ldm lr!, {r0, r1, r2, r3}
4510: e8ac000f stmia ip!, {r0, r1, r2, r3}
4514: e59e3000 ldr r3, [lr]
4518: 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) &&
451c: e59430b8 ldr r3, [r4, #184] ; 0xb8
4520: e3130c02 tst r3, #512 ; 0x200
4524: 0a000018 beq 458c <rtems_termios_ioctl+0x190>
!(tty->termios.c_iflag & IXON)) {
4528: e5943030 ldr r3, [r4, #48] ; 0x30
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
452c: e3130b01 tst r3, #1024 ; 0x400
4530: 1a000015 bne 458c <rtems_termios_ioctl+0x190>
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
4534: e59430b8 ldr r3, [r4, #184] ; 0xb8
4538: e3c33e21 bic r3, r3, #528 ; 0x210
453c: e58430b8 str r3, [r4, #184] ; 0xb8
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
4540: e59430b8 ldr r3, [r4, #184] ; 0xb8
4544: e3130020 tst r3, #32
4548: 0a00000f beq 458c <rtems_termios_ioctl+0x190>
/* disable interrupts */
rtems_interrupt_disable(level);
454c: ebfffd84 bl 3b64 <arm_interrupt_disable> <== NOT EXECUTED
4550: e1a06000 mov r6, r0 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
4554: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4558: e3c33020 bic r3, r3, #32 <== NOT EXECUTED
455c: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
4560: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
4564: e3530000 cmp r3, #0 <== NOT EXECUTED
4568: 0a000006 beq 4588 <rtems_termios_ioctl+0x18c> <== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
456c: 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)(
4570: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED
4574: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
4578: e0811003 add r1, r1, r3 <== NOT EXECUTED
457c: e3a02001 mov r2, #1 <== NOT EXECUTED
4580: e1a0e00f mov lr, pc <== NOT EXECUTED
4584: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
4588: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
/* reenable interrupts */
rtems_interrupt_enable(level);
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
458c: e59430b8 ldr r3, [r4, #184] ; 0xb8
4590: e3130b01 tst r3, #1024 ; 0x400
4594: 0a000008 beq 45bc <rtems_termios_ioctl+0x1c0>
4598: e5943030 ldr r3, [r4, #48] ; 0x30
459c: e3130a01 tst r3, #4096 ; 0x1000
45a0: 1a000005 bne 45bc <rtems_termios_ioctl+0x1c0>
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
45a4: e59430b8 ldr r3, [r4, #184] ; 0xb8
45a8: e3c33b01 bic r3, r3, #1024 ; 0x400
45ac: e58430b8 str r3, [r4, #184] ; 0xb8
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
45b0: e59430b8 ldr r3, [r4, #184] ; 0xb8
45b4: e3c33002 bic r3, r3, #2
45b8: e58430b8 str r3, [r4, #184] ; 0xb8
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
45bc: e59430b8 ldr r3, [r4, #184] ; 0xb8
45c0: e3130c01 tst r3, #256 ; 0x100
45c4: 0a000010 beq 460c <rtems_termios_ioctl+0x210>
45c8: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED
45cc: e3530000 cmp r3, #0 <== NOT EXECUTED
45d0: ba00000d blt 460c <rtems_termios_ioctl+0x210> <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
45d4: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
45d8: e3c33c01 bic r3, r3, #256 ; 0x100 <== NOT EXECUTED
45dc: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
45e0: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
45e4: e3130004 tst r3, #4 <== NOT EXECUTED
45e8: 0a000004 beq 4600 <rtems_termios_ioctl+0x204> <== NOT EXECUTED
45ec: e59430b0 ldr r3, [r4, #176] ; 0xb0 <== NOT EXECUTED
45f0: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
45f4: 15940010 ldrne r0, [r4, #16] <== NOT EXECUTED
45f8: 11a0e00f movne lr, pc <== NOT EXECUTED
45fc: 112fff13 bxne r3 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
4600: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4604: e3c33004 bic r3, r3, #4 <== NOT EXECUTED
4608: 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) {
460c: e5943038 ldr r3, [r4, #56] ; 0x38
4610: e3530000 cmp r3, #0
tty->flow_ctrl |= FL_MDRTS;
4614: b59430b8 ldrlt r3, [r4, #184] ; 0xb8
4618: b3833c01 orrlt r3, r3, #256 ; 0x100
461c: b58430b8 strlt r3, [r4, #184] ; 0xb8
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
4620: e5943030 ldr r3, [r4, #48] ; 0x30
4624: e3130a01 tst r3, #4096 ; 0x1000
tty->flow_ctrl |= FL_MDXOF;
4628: 159420b8 ldrne r2, [r4, #184] ; 0xb8
462c: 13822b01 orrne r2, r2, #1024 ; 0x400
4630: 158420b8 strne r2, [r4, #184] ; 0xb8
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
4634: e3130b01 tst r3, #1024 ; 0x400
tty->flow_ctrl |= FL_MDXON;
4638: 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) {
463c: e594603c ldr r6, [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;
4640: 13833c02 orrne r3, r3, #512 ; 0x200
4644: 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) {
4648: e2166002 ands r6, r6, #2
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
464c: 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) {
4650: 1a000013 bne 46a4 <rtems_termios_ioctl+0x2a8>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
4654: e5d47046 ldrb r7, [r4, #70] ; 0x46
rtems_clock_get_ticks_per_second() / 10;
4658: eb0004c1 bl 5964 <rtems_clock_get_ticks_per_second>
465c: e3a0100a mov r1, #10
4660: e0000097 mul r0, r7, r0
4664: eb004823 bl 166f8 <__aeabi_uidiv>
if (tty->termios.c_cc[VTIME]) {
4668: e5d43046 ldrb r3, [r4, #70] ; 0x46
466c: e3530000 cmp r3, #0
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
4670: e5840054 str r0, [r4, #84] ; 0x54
4674: e5d42047 ldrb r2, [r4, #71] ; 0x47
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
4678: 0a000005 beq 4694 <rtems_termios_ioctl+0x298>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
467c: e3520000 cmp r2, #0
} 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;
4680: e5840070 str r0, [r4, #112] ; 0x70
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
4684: 13a00000 movne r0, #0
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} 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;
4688: e584606c str r6, [r4, #108] ; 0x6c
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
468c: e5840074 str r0, [r4, #116] ; 0x74
4690: ea000006 b 46b0 <rtems_termios_ioctl+0x2b4>
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
4694: e3520000 cmp r2, #0
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
4698: 03a03001 moveq r3, #1
469c: 0584306c streq r3, [r4, #108] ; 0x6c
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
46a0: 0a000002 beq 46b0 <rtems_termios_ioctl+0x2b4>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
46a4: e584306c str r3, [r4, #108] ; 0x6c
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
46a8: e5843070 str r3, [r4, #112] ; 0x70
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
46ac: e5843074 str r3, [r4, #116] ; 0x74
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
46b0: e59430a8 ldr r3, [r4, #168] ; 0xa8
46b4: e3530000 cmp r3, #0
46b8: 0a000051 beq 4804 <rtems_termios_ioctl+0x408>
(*tty->device.setAttributes)(tty->minor, &tty->termios);
46bc: e5940010 ldr r0, [r4, #16]
46c0: e2841030 add r1, r4, #48 ; 0x30
46c4: e1a0e00f mov lr, pc
46c8: e12fff13 bx r3
46cc: ea00004c b 4804 <rtems_termios_ioctl+0x408>
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
46d0: e59430b4 ldr r3, [r4, #180] ; 0xb4
46d4: e3530000 cmp r3, #0
46d8: 0a000049 beq 4804 <rtems_termios_ioctl+0x408>
46dc: e1a00004 mov r0, r4 <== NOT EXECUTED
46e0: ebfffdad bl 3d9c <drainOutput.part.0> <== NOT EXECUTED
46e4: ea000046 b 4804 <rtems_termios_ioctl+0x408> <== NOT EXECUTED
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_TCFLUSH:
switch ((intptr_t) args->buffer) {
46e8: e5963008 ldr r3, [r6, #8]
46ec: e3530001 cmp r3, #1
46f0: 0a000008 beq 4718 <rtems_termios_ioctl+0x31c>
46f4: e3530002 cmp r3, #2
46f8: 0a00000b beq 472c <rtems_termios_ioctl+0x330>
46fc: e3530000 cmp r3, #0
case TCIOFLUSH:
flushOutput (tty);
flushInput (tty);
break;
default:
sc = RTEMS_INVALID_NAME;
4700: 13a05003 movne r5, #3
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_TCFLUSH:
switch ((intptr_t) args->buffer) {
4704: 1a00003e bne 4804 <rtems_termios_ioctl+0x408>
static void
flushInput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
4708: ebfffd15 bl 3b64 <arm_interrupt_disable>
tty->rawInBuf.Tail = 0;
470c: e5845060 str r5, [r4, #96] ; 0x60
tty->rawInBuf.Head = 0;
4710: e584505c str r5, [r4, #92] ; 0x5c
4714: ea00000d b 4750 <rtems_termios_ioctl+0x354>
static void
flushOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
4718: ebfffd11 bl 3b64 <arm_interrupt_disable>
tty->rawOutBuf.Tail = 0;
471c: e5845084 str r5, [r4, #132] ; 0x84
tty->rawOutBuf.Head = 0; tty->rawOutBufState = rob_idle;
4720: e5845094 str r5, [r4, #148] ; 0x94
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
tty->rawOutBuf.Tail = 0;
tty->rawOutBuf.Head = 0;
4724: e5845080 str r5, [r4, #128] ; 0x80
4728: ea000008 b 4750 <rtems_termios_ioctl+0x354>
static void
flushOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
472c: ebfffd0c bl 3b64 <arm_interrupt_disable>
tty->rawOutBuf.Tail = 0;
4730: e5845084 str r5, [r4, #132] ; 0x84
tty->rawOutBuf.Head = 0; tty->rawOutBufState = rob_idle;
4734: e5845094 str r5, [r4, #148] ; 0x94
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
tty->rawOutBuf.Tail = 0;
tty->rawOutBuf.Head = 0;
4738: e5845080 str r5, [r4, #128] ; 0x80
473c: e129f000 msr CPSR_fc, r0
static void
flushInput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
4740: ebfffd07 bl 3b64 <arm_interrupt_disable>
tty->rawInBuf.Tail = 0;
4744: e3a03000 mov r3, #0
4748: e5843060 str r3, [r4, #96] ; 0x60
tty->rawInBuf.Head = 0;
474c: e584305c str r3, [r4, #92] ; 0x5c
4750: e129f000 msr CPSR_fc, r0
4754: ea00002a b 4804 <rtems_termios_ioctl+0x408>
break;
}
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
4758: e897000c ldm r7, {r2, r3}
475c: e58420d4 str r2, [r4, #212] ; 0xd4
4760: e58430d8 str r3, [r4, #216] ; 0xd8
break;
4764: ea000026 b 4804 <rtems_termios_ioctl+0x408>
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
4768: e897000c ldm r7, {r2, r3}
476c: e58420dc str r2, [r4, #220] ; 0xdc
4770: e58430e0 str r3, [r4, #224] ; 0xe0
break;
4774: ea000022 b 4804 <rtems_termios_ioctl+0x408>
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
4778: e59420cc ldr r2, [r4, #204] ; 0xcc
477c: e59f3098 ldr r3, [pc, #152] ; 481c <rtems_termios_ioctl+0x420>
4780: e0833282 add r3, r3, r2, lsl #5
4784: e5933004 ldr r3, [r3, #4]
4788: e3530000 cmp r3, #0
478c: 0a000003 beq 47a0 <rtems_termios_ioctl+0x3a4>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
4790: e1a00004 mov r0, r4
4794: e1a0e00f mov lr, pc
4798: e12fff13 bx r3
479c: e1a05000 mov r5, r0
}
tty->t_line=*(int*)(args->buffer);
47a0: e5963008 ldr r3, [r6, #8]
tty->t_sc = NULL; /* ensure that no more valid data */
47a4: e3a02000 mov r2, #0
* 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);
47a8: e5933000 ldr r3, [r3]
tty->t_sc = NULL; /* ensure that no more valid data */
47ac: e58420d0 str r2, [r4, #208] ; 0xd0
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
47b0: e59f2064 ldr r2, [pc, #100] ; 481c <rtems_termios_ioctl+0x420>
* 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);
47b4: e58430cc str r3, [r4, #204] ; 0xcc
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
47b8: e7923283 ldr r3, [r2, r3, lsl #5]
47bc: e3530000 cmp r3, #0
47c0: 0a00000f beq 4804 <rtems_termios_ioctl+0x408>
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
47c4: e1a00004 mov r0, r4
47c8: e1a0e00f mov lr, pc
47cc: e12fff13 bx r3
47d0: e1a05000 mov r5, r0
47d4: ea00000a b 4804 <rtems_termios_ioctl+0x408>
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
47d8: e5942060 ldr r2, [r4, #96] ; 0x60 <== NOT EXECUTED
47dc: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED
if ( rawnc < 0 )
47e0: e0523003 subs r3, r2, r3 <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
47e4: 45942064 ldrmi r2, [r4, #100] ; 0x64 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
47e8: e2840020 add r0, r4, #32 <== NOT EXECUTED
47ec: e8900003 ldm r0, {r0, r1} <== NOT EXECUTED
47f0: e0401001 sub r1, r0, r1 <== NOT EXECUTED
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
rawnc += tty->rawInBuf.Size;
47f4: 40833002 addmi r3, r3, r2 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
47f8: e5962008 ldr r2, [r6, #8] <== NOT EXECUTED
47fc: e0813003 add r3, r1, r3 <== NOT EXECUTED
4800: e5823000 str r3, [r2] <== NOT EXECUTED
}
break;
}
rtems_semaphore_release (tty->osem);
4804: e5940018 ldr r0, [r4, #24]
4808: eb00062c bl 60c0 <rtems_semaphore_release>
return sc; }
480c: e1a00005 mov r0, r5
4810: e8bd80f0 pop {r4, r5, r6, r7, pc}
00004f60 <rtems_termios_read>:
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
4f60: e5903000 ldr r3, [r0]
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
4f64: 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;
4f68: e593402c ldr r4, [r3, #44] ; 0x2c
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4f6c: e3a01000 mov r1, #0
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;
4f70: e5908010 ldr r8, [r0, #16]
char *buffer = args->buffer;
4f74: e590b00c ldr fp, [r0, #12]
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
4f78: e1a05000 mov r5, r0
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4f7c: e1a02001 mov r2, r1
4f80: e5940014 ldr r0, [r4, #20]
4f84: eb000406 bl 5fa4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
4f88: e2507000 subs r7, r0, #0
4f8c: 1a0000bc bne 5284 <rtems_termios_read+0x324>
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
4f90: e59420cc ldr r2, [r4, #204] ; 0xcc
4f94: e59f32f0 ldr r3, [pc, #752] ; 528c <rtems_termios_read+0x32c>
4f98: e0833282 add r3, r3, r2, lsl #5
4f9c: e5933008 ldr r3, [r3, #8]
4fa0: e3530000 cmp r3, #0
4fa4: 0a000005 beq 4fc0 <rtems_termios_read+0x60>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
4fa8: e1a00004 mov r0, r4
4fac: e1a01005 mov r1, r5
4fb0: e1a0e00f mov lr, pc
4fb4: e12fff13 bx r3
4fb8: e1a07000 mov r7, r0
4fbc: ea0000ac b 5274 <rtems_termios_read+0x314>
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
4fc0: e5942024 ldr r2, [r4, #36] ; 0x24
4fc4: e5943020 ldr r3, [r4, #32]
4fc8: e1520003 cmp r2, r3
4fcc: 1a00009f bne 5250 <rtems_termios_read+0x2f0>
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
4fd0: e5943028 ldr r3, [r4, #40] ; 0x28
4fd4: e584302c str r3, [r4, #44] ; 0x2c
if (tty->device.pollRead != NULL &&
4fd8: e59430a0 ldr r3, [r4, #160] ; 0xa0
4fdc: e3530000 cmp r3, #0
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
4fe0: e5847020 str r7, [r4, #32]
4fe4: e5847024 str r7, [r4, #36] ; 0x24
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL &&
4fe8: 0a00003b beq 50dc <rtems_termios_read+0x17c>
4fec: e59430b4 ldr r3, [r4, #180] ; 0xb4
4ff0: e3530000 cmp r3, #0
4ff4: 1a000038 bne 50dc <rtems_termios_read+0x17c>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
4ff8: e594303c ldr r3, [r4, #60] ; 0x3c
4ffc: e3130002 tst r3, #2
5000: 0a00000d beq 503c <rtems_termios_read+0xdc>
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
5004: e5940010 ldr r0, [r4, #16]
5008: e1a0e00f mov lr, pc
500c: e594f0a0 ldr pc, [r4, #160] ; 0xa0
if (n < 0) {
5010: e3500000 cmp r0, #0
5014: aa000002 bge 5024 <rtems_termios_read+0xc4>
rtems_task_wake_after (1);
5018: e3a00001 mov r0, #1
501c: eb000522 bl 64ac <rtems_task_wake_after>
5020: eafffff7 b 5004 <rtems_termios_read+0xa4>
} else {
if (siproc (n, tty))
5024: e20000ff and r0, r0, #255 ; 0xff
5028: e1a01004 mov r1, r4
502c: ebffff85 bl 4e48 <siproc>
5030: e3500000 cmp r0, #0
5034: 0afffff2 beq 5004 <rtems_termios_read+0xa4>
5038: ea000084 b 5250 <rtems_termios_read+0x2f0>
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
503c: eb000250 bl 5984 <rtems_clock_get_ticks_since_boot>
5040: e1a06000 mov r6, r0
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
5044: e5940010 ldr r0, [r4, #16]
5048: e1a0e00f mov lr, pc
504c: e594f0a0 ldr pc, [r4, #160] ; 0xa0
if (n < 0) {
5050: e3500000 cmp r0, #0
5054: aa000013 bge 50a8 <rtems_termios_read+0x148>
if (tty->termios.c_cc[VMIN]) {
5058: e5d43047 ldrb r3, [r4, #71] ; 0x47
505c: e3530000 cmp r3, #0
5060: e5d43046 ldrb r3, [r4, #70] ; 0x46
5064: 0a000005 beq 5080 <rtems_termios_read+0x120>
if (tty->termios.c_cc[VTIME] && tty->ccount) {
5068: e3530000 cmp r3, #0
506c: 0a00000a beq 509c <rtems_termios_read+0x13c>
5070: e5943020 ldr r3, [r4, #32]
5074: e3530000 cmp r3, #0
5078: 0a000007 beq 509c <rtems_termios_read+0x13c>
507c: ea000001 b 5088 <rtems_termios_read+0x128>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
5080: e3530000 cmp r3, #0
5084: 0a000071 beq 5250 <rtems_termios_read+0x2f0>
break;
now = rtems_clock_get_ticks_since_boot();
5088: eb00023d bl 5984 <rtems_clock_get_ticks_since_boot>
if ((now - then) > tty->vtimeTicks) {
508c: e5943054 ldr r3, [r4, #84] ; 0x54
5090: e0660000 rsb r0, r6, r0
5094: e1500003 cmp r0, r3
5098: 8a00006c bhi 5250 <rtems_termios_read+0x2f0>
break;
}
}
rtems_task_wake_after (1);
509c: e3a00001 mov r0, #1
50a0: eb000501 bl 64ac <rtems_task_wake_after>
50a4: eaffffe6 b 5044 <rtems_termios_read+0xe4>
} else {
siproc (n, tty);
50a8: e20000ff and r0, r0, #255 ; 0xff
50ac: e1a01004 mov r1, r4
50b0: ebffff64 bl 4e48 <siproc>
if (tty->ccount >= tty->termios.c_cc[VMIN])
50b4: e5d43047 ldrb r3, [r4, #71] ; 0x47
50b8: e5942020 ldr r2, [r4, #32]
50bc: e1520003 cmp r2, r3
50c0: aa000062 bge 5250 <rtems_termios_read+0x2f0>
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
50c4: e3530000 cmp r3, #0
50c8: 0affffdd beq 5044 <rtems_termios_read+0xe4>
50cc: e5d43046 ldrb r3, [r4, #70] ; 0x46
50d0: e3530000 cmp r3, #0
50d4: 0affffda beq 5044 <rtems_termios_read+0xe4>
50d8: eaffffd7 b 503c <rtems_termios_read+0xdc>
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)(
50dc: e2843049 add r3, r4, #73 ; 0x49
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
50e0: e594a074 ldr sl, [r4, #116] ; 0x74
rtems_status_code sc; int wait = 1;
50e4: e3a06001 mov r6, #1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
50e8: e59f91a0 ldr r9, [pc, #416] ; 5290 <rtems_termios_read+0x330>
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)(
50ec: e58d3000 str r3, [sp]
50f0: ea00003e b 51f0 <rtems_termios_read+0x290>
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
50f4: e594005c ldr r0, [r4, #92] ; 0x5c
50f8: e5941064 ldr r1, [r4, #100] ; 0x64
50fc: e2800001 add r0, r0, #1
5100: eb0045c2 bl 16810 <__umodsi3>
c = tty->rawInBuf.theBuf[newHead];
5104: e5943058 ldr r3, [r4, #88] ; 0x58
5108: e7d3a000 ldrb sl, [r3, r0]
tty->rawInBuf.Head = newHead;
510c: e584005c str r0, [r4, #92] ; 0x5c
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
5110: e5943060 ldr r3, [r4, #96] ; 0x60
5114: e5942064 ldr r2, [r4, #100] ; 0x64
5118: e0823003 add r3, r2, r3
% tty->rawInBuf.Size)
511c: e0600003 rsb r0, r0, r3
5120: e5941064 ldr r1, [r4, #100] ; 0x64
5124: eb0045b9 bl 16810 <__umodsi3>
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
5128: e59430bc ldr r3, [r4, #188] ; 0xbc
512c: e1500003 cmp r0, r3
5130: 2a00001f bcs 51b4 <rtems_termios_read+0x254>
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
5134: e59430b8 ldr r3, [r4, #184] ; 0xb8
5138: e3c33001 bic r3, r3, #1
513c: e58430b8 str r3, [r4, #184] ; 0xb8
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
5140: e59f314c ldr r3, [pc, #332] ; 5294 <rtems_termios_read+0x334>
5144: e59420b8 ldr r2, [r4, #184] ; 0xb8
5148: e0023003 and r3, r2, r3
514c: e59f2140 ldr r2, [pc, #320] ; 5294 <rtems_termios_read+0x334>
5150: e1530002 cmp r3, r2
5154: 1a00000b bne 5188 <rtems_termios_read+0x228>
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
5158: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
515c: e3530000 cmp r3, #0 <== NOT EXECUTED
5160: 0a000002 beq 5170 <rtems_termios_read+0x210> <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
5164: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
5168: e3130020 tst r3, #32 <== NOT EXECUTED
516c: 0a000005 beq 5188 <rtems_termios_read+0x228> <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
5170: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
5174: e59d1000 ldr r1, [sp] <== NOT EXECUTED
5178: e3a02001 mov r2, #1 <== NOT EXECUTED
517c: e1a0e00f mov lr, pc <== NOT EXECUTED
5180: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
5184: ea00000a b 51b4 <rtems_termios_read+0x254> <== NOT EXECUTED
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
5188: e59430b8 ldr r3, [r4, #184] ; 0xb8
518c: e3130c01 tst r3, #256 ; 0x100
5190: 0a000007 beq 51b4 <rtems_termios_read+0x254>
tty->flow_ctrl &= ~FL_IRTSOFF;
5194: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
5198: e3c33004 bic r3, r3, #4 <== NOT EXECUTED
519c: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
51a0: e59430b0 ldr r3, [r4, #176] ; 0xb0 <== NOT EXECUTED
51a4: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
51a8: 15940010 ldrne r0, [r4, #16] <== NOT EXECUTED
51ac: 11a0e00f movne lr, pc <== NOT EXECUTED
51b0: 112fff13 bxne r3 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
51b4: e594303c ldr r3, [r4, #60] ; 0x3c
51b8: e3130002 tst r3, #2
if (siproc (c, tty))
51bc: e1a0000a mov r0, sl
51c0: e1a01004 mov r1, r4
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
51c4: 0a000003 beq 51d8 <rtems_termios_read+0x278>
if (siproc (c, tty))
51c8: ebffff1e bl 4e48 <siproc>
wait = 0;
51cc: e3500000 cmp r0, #0
51d0: 13a06000 movne r6, #0
51d4: ea000004 b 51ec <rtems_termios_read+0x28c>
} else {
siproc (c, tty);
51d8: ebffff1a bl 4e48 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
51dc: e5d43047 ldrb r3, [r4, #71] ; 0x47 <== NOT EXECUTED
51e0: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
wait = 0;
51e4: e1520003 cmp r2, r3 <== NOT EXECUTED
51e8: a3a06000 movge r6, #0 <== NOT EXECUTED
}
timeout = tty->rawInBufSemaphoreTimeout;
51ec: e594a070 ldr sl, [r4, #112] ; 0x70
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
51f0: e594205c ldr r2, [r4, #92] ; 0x5c
51f4: e5943060 ldr r3, [r4, #96] ; 0x60
51f8: e1520003 cmp r2, r3
51fc: 0a000004 beq 5214 <rtems_termios_read+0x2b4>
(tty->ccount < (CBUFSIZE-1))) {
5200: e5993008 ldr r3, [r9, #8]
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
5204: e5942020 ldr r2, [r4, #32]
(tty->ccount < (CBUFSIZE-1))) {
5208: e2433001 sub r3, r3, #1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
520c: e1520003 cmp r2, r3
5210: 3affffb7 bcc 50f4 <rtems_termios_read+0x194>
}
/*
* Wait for characters
*/
if ( wait ) {
5214: e3560000 cmp r6, #0
5218: 0a00000c beq 5250 <rtems_termios_read+0x2f0>
sc = rtems_semaphore_obtain(
521c: e2840068 add r0, r4, #104 ; 0x68
5220: e8900003 ldm r0, {r0, r1}
5224: e1a0200a mov r2, sl
5228: eb00035d bl 5fa4 <rtems_semaphore_obtain>
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
522c: e3500000 cmp r0, #0
5230: 0affffee beq 51f0 <rtems_termios_read+0x290>
5234: ea000005 b 5250 <rtems_termios_read+0x2f0> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
5238: e594201c ldr r2, [r4, #28]
523c: e7d22003 ldrb r2, [r2, r3]
5240: e2833001 add r3, r3, #1
5244: e4cb2001 strb r2, [fp], #1
5248: e5843024 str r3, [r4, #36] ; 0x24
count--;
524c: e2488001 sub r8, r8, #1
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
5250: e3580000 cmp r8, #0
5254: 0a000003 beq 5268 <rtems_termios_read+0x308>
5258: e2842020 add r2, r4, #32
525c: e892000c ldm r2, {r2, r3}
5260: e1530002 cmp r3, r2
5264: bafffff3 blt 5238 <rtems_termios_read+0x2d8>
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
5268: e5953010 ldr r3, [r5, #16]
526c: e0688003 rsb r8, r8, r3
5270: e5858018 str r8, [r5, #24]
tty->tty_rcvwakeup = 0;
5274: e3a03000 mov r3, #0
5278: e58430e4 str r3, [r4, #228] ; 0xe4
rtems_semaphore_release (tty->isem);
527c: e5940014 ldr r0, [r4, #20]
5280: eb00038e bl 60c0 <rtems_semaphore_release>
return sc; }
5284: e1a00007 mov r0, r7
5288: e8bd8ff8 pop {r3, r4, r5, r6, r7, r8, r9, sl, fp, pc}
00003b74 <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))
3b74: e59020b8 ldr r2, [r0, #184] ; 0xb8
3b78: e59f31b4 ldr r3, [pc, #436] ; 3d34 <rtems_termios_refill_transmitter+0x1c0>
3b7c: e0023003 and r3, r2, r3
3b80: e59f21b0 ldr r2, [pc, #432] ; 3d38 <rtems_termios_refill_transmitter+0x1c4>
3b84: e1530002 cmp r3, r2
* in task-driven mode, this function is called in Tx task context
* in interrupt-driven mode, this function is called in TxIRQ context
*/
static int
rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)
{
3b88: e92d4070 push {r4, r5, r6, lr}
3b8c: e1a04000 mov r4, r0
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
3b90: 1a00000b bne 3bc4 <rtems_termios_refill_transmitter+0x50>
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
3b94: e284104a add r1, r4, #74 ; 0x4a <== NOT EXECUTED
3b98: e3a02001 mov r2, #1 <== NOT EXECUTED
3b9c: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
3ba0: e1a0e00f mov lr, pc <== NOT EXECUTED
3ba4: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
rtems_interrupt_disable(level);
3ba8: ebffffed bl 3b64 <arm_interrupt_disable> <== NOT EXECUTED
tty->t_dqlen--;
3bac: e5943090 ldr r3, [r4, #144] ; 0x90 <== NOT EXECUTED
3bb0: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3bb4: e5843090 str r3, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
3bb8: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
3bbc: e3833002 orr r3, r3, #2 <== NOT EXECUTED
3bc0: ea00000e b 3c00 <rtems_termios_refill_transmitter+0x8c> <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
3bc4: e59030b8 ldr r3, [r0, #184] ; 0xb8
3bc8: e2033003 and r3, r3, #3
3bcc: e3530002 cmp r3, #2
3bd0: 1a00000e bne 3c10 <rtems_termios_refill_transmitter+0x9c>
* 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, (void *)&(tty->termios.c_cc[VSTART]), 1);
3bd4: e2841049 add r1, r4, #73 ; 0x49 <== NOT EXECUTED
3bd8: e3a02001 mov r2, #1 <== NOT EXECUTED
3bdc: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
3be0: e1a0e00f mov lr, pc <== NOT EXECUTED
3be4: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
rtems_interrupt_disable(level);
3be8: ebffffdd bl 3b64 <arm_interrupt_disable> <== NOT EXECUTED
tty->t_dqlen--;
3bec: e5943090 ldr r3, [r4, #144] ; 0x90 <== NOT EXECUTED
3bf0: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3bf4: e5843090 str r3, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
3bf8: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
3bfc: e3c33002 bic r3, r3, #2 <== NOT EXECUTED
3c00: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3c04: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
3c08: e3a05001 mov r5, #1 <== NOT EXECUTED
3c0c: ea000046 b 3d2c <rtems_termios_refill_transmitter+0x1b8> <== NOT EXECUTED
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
3c10: e5902080 ldr r2, [r0, #128] ; 0x80
3c14: e5903084 ldr r3, [r0, #132] ; 0x84
3c18: e1520003 cmp r2, r3
3c1c: 1a000005 bne 3c38 <rtems_termios_refill_transmitter+0xc4>
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
3c20: e5903094 ldr r3, [r0, #148] ; 0x94
3c24: e3530002 cmp r3, #2
3c28: 1a00003e bne 3d28 <rtems_termios_refill_transmitter+0x1b4>
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
3c2c: e590008c ldr r0, [r0, #140] ; 0x8c <== NOT EXECUTED
3c30: eb000922 bl 60c0 <rtems_semaphore_release> <== NOT EXECUTED
3c34: ea00003b b 3d28 <rtems_termios_refill_transmitter+0x1b4> <== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
3c38: ebffffc9 bl 3b64 <arm_interrupt_disable>
len = tty->t_dqlen;
tty->t_dqlen = 0;
3c3c: e3a03000 mov r3, #0
}
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
3c40: e5942090 ldr r2, [r4, #144] ; 0x90
tty->t_dqlen = 0;
3c44: e5843090 str r3, [r4, #144] ; 0x90
3c48: e129f000 msr CPSR_fc, r0
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
3c4c: e5943084 ldr r3, [r4, #132] ; 0x84
3c50: e5941088 ldr r1, [r4, #136] ; 0x88
3c54: e0820003 add r0, r2, r3
3c58: eb004aec bl 16810 <__umodsi3>
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
3c5c: e5943094 ldr r3, [r4, #148] ; 0x94
3c60: e3530002 cmp r3, #2
rtems_interrupt_disable(level);
len = tty->t_dqlen;
tty->t_dqlen = 0;
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
3c64: e1a06000 mov r6, r0
tty->rawOutBuf.Tail = newTail;
3c68: e5840084 str r0, [r4, #132] ; 0x84
if (tty->rawOutBufState == rob_wait) {
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
3c6c: 0594008c ldreq r0, [r4, #140] ; 0x8c
3c70: 0b000912 bleq 60c0 <rtems_semaphore_release>
}
if (newTail == tty->rawOutBuf.Head) {
3c74: e5943080 ldr r3, [r4, #128] ; 0x80
3c78: e1560003 cmp r6, r3
3c7c: 1a00000a bne 3cac <rtems_termios_refill_transmitter+0x138>
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
3c80: e59430d4 ldr r3, [r4, #212] ; 0xd4
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
3c84: e3a05000 mov r5, #0
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
3c88: e1530005 cmp r3, r5
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
3c8c: e5845094 str r5, [r4, #148] ; 0x94
nToSend = 0;
3c90: 01a05003 moveq r5, r3
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
3c94: 0a000021 beq 3d20 <rtems_termios_refill_transmitter+0x1ac>
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
3c98: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED
3c9c: e59410d8 ldr r1, [r4, #216] ; 0xd8 <== NOT EXECUTED
3ca0: e1a0e00f mov lr, pc <== NOT EXECUTED
3ca4: e12fff13 bx r3 <== NOT EXECUTED
3ca8: ea00001c b 3d20 <rtems_termios_refill_transmitter+0x1ac> <== NOT EXECUTED
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
3cac: e59430b8 ldr r3, [r4, #184] ; 0xb8
3cb0: e2033e21 and r3, r3, #528 ; 0x210
3cb4: e3530e21 cmp r3, #528 ; 0x210
3cb8: 1a000008 bne 3ce0 <rtems_termios_refill_transmitter+0x16c>
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
3cbc: ebffffa8 bl 3b64 <arm_interrupt_disable> <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
3cc0: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
3cc4: e3833020 orr r3, r3, #32 <== NOT EXECUTED
3cc8: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
3ccc: e3a03001 mov r3, #1 <== NOT EXECUTED
3cd0: e5843094 str r3, [r4, #148] ; 0x94 <== NOT EXECUTED
3cd4: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 0;
3cd8: e3a05000 mov r5, #0 <== NOT EXECUTED
3cdc: ea00000f b 3d20 <rtems_termios_refill_transmitter+0x1ac> <== NOT EXECUTED
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
3ce0: e5943080 ldr r3, [r4, #128] ; 0x80
3ce4: e1560003 cmp r6, r3
nToSend = tty->rawOutBuf.Size - newTail;
3ce8: 85945088 ldrhi r5, [r4, #136] ; 0x88
else
nToSend = tty->rawOutBuf.Head - newTail;
3cec: 95945080 ldrls r5, [r4, #128] ; 0x80
/* 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)) {
3cf0: e59430b8 ldr r3, [r4, #184] ; 0xb8
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
3cf4: e0665005 rsb r5, r6, r5
/* 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)) {
3cf8: e3130c06 tst r3, #1536 ; 0x600
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
3cfc: e594107c ldr r1, [r4, #124] ; 0x7c
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)) {
nToSend = 1;
3d00: 13a05001 movne r5, #1
}
tty->rawOutBufState = rob_busy; /*apm*/
3d04: e3a03001 mov r3, #1
3d08: e5843094 str r3, [r4, #148] ; 0x94
(*tty->device.write)(
3d0c: e5940010 ldr r0, [r4, #16]
3d10: e0811006 add r1, r1, r6
3d14: e1a02005 mov r2, r5
3d18: e1a0e00f mov lr, pc
3d1c: e594f0a4 ldr pc, [r4, #164] ; 0xa4
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
3d20: e5846084 str r6, [r4, #132] ; 0x84
3d24: ea000000 b 3d2c <rtems_termios_refill_transmitter+0x1b8>
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
3d28: e3a05000 mov r5, #0
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
3d2c: e1a00005 mov r0, r5
3d30: e8bd8070 pop {r4, r5, r6, pc}
00004ea4 <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;
4ea4: e5903000 ldr r3, [r0]
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
4ea8: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
4eac: e593502c ldr r5, [r3, #44] ; 0x2c
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4eb0: e3a01000 mov r1, #0
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
4eb4: 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);
4eb8: e1a02001 mov r2, r1
4ebc: e5950018 ldr r0, [r5, #24]
4ec0: eb000437 bl 5fa4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
4ec4: e2506000 subs r6, r0, #0
4ec8: 1a000021 bne 4f54 <rtems_termios_write+0xb0>
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
4ecc: e59520cc ldr r2, [r5, #204] ; 0xcc
4ed0: e59f3084 ldr r3, [pc, #132] ; 4f5c <rtems_termios_write+0xb8>
4ed4: e0833282 add r3, r3, r2, lsl #5
4ed8: e593300c ldr r3, [r3, #12]
4edc: e3530000 cmp r3, #0
4ee0: 0a000005 beq 4efc <rtems_termios_write+0x58>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
4ee4: e1a00005 mov r0, r5
4ee8: e1a01004 mov r1, r4
4eec: e1a0e00f mov lr, pc
4ef0: e12fff13 bx r3
4ef4: e1a06000 mov r6, r0
4ef8: ea000013 b 4f4c <rtems_termios_write+0xa8>
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
4efc: e5953034 ldr r3, [r5, #52] ; 0x34
4f00: e3130001 tst r3, #1
4f04: 0a00000a beq 4f34 <rtems_termios_write+0x90>
uint32_t count = args->count;
char *buffer = args->buffer;
4f08: e284800c add r8, r4, #12
4f0c: e8980500 ldm r8, {r8, sl}
while (count--)
4f10: e1a07006 mov r7, r6
4f14: ea000003 b 4f28 <rtems_termios_write+0x84>
oproc (*buffer++, tty);
4f18: e7d80007 ldrb r0, [r8, r7]
4f1c: e1a01005 mov r1, r5
4f20: ebfffe7b bl 4914 <oproc>
4f24: e2877001 add r7, r7, #1
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
4f28: e157000a cmp r7, sl
4f2c: 1afffff9 bne 4f18 <rtems_termios_write+0x74>
4f30: ea000003 b 4f44 <rtems_termios_write+0xa0>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
4f34: e284000c add r0, r4, #12 <== NOT EXECUTED
4f38: e8900003 ldm r0, {r0, r1} <== NOT EXECUTED
4f3c: e1a02005 mov r2, r5 <== NOT EXECUTED
4f40: ebfffe36 bl 4820 <rtems_termios_puts> <== NOT EXECUTED
args->bytes_moved = args->count;
4f44: e5943010 ldr r3, [r4, #16]
4f48: e5843018 str r3, [r4, #24]
} rtems_semaphore_release (tty->osem);
4f4c: e5950018 ldr r0, [r5, #24]
4f50: eb00045a bl 60c0 <rtems_semaphore_release>
return sc; }
4f54: e1a00006 mov r0, r6
4f58: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
00002128 <rtems_verror>:
{
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
2128: e3100202 tst r0, #536870912 ; 0x20000000
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
212c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
2130: e1a05000 mov r5, r0
2134: e1a07001 mov r7, r1
2138: e1a04002 mov r4, r2
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
213c: 0a00000d beq 2178 <rtems_verror+0x50>
if (rtems_panic_in_progress++)
2140: e59f3124 ldr r3, [pc, #292] ; 226c <rtems_verror+0x144>
2144: e5932000 ldr r2, [r3]
2148: e2821001 add r1, r2, #1
214c: e3520000 cmp r2, #0
2150: e5831000 str r1, [r3]
2154: 0a000003 beq 2168 <rtems_verror+0x40>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
uint32_t level = _Thread_Dispatch_disable_level;
2158: e59f2110 ldr r2, [pc, #272] ; 2270 <rtems_verror+0x148> <== NOT EXECUTED
215c: e5921000 ldr r1, [r2] <== NOT EXECUTED
++level;
2160: e2811001 add r1, r1, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
2164: e5821000 str r1, [r2] <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
2168: e5933000 ldr r3, [r3]
216c: e3530002 cmp r3, #2
return 0;
2170: c3a04000 movgt r4, #0
if (error_flag & RTEMS_ERROR_PANIC) {
if (rtems_panic_in_progress++)
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
2174: ca00003a bgt 2264 <rtems_verror+0x13c>
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
2178: e59f80f4 ldr r8, [pc, #244] ; 2274 <rtems_verror+0x14c>
217c: e5983000 ldr r3, [r8]
2180: e5930008 ldr r0, [r3, #8]
2184: eb002e67 bl db28 <fflush>
status = error_flag & ~RTEMS_ERROR_MASK;
2188: e3c56207 bic r6, r5, #1879048192 ; 0x70000000
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
218c: e2155101 ands r5, r5, #1073741824 ; 0x40000000
2190: 0a000001 beq 219c <rtems_verror+0x74>
local_errno = errno;
2194: eb002d66 bl d734 <__errno>
2198: e5905000 ldr r5, [r0]
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
219c: e5983000 ldr r3, [r8]
21a0: e1a02004 mov r2, r4
21a4: e593000c ldr r0, [r3, #12]
21a8: e1a01007 mov r1, r7
21ac: eb00432e bl 12e6c <vfprintf>
if (status)
21b0: e3560000 cmp r6, #0
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
21b4: e1a04000 mov r4, r0
if (status)
21b8: 0a000009 beq 21e4 <rtems_verror+0xbc>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
21bc: e59f30b0 ldr r3, [pc, #176] ; 2274 <rtems_verror+0x14c>
21c0: e5933000 ldr r3, [r3]
21c4: e1a00006 mov r0, r6
21c8: e593700c ldr r7, [r3, #12]
21cc: ebffffd1 bl 2118 <rtems_status_text>
21d0: e59f10a0 ldr r1, [pc, #160] ; 2278 <rtems_verror+0x150>
21d4: e1a02000 mov r2, r0
21d8: e1a00007 mov r0, r7
21dc: eb002f3e bl dedc <fprintf>
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
21e0: e0844000 add r4, r4, r0
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
21e4: e3550000 cmp r5, #0
21e8: 0a000014 beq 2240 <rtems_verror+0x118>
21ec: e59f6080 ldr r6, [pc, #128] ; 2274 <rtems_verror+0x14c>
if ((local_errno > 0) && *strerror(local_errno))
21f0: da00000c ble 2228 <rtems_verror+0x100>
21f4: e1a00005 mov r0, r5
21f8: eb003302 bl ee08 <strerror>
21fc: e5d03000 ldrb r3, [r0]
2200: e3530000 cmp r3, #0
2204: 0a000007 beq 2228 <rtems_verror+0x100>
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
2208: e5963000 ldr r3, [r6]
220c: e1a00005 mov r0, r5
2210: e593600c ldr r6, [r3, #12]
2214: eb0032fb bl ee08 <strerror>
2218: e59f105c ldr r1, [pc, #92] ; 227c <rtems_verror+0x154>
221c: e1a02000 mov r2, r0
2220: e1a00006 mov r0, r6
2224: ea000003 b 2238 <rtems_verror+0x110>
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
2228: e5963000 ldr r3, [r6]
222c: e59f104c ldr r1, [pc, #76] ; 2280 <rtems_verror+0x158>
2230: e593000c ldr r0, [r3, #12]
2234: e1a02005 mov r2, r5
2238: eb002f27 bl dedc <fprintf>
223c: e0844000 add r4, r4, r0
}
chars_written += fprintf(stderr, "\n");
2240: e59f502c ldr r5, [pc, #44] ; 2274 <rtems_verror+0x14c>
2244: e5953000 ldr r3, [r5]
2248: e59f1034 ldr r1, [pc, #52] ; 2284 <rtems_verror+0x15c>
224c: e593000c ldr r0, [r3, #12]
2250: eb002f21 bl dedc <fprintf>
(void) fflush(stderr);
2254: e5953000 ldr r3, [r5]
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
}
chars_written += fprintf(stderr, "\n");
2258: e0844000 add r4, r4, r0
(void) fflush(stderr);
225c: e593000c ldr r0, [r3, #12]
2260: eb002e30 bl db28 <fflush>
return chars_written;
}
2264: e1a00004 mov r0, r4
2268: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
000206e4 <scanInt>:
/**
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
206e4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
int c; unsigned int i = 0; unsigned int limit = INT_MAX; int sign = 0;
206e8: e3a04000 mov r4, #0
int d;
for (;;) {
c = getc(fp);
206ec: e59fb0dc ldr fp, [pc, #220] ; 207d0 <scanInt+0xec>
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
206f0: e59f90dc ldr r9, [pc, #220] ; 207d4 <scanInt+0xf0>
/**
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
206f4: e1a05000 mov r5, r0 206f8: e1a0a001 mov sl, r1
int c; unsigned int i = 0; unsigned int limit = INT_MAX;
206fc: e3e08102 mvn r8, #-2147483648 ; 0x80000000
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
20700: e1a07004 mov r7, r4
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
20704: e5953004 ldr r3, [r5, #4] 20708: e2433001 sub r3, r3, #1 2070c: e3530000 cmp r3, #0 20710: e5853004 str r3, [r5, #4] 20714: a5953000 ldrge r3, [r5] 20718: a4d36001 ldrbge r6, [r3], #1 2071c: a5853000 strge r3, [r5]
20720: aa000003 bge 20734 <scanInt+0x50>
20724: e59b0000 ldr r0, [fp] <== NOT EXECUTED 20728: e1a01005 mov r1, r5 <== NOT EXECUTED 2072c: eb005a2d bl 36fe8 <__srget_r> <== NOT EXECUTED 20730: e1a06000 mov r6, r0 <== NOT EXECUTED
if (c == ':')
20734: e356003a cmp r6, #58 ; 0x3a
20738: 0a00001a beq 207a8 <scanInt+0xc4>
break;
if (sign == 0) {
2073c: e3540000 cmp r4, #0
20740: 1a000004 bne 20758 <scanInt+0x74>
if (c == '-') {
20744: e356002d cmp r6, #45 ; 0x2d
sign = -1;
limit++;
20748: 02888001 addeq r8, r8, #1
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
2074c: 03e04000 mvneq r4, #0
for (;;) {
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
20750: 0affffeb beq 20704 <scanInt+0x20>
sign = -1;
limit++;
continue;
}
sign = 1;
20754: e3a04001 mov r4, #1
}
if (!isdigit(c))
20758: e5993000 ldr r3, [r9]
2075c: e0833006 add r3, r3, r6
20760: e5d30001 ldrb r0, [r3, #1]
20764: e2100004 ands r0, r0, #4
20768: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return 0;
d = c - '0';
if ((i > (limit / 10))
2076c: e1a00008 mov r0, r8 20770: e3a0100a mov r1, #10 20774: eb00a82a bl 4a824 <__aeabi_uidiv> 20778: e1570000 cmp r7, r0
2077c: 8a00000f bhi 207c0 <scanInt+0xdc>
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
20780: e2466030 sub r6, r6, #48 ; 0x30
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
20784: 1a000004 bne 2079c <scanInt+0xb8>
20788: e1a00008 mov r0, r8 2078c: e3a0100a mov r1, #10 20790: eb00a8bb bl 4aa84 <__umodsi3> 20794: e1560000 cmp r6, r0
20798: 8a000008 bhi 207c0 <scanInt+0xdc>
return 0;
i = i * 10 + d;
2079c: e3a0300a mov r3, #10 207a0: e0276793 mla r7, r3, r7, r6 207a4: eaffffd6 b 20704 <scanInt+0x20>
} if (sign == 0)
207a8: e3540000 cmp r4, #0
return 0;
*val = i * sign;
207ac: 10040497 mulne r4, r7, r4
return 1;
207b0: 13a00001 movne r0, #1
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
*val = i * sign;
207b4: 158a4000 strne r4, [sl]
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
207b8: 18bd8ff0 popne {r4, r5, r6, r7, r8, r9, sl, fp, pc}
207bc: ea000001 b 207c8 <scanInt+0xe4> <== NOT EXECUTED
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
207c0: e3a00000 mov r0, #0
207c4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
i = i * 10 + d;
}
if (sign == 0)
return 0;
207c8: e1a00004 mov r0, r4 <== NOT EXECUTED
*val = i * sign; return 1; }
207cc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00006620 <sigaction>:
struct sigaction *oact
)
{
ISR_Level level;
if ( oact )
6620: e2523000 subs r3, r2, #0
*oact = _POSIX_signals_Vectors[ sig ];
6624: 159f20b4 ldrne r2, [pc, #180] ; 66e0 <sigaction+0xc0>
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
6628: e92d41f0 push {r4, r5, r6, r7, r8, lr}
662c: e1a05001 mov r5, r1
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
6630: 13a0100c movne r1, #12
6634: 10222091 mlane r2, r1, r0, r2
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
6638: e1a04000 mov r4, r0
ISR_Level level;
if ( oact )
*oact = _POSIX_signals_Vectors[ sig ];
663c: 18920007 ldmne r2, {r0, r1, r2}
6640: 18830007 stmne r3, {r0, r1, r2}
if ( !sig )
6644: e3540000 cmp r4, #0
6648: 0a000004 beq 6660 <sigaction+0x40>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
664c: e2443001 sub r3, r4, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
6650: e353001f cmp r3, #31
6654: 8a000001 bhi 6660 <sigaction+0x40>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
6658: e3540009 cmp r4, #9
665c: 1a000004 bne 6674 <sigaction+0x54>
rtems_set_errno_and_return_minus_one( EINVAL );
6660: eb002032 bl e730 <__errno>
6664: e3a03016 mov r3, #22
6668: e5803000 str r3, [r0]
666c: e3e00000 mvn r0, #0
6670: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
6674: e3550000 cmp r5, #0
6678: 0a000016 beq 66d8 <sigaction+0xb8>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
667c: e10f6000 mrs r6, CPSR
6680: e3863080 orr r3, r6, #128 ; 0x80
6684: e129f003 msr CPSR_fc, r3
* Unless the user is installing the default signal actions, then
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
6688: e5953008 ldr r3, [r5, #8]
668c: e3530000 cmp r3, #0
6690: e59f7048 ldr r7, [pc, #72] ; 66e0 <sigaction+0xc0>
6694: e3a0800c mov r8, #12
6698: 1a000006 bne 66b8 <sigaction+0x98>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
669c: e0040498 mul r4, r8, r4
66a0: e59f803c ldr r8, [pc, #60] ; 66e4 <sigaction+0xc4>
66a4: e0873004 add r3, r7, r4
66a8: e0884004 add r4, r8, r4
66ac: e8940007 ldm r4, {r0, r1, r2}
66b0: e8830007 stm r3, {r0, r1, r2}
66b4: ea000004 b 66cc <sigaction+0xac>
} else {
_POSIX_signals_Clear_process_signals( sig );
66b8: e1a00004 mov r0, r4
_POSIX_signals_Vectors[ sig ] = *act;
66bc: e0247498 mla r4, r8, r4, r7
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
66c0: eb00156f bl bc84 <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
66c4: e8950007 ldm r5, {r0, r1, r2}
66c8: e8840007 stm r4, {r0, r1, r2}
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
66cc: e129f006 msr CPSR_fc, r6
* now (signals not posted when SIG_IGN).
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
66d0: e3a00000 mov r0, #0
66d4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
66d8: e1a00005 mov r0, r5 <== NOT EXECUTED
}
66dc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00008a28 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
8a28: e92d4010 push {r4, lr}
8a2c: e1a04001 mov r4, r1
int status;
status = sigtimedwait( set, NULL, NULL );
8a30: e3a01000 mov r1, #0
8a34: e1a02001 mov r2, r1
8a38: ebffff86 bl 8858 <sigtimedwait>
if ( status != -1 ) {
8a3c: e3700001 cmn r0, #1
8a40: 0a000004 beq 8a58 <sigwait+0x30>
if ( sig )
8a44: e3540000 cmp r4, #0
*sig = status;
8a48: 15840000 strne r0, [r4]
return 0;
8a4c: 13a00000 movne r0, #0
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
8a50: 18bd8010 popne {r4, pc}
8a54: ea000002 b 8a64 <sigwait+0x3c> <== NOT EXECUTED
*sig = status;
return 0;
}
return errno;
8a58: eb001f78 bl 10840 <__errno>
8a5c: e5900000 ldr r0, [r0]
8a60: e8bd8010 pop {r4, pc}
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
*sig = status;
return 0;
8a64: e1a00004 mov r0, r4 <== NOT EXECUTED
}
return errno;
}
8a68: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00004e48 <siproc>:
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
4e48: e591203c ldr r2, [r1, #60] ; 0x3c
4e4c: e59f304c ldr r3, [pc, #76] ; 4ea0 <siproc+0x58>
4e50: e0023003 and r3, r2, r3
4e54: e3530000 cmp r3, #0
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
4e58: e92d4030 push {r4, r5, lr}
4e5c: e1a04001 mov r4, r1
4e60: e1a05000 mov r5, r0
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
4e64: 0a00000b beq 4e98 <siproc+0x50>
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4e68: e5910018 ldr r0, [r1, #24]
4e6c: e3a01000 mov r1, #0
4e70: e1a02001 mov r2, r1
4e74: eb00044a bl 5fa4 <rtems_semaphore_obtain>
i = iproc (c, tty);
4e78: e1a01004 mov r1, r4
4e7c: e1a00005 mov r0, r5
4e80: ebffff8b bl 4cb4 <iproc>
4e84: e1a05000 mov r5, r0
rtems_semaphore_release (tty->osem);
4e88: e5940018 ldr r0, [r4, #24]
4e8c: eb00048b bl 60c0 <rtems_semaphore_release>
}
else {
i = iproc (c, tty);
}
return i;
}
4e90: e1a00005 mov r0, r5
4e94: e8bd8030 pop {r4, r5, pc}
4e98: 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);
4e9c: eaffff84 b 4cb4 <iproc> <== NOT EXECUTED
0000ce0c <sparse_disk_ioctl>:
/*
* ioctl handler to be passed to the block device handler
*/
static int sparse_disk_ioctl( rtems_disk_device *dd, uint32_t req, void *argp )
{
ce0c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_status_code sc;
rtems_sparse_disk *sd = rtems_disk_get_driver_data( dd );
if ( RTEMS_BLKIO_REQUEST == req ) {
ce10: e59fc244 ldr ip, [pc, #580] ; d05c <sparse_disk_ioctl+0x250>
ce14: e151000c cmp r1, ip
/*
* ioctl handler to be passed to the block device handler
*/
static int sparse_disk_ioctl( rtems_disk_device *dd, uint32_t req, void *argp )
{
ce18: e24dd018 sub sp, sp, #24
ce1c: e1a05002 mov r5, r2
static inline void *rtems_disk_get_driver_data(
const rtems_disk_device *dd
)
{
return dd->driver_data;
ce20: e590403c ldr r4, [r0, #60] ; 0x3c
rtems_status_code sc;
rtems_sparse_disk *sd = rtems_disk_get_driver_data( dd );
if ( RTEMS_BLKIO_REQUEST == req ) {
ce24: 1a000072 bne cff4 <sparse_disk_ioctl+0x1e8>
rtems_blkdev_request *r = argp;
switch ( r->req ) {
ce28: e5921000 ldr r1, [r2]
ce2c: e3510001 cmp r1, #1
ce30: e58d1004 str r1, [sp, #4]
ce34: 8a000082 bhi d044 <sparse_disk_ioctl+0x238>
rtems_blkdev_bnum block;
uint8_t *buff;
size_t buff_size;
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
ce38: e3a01000 mov r1, #0
ce3c: e5940000 ldr r0, [r4]
ce40: e1a02001 mov r2, r1
static int sparse_disk_read_write(
rtems_sparse_disk *sparse_disk,
rtems_blkdev_request *req,
const bool read )
{
int rv = 0;
ce44: e3a0b000 mov fp, #0
rtems_blkdev_bnum block;
uint8_t *buff;
size_t buff_size;
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
ce48: ebffec8c bl 8080 <rtems_semaphore_obtain>
for ( req_buffer = 0;
ce4c: e1a0900b mov r9, fp
ce50: ea000059 b cfbc <sparse_disk_ioctl+0x1b0>
( 0 <= rv ) && ( req_buffer < req->bufnum );
++req_buffer ) {
scatter_gather = &req->bufs[req_buffer];
ce54: e1a02209 lsl r2, r9, #4
ce58: e2822018 add r2, r2, #24
ce5c: e0853002 add r3, r5, r2
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
ce60: e5931008 ldr r1, [r3, #8]
ce64: e58d900c str r9, [sp, #12]
ce68: e58d1008 str r1, [sp, #8]
block = scatter_gather->block;
ce6c: e7957002 ldr r7, [r5, r2]
buff_size = scatter_gather->length;
ce70: e5936004 ldr r6, [r3, #4]
for ( req_buffer = 0;
( 0 <= rv ) && ( req_buffer < req->bufnum );
++req_buffer ) {
scatter_gather = &req->bufs[req_buffer];
bytes_handled = 0;
ce74: e3a0a000 mov sl, #0
ce78: e1a09005 mov r9, r5
ce7c: ea000043 b cf90 <sparse_disk_ioctl+0x184>
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
if ( read )
ce80: e59d3004 ldr r3, [sp, #4]
ce84: e59d1008 ldr r1, [sp, #8]
ce88: e3530000 cmp r3, #0
ce8c: e081500a add r5, r1, sl
const rtems_blkdev_bnum block,
uint8_t *buffer,
const size_t buffer_size )
{
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
ce90: e58d7010 str r7, [sp, #16]
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
if ( read )
ce94: 1a000012 bne cee4 <sparse_disk_ioctl+0xd8>
const rtems_blkdev_bnum block,
uint8_t *buffer,
const size_t buffer_size )
{
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
ce98: e58d3014 str r3, [sp, #20]
size_t bytes_to_copy = sparse_disk->media_block_size;
if ( buffer_size < bytes_to_copy )
bytes_to_copy = buffer_size;
key = bsearch(
ce9c: e59f31bc ldr r3, [pc, #444] ; d060 <sparse_disk_ioctl+0x254>
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
.block = block,
.data = NULL
};
size_t bytes_to_copy = sparse_disk->media_block_size;
cea0: e594b00c ldr fp, [r4, #12]
if ( buffer_size < bytes_to_copy )
bytes_to_copy = buffer_size;
key = bsearch(
cea4: e58d3000 str r3, [sp]
cea8: e28d0010 add r0, sp, #16
ceac: e5941018 ldr r1, [r4, #24]
ceb0: e3a03008 mov r3, #8
ceb4: e5942008 ldr r2, [r4, #8]
ceb8: eb002e4b bl 187ec <bsearch>
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
.block = block,
.data = NULL
};
size_t bytes_to_copy = sparse_disk->media_block_size;
cebc: e156000b cmp r6, fp
cec0: 31a0b006 movcc fp, r6
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL != key )
cec4: e2503000 subs r3, r0, #0
memcpy( buffer, key->data, bytes_to_copy );
cec8: 15931004 ldrne r1, [r3, #4]
cecc: e1a00005 mov r0, r5
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL != key )
ced0: 1a000029 bne cf7c <sparse_disk_ioctl+0x170>
memcpy( buffer, key->data, bytes_to_copy );
else
memset( buffer, sparse_disk->fill_pattern, buffer_size );
ced4: e5d41014 ldrb r1, [r4, #20]
ced8: e1a02006 mov r2, r6
cedc: eb00313e bl 193dc <memset>
cee0: ea000027 b cf84 <sparse_disk_ioctl+0x178>
/* we only need to write the block if it is different from the fill pattern.
* If the read method does not find a block it will deliver the fill pattern anyway.
*/
key = bsearch(
cee4: e59f3174 ldr r3, [pc, #372] ; d060 <sparse_disk_ioctl+0x254>
const size_t buffer_size )
{
unsigned int i;
bool block_needs_writing = false;
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
cee8: e3a01000 mov r1, #0
.block = block,
.data = NULL
};
size_t bytes_to_copy = sparse_disk->media_block_size;
ceec: e594b00c ldr fp, [r4, #12]
const size_t buffer_size )
{
unsigned int i;
bool block_needs_writing = false;
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
cef0: e58d1014 str r1, [sp, #20]
/* we only need to write the block if it is different from the fill pattern.
* If the read method does not find a block it will deliver the fill pattern anyway.
*/
key = bsearch(
cef4: e58d3000 str r3, [sp]
cef8: e28d0010 add r0, sp, #16
cefc: e5941018 ldr r1, [r4, #24]
cf00: e5942008 ldr r2, [r4, #8]
cf04: e3a03008 mov r3, #8
cf08: eb002e37 bl 187ec <bsearch>
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
.block = block,
.data = NULL
};
size_t bytes_to_copy = sparse_disk->media_block_size;
cf0c: e156000b cmp r6, fp
cf10: 31a0b006 movcc fp, r6
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
cf14: e2508000 subs r8, r0, #0
cf18: 1a000015 bne cf74 <sparse_disk_ioctl+0x168>
cf1c: ea000004 b cf34 <sparse_disk_ioctl+0x128>
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
if ( buffer[i] != sparse_disk->fill_pattern )
cf20: e7d53008 ldrb r3, [r5, r8]
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
cf24: e5d42014 ldrb r2, [r4, #20]
cf28: e1520003 cmp r2, r3
cf2c: e2888001 add r8, r8, #1
cf30: 1a000002 bne cf40 <sparse_disk_ioctl+0x134>
cf34: e158000b cmp r8, fp
cf38: 1afffff8 bne cf20 <sparse_disk_ioctl+0x114>
cf3c: ea000010 b cf84 <sparse_disk_ioctl+0x178>
rtems_sparse_disk *sparse_disk,
const rtems_blkdev_bnum block )
{
rtems_sparse_disk_key *key;
if ( sparse_disk->used_count < sparse_disk->blocks_with_buffer ) {
cf40: e5941008 ldr r1, [r4, #8]
cf44: e5943004 ldr r3, [r4, #4]
cf48: e1510003 cmp r1, r3
}
if ( NULL != key )
memcpy( key->data, buffer, bytes_to_copy );
else if ( block_needs_writing )
return -1;
cf4c: 23e0b000 mvncs fp, #0
rtems_sparse_disk *sparse_disk,
const rtems_blkdev_bnum block )
{
rtems_sparse_disk_key *key;
if ( sparse_disk->used_count < sparse_disk->blocks_with_buffer ) {
cf50: 2a00000b bcs cf84 <sparse_disk_ioctl+0x178>
key = &sparse_disk->key_table[sparse_disk->used_count];
cf54: e5940018 ldr r0, [r4, #24]
key->block = block;
cf58: e7807181 str r7, [r0, r1, lsl #3]
const rtems_blkdev_bnum block )
{
rtems_sparse_disk_key *key;
if ( sparse_disk->used_count < sparse_disk->blocks_with_buffer ) {
key = &sparse_disk->key_table[sparse_disk->used_count];
cf5c: e0808181 add r8, r0, r1, lsl #3
key->block = block;
++sparse_disk->used_count;
cf60: e2811001 add r1, r1, #1
cf64: e5841008 str r1, [r4, #8]
qsort( sparse_disk->key_table, sparse_disk->used_count,
cf68: e3a02008 mov r2, #8
cf6c: e59f30ec ldr r3, [pc, #236] ; d060 <sparse_disk_ioctl+0x254>
cf70: eb003155 bl 194cc <qsort>
key = sparse_disk_get_new_block( sparse_disk, block );
}
}
if ( NULL != key )
memcpy( key->data, buffer, bytes_to_copy );
cf74: e5980004 ldr r0, [r8, #4]
cf78: e1a01005 mov r1, r5
cf7c: e1a0200b mov r2, fp
cf80: eb0030df bl 19304 <memcpy>
rv = sparse_disk_write_block( sparse_disk,
block,
&buff[bytes_handled],
buff_size );
++block;
cf84: e2877001 add r7, r7, #1
bytes_handled += rv;
cf88: e08aa00b add sl, sl, fp
buff_size -= rv;
cf8c: e06b6006 rsb r6, fp, r6
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
cf90: e2963000 adds r3, r6, #0
cf94: 13a03001 movne r3, #1
cf98: e35b0000 cmp fp, #0
cf9c: b3a03000 movlt r3, #0
cfa0: e3530000 cmp r3, #0
cfa4: 1affffb5 bne ce80 <sparse_disk_ioctl+0x74>
cfa8: e1a05009 mov r5, r9
cfac: e59d900c ldr r9, [sp, #12]
size_t buff_size;
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
cfb0: e35b0000 cmp fp, #0
( 0 <= rv ) && ( req_buffer < req->bufnum );
++req_buffer ) {
cfb4: e2899001 add r9, r9, #1
size_t buff_size;
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
cfb8: ba000002 blt cfc8 <sparse_disk_ioctl+0x1bc>
( 0 <= rv ) && ( req_buffer < req->bufnum );
cfbc: e5953010 ldr r3, [r5, #16]
cfc0: e1590003 cmp r9, r3
cfc4: 3affffa2 bcc ce54 <sparse_disk_ioctl+0x48>
bytes_handled += rv;
buff_size -= rv;
}
}
rtems_semaphore_release( sparse_disk->mutex );
cfc8: e5940000 ldr r0, [r4]
cfcc: ebffec72 bl 819c <rtems_semaphore_release>
if ( 0 > rv )
cfd0: e35b0000 cmp fp, #0
static inline void rtems_blkdev_request_done(
rtems_blkdev_request *req,
rtems_status_code status
)
{
(*req->done)(req, status);
cfd4: e1a00005 mov r0, r5
cfd8: e5953004 ldr r3, [r5, #4]
cfdc: b3a0101b movlt r1, #27
cfe0: a3a01000 movge r1, #0
cfe4: e1a0e00f mov lr, pc
cfe8: e12fff13 bx r3
rtems_blkdev_request *r = argp;
switch ( r->req ) {
case RTEMS_BLKDEV_REQ_READ:
case RTEMS_BLKDEV_REQ_WRITE:
return sparse_disk_read_write( sd, r, r->req == RTEMS_BLKDEV_REQ_READ );
cfec: e3a00000 mov r0, #0
cff0: ea000017 b d054 <sparse_disk_ioctl+0x248>
default:
break;
}
} else if ( RTEMS_BLKIO_DELETED == req ) {
cff4: e59fc068 ldr ip, [pc, #104] ; d064 <sparse_disk_ioctl+0x258>
cff8: e151000c cmp r1, ip
cffc: 1a00000e bne d03c <sparse_disk_ioctl+0x230>
sc = rtems_semaphore_delete( sd->mutex );
d000: e5940000 ldr r0, [r4]
d004: ebffebf6 bl 7fe4 <rtems_semaphore_delete>
if ( RTEMS_SUCCESSFUL != sc )
d008: e2505000 subs r5, r0, #0
rtems_fatal_error_occurred( 0xdeadbeef );
d00c: 159f0054 ldrne r0, [pc, #84] ; d068 <sparse_disk_ioctl+0x25c>
d010: 1bffedf2 blne 87e0 <rtems_fatal_error_occurred>
sd->mutex = RTEMS_ID_NONE;
if ( NULL != sd->delete_handler )
d014: e5943010 ldr r3, [r4, #16]
d018: e3530000 cmp r3, #0
sc = rtems_semaphore_delete( sd->mutex );
if ( RTEMS_SUCCESSFUL != sc )
rtems_fatal_error_occurred( 0xdeadbeef );
sd->mutex = RTEMS_ID_NONE;
d01c: e5845000 str r5, [r4]
if ( NULL != sd->delete_handler )
( *sd->delete_handler )( sd );
return 0;
d020: 01a00003 moveq r0, r3
if ( RTEMS_SUCCESSFUL != sc )
rtems_fatal_error_occurred( 0xdeadbeef );
sd->mutex = RTEMS_ID_NONE;
if ( NULL != sd->delete_handler )
d024: 0a00000a beq d054 <sparse_disk_ioctl+0x248>
( *sd->delete_handler )( sd );
d028: e1a00004 mov r0, r4
d02c: e1a0e00f mov lr, pc
d030: e12fff13 bx r3
return 0;
d034: e1a00005 mov r0, r5
d038: ea000005 b d054 <sparse_disk_ioctl+0x248>
} else {
return rtems_blkdev_ioctl( dd, req, argp );
d03c: eb000a94 bl fa94 <rtems_blkdev_ioctl>
d040: ea000003 b d054 <sparse_disk_ioctl+0x248>
}
errno = EINVAL;
d044: eb002e07 bl 18868 <__errno> <== NOT EXECUTED
d048: e3a03016 mov r3, #22 <== NOT EXECUTED
d04c: e5803000 str r3, [r0] <== NOT EXECUTED
return -1;
d050: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
d054: e28dd018 add sp, sp, #24
d058: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000594c <sysconf>:
long sysconf(
int name
)
{
if ( name == _SC_CLK_TCK )
594c: e3500002 cmp r0, #2
*/
long sysconf(
int name
)
{
5950: e52de004 push {lr} ; (str lr, [sp, #-4]!)
if ( name == _SC_CLK_TCK )
5954: 1a000004 bne 596c <sysconf+0x20>
return (TOD_MICROSECONDS_PER_SECOND /
5958: e59f3058 ldr r3, [pc, #88] ; 59b8 <sysconf+0x6c>
595c: e59f0058 ldr r0, [pc, #88] ; 59bc <sysconf+0x70>
5960: e593100c ldr r1, [r3, #12]
5964: eb00442b bl 16a18 <__aeabi_uidiv>
5968: e49df004 pop {pc} ; (ldr pc, [sp], #4)
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
596c: e3500004 cmp r0, #4
return rtems_libio_number_iops;
5970: 059f3048 ldreq r3, [pc, #72] ; 59c0 <sysconf+0x74>
5974: 05930000 ldreq r0, [r3]
{
if ( name == _SC_CLK_TCK )
return (TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
5978: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
597c: e3500033 cmp r0, #51 ; 0x33
return 1024;
5980: 03a00b01 moveq r0, #1024 ; 0x400
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
5984: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
return 1024;
if ( name == _SC_PAGESIZE )
5988: e3500008 cmp r0, #8
return PAGE_SIZE;
598c: 03a00a01 moveq r0, #4096 ; 0x1000
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
return 1024;
if ( name == _SC_PAGESIZE )
5990: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
return PAGE_SIZE;
if ( name == _SC_SYMLOOP_MAX )
5994: e350004f cmp r0, #79 ; 0x4f
5998: 0a000004 beq 59b0 <sysconf+0x64>
#if defined(__sparc__)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
599c: eb00202c bl da54 <__errno>
59a0: e3a03016 mov r3, #22
59a4: e5803000 str r3, [r0]
59a8: e3e00000 mvn r0, #0
59ac: e49df004 pop {pc} ; (ldr pc, [sp], #4)
if ( name == _SC_PAGESIZE )
return PAGE_SIZE;
if ( name == _SC_SYMLOOP_MAX )
return RTEMS_FILESYSTEM_SYMLOOP_MAX;
59b0: e3a00020 mov r0, #32 <== NOT EXECUTED
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
}
59b4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00018adc <write>:
size_t count
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
18adc: e59fc07c ldr ip, [pc, #124] ; 18b60 <bsp_section_text_size+0x38> 18ae0: e59cc000 ldr ip, [ip] 18ae4: e150000c cmp r0, ip
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
18ae8: e92d4030 push {r4, r5, lr}
18aec: e1a04001 mov r4, r1
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
18af0: 2a00000f bcs 18b34 <bsp_section_text_size+0xc>
iop = rtems_libio_iop( fd );
18af4: e59fc068 ldr ip, [pc, #104] ; 18b64 <bsp_section_text_size+0x3c> 18af8: e59cc000 ldr ip, [ip] 18afc: e3a05030 mov r5, #48 ; 0x30 18b00: e020c095 mla r0, r5, r0, ip
rtems_libio_check_is_open( iop );
18b04: e590c00c ldr ip, [r0, #12] 18b08: e31c0c01 tst ip, #256 ; 0x100
18b0c: 0a000008 beq 18b34 <bsp_section_text_size+0xc> rtems_libio_check_buffer( buffer );
18b10: e3510000 cmp r1, #0
18b14: 1a000002 bne 18b24 <write+0x48>
18b18: ebffd305 bl d734 <__errno> <== NOT EXECUTED 18b1c: e3a03016 mov r3, #22 <== NOT EXECUTED 18b20: ea000005 b 18b3c <bsp_section_text_size+0x14> <== NOT EXECUTED
rtems_libio_check_count( count );
18b24: e3520000 cmp r2, #0
18b28: 0a00000a beq 18b58 <bsp_section_text_size+0x30> rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
18b2c: e31c0004 tst ip, #4
18b30: 1a000004 bne 18b48 <bsp_section_text_size+0x20>
18b34: ebffd2fe bl d734 <__errno>
18b38: e3a03009 mov r3, #9
18b3c: e5803000 str r3, [r0]
18b40: e3e00000 mvn r0, #0
18b44: e8bd8030 pop {r4, r5, pc}
/*
* Now process the write() request.
*/
return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
18b48: e5903020 ldr r3, [r0, #32]
18b4c: e1a0e00f mov lr, pc
18b50: e593f00c ldr pc, [r3, #12]
18b54: e8bd8030 pop {r4, r5, pc}
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
18b58: e1a00002 mov r0, r2
/*
* Now process the write() request.
*/
return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
}
18b5c: e8bd8030 pop {r4, r5, pc}