000044dc <IMFS_dump_directory>:
*/
static void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
44dc: e92d41f0 push {r4, r5, r6, r7, r8, lr}
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
44e0: e5907050 ldr r7, [r0, #80] ; 0x50
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 ));
44e4: e2808054 add r8, r0, #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 );
44e8: e1570008 cmp r7, r8
*/
static void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
44ec: e1a06001 mov r6, r1
44f0: 159f516c ldrne r5, [pc, #364] ; 4664 <IMFS_dump_directory+0x188>
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 );
44f4: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
!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++ )
44f8: e3560000 cmp r6, #0
44fc: a3a04000 movge r4, #0
4500: ba000008 blt 4528 <IMFS_dump_directory+0x4c>
fprintf(stdout, "...." );
4504: e5953000 ldr r3, [r5]
4508: e3a01001 mov r1, #1
!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++ )
450c: e0844001 add r4, r4, r1
fprintf(stdout, "...." );
4510: e59f0150 ldr r0, [pc, #336] ; 4668 <IMFS_dump_directory+0x18c>
4514: e3a02004 mov r2, #4
4518: e5933008 ldr r3, [r3, #8]
451c: eb003827 bl 125c0 <fwrite>
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
4520: e1560004 cmp r6, r4
4524: aafffff6 bge 4504 <IMFS_dump_directory+0x28>
IMFS_jnode_t *the_jnode
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
4528: e5953000 ldr r3, [r5]
452c: e287000c add r0, r7, #12
4530: e5931008 ldr r1, [r3, #8]
4534: eb003510 bl 1197c <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;
4538: e597304c ldr r3, [r7, #76] ; 0x4c
453c: e5932000 ldr r2, [r3]
switch( IMFS_type( the_jnode ) ) {
4540: e3520006 cmp r2, #6
4544: 979ff102 ldrls pc, [pc, r2, lsl #2]
4548: ea000033 b 461c <IMFS_dump_directory+0x140> <== NOT EXECUTED
454c: 00004608 .word 0x00004608 <== NOT EXECUTED
4550: 000045e4 .word 0x000045e4 <== NOT EXECUTED
4554: 00004568 .word 0x00004568 <== NOT EXECUTED
4558: 00004568 .word 0x00004568 <== NOT EXECUTED
455c: 0000464c .word 0x0000464c <== NOT EXECUTED
4560: 00004630 .word 0x00004630 <== NOT EXECUTED
4564: 000045a0 .word 0x000045a0 <== NOT EXECUTED
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
4568: e5953000 ldr r3, [r5]
456c: e3a01001 mov r1, #1
4570: e3a02013 mov r2, #19
4574: e5933008 ldr r3, [r3, #8]
4578: e59f00ec ldr r0, [pc, #236] ; 466c <IMFS_dump_directory+0x190>
457c: eb00380f bl 125c0 <fwrite>
}
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )
{
return node->control->imfs_type == IMFS_DIRECTORY;
4580: e597304c ldr r3, [r7, #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 ) )
4584: e5933000 ldr r3, [r3]
4588: e3530000 cmp r3, #0
458c: 0a00000d beq 45c8 <IMFS_dump_directory+0xec>
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 ) {
4590: e5977000 ldr r7, [r7]
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 );
4594: e1570008 cmp r7, r8
4598: 1affffd6 bne 44f8 <IMFS_dump_directory+0x1c>
459c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
45a0: e5953000 ldr r3, [r5]
45a4: e3a01001 mov r1, #1
45a8: e5933008 ldr r3, [r3, #8]
45ac: e3a02012 mov r2, #18
45b0: e59f00b8 ldr r0, [pc, #184] ; 4670 <IMFS_dump_directory+0x194>
45b4: eb003801 bl 125c0 <fwrite>
45b8: e597304c ldr r3, [r7, #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 ) )
45bc: e5933000 ldr r3, [r3]
45c0: e3530000 cmp r3, #0
45c4: 1afffff1 bne 4590 <IMFS_dump_directory+0xb4>
IMFS_dump_directory( the_jnode, level + 1 );
45c8: e1a00007 mov r0, r7
45cc: e2861001 add r1, r6, #1
45d0: ebffffc1 bl 44dc <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 ) {
45d4: e5977000 ldr r7, [r7]
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 );
45d8: e1570008 cmp r7, r8
45dc: 1affffc5 bne 44f8 <IMFS_dump_directory+0x1c>
45e0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
45e4: e5953000 ldr r3, [r5]
45e8: e2872050 add r2, r7, #80 ; 0x50
45ec: e5930008 ldr r0, [r3, #8]
45f0: e59f107c ldr r1, [pc, #124] ; 4674 <IMFS_dump_directory+0x198>
45f4: e892000c ldm r2, {r2, r3}
45f8: eb00348a bl 11828 <fprintf>
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
return;
}
puts("");
45fc: e59f0074 ldr r0, [pc, #116] ; 4678 <IMFS_dump_directory+0x19c>
4600: eb003bdb bl 13574 <puts>
4604: eaffffdd b 4580 <IMFS_dump_directory+0xa4>
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( IMFS_type( the_jnode ) ) {
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
4608: e5953000 ldr r3, [r5]
460c: e3a0002f mov r0, #47 ; 0x2f
4610: e5931008 ldr r1, [r3, #8]
4614: eb0034a3 bl 118a8 <fputc>
4618: eafffff7 b 45fc <IMFS_dump_directory+0x120>
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
461c: e5953000 ldr r3, [r5] <== NOT EXECUTED
4620: e59f1054 ldr r1, [pc, #84] ; 467c <IMFS_dump_directory+0x1a0><== NOT EXECUTED
4624: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
4628: eb00347e bl 11828 <fprintf> <== NOT EXECUTED
462c: eaffffd3 b 4580 <IMFS_dump_directory+0xa4> <== NOT EXECUTED
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
4630: e5953000 ldr r3, [r5]
4634: e59f1044 ldr r1, [pc, #68] ; 4680 <IMFS_dump_directory+0x1a4>
4638: e5930008 ldr r0, [r3, #8]
463c: e5972050 ldr r2, [r7, #80] ; 0x50
4640: e5973058 ldr r3, [r7, #88] ; 0x58
4644: eb003477 bl 11828 <fprintf>
4648: eaffffeb b 45fc <IMFS_dump_directory+0x120>
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
464c: e5953000 ldr r3, [r5]
4650: e59f102c ldr r1, [pc, #44] ; 4684 <IMFS_dump_directory+0x1a8>
4654: e5930008 ldr r0, [r3, #8]
4658: e5972050 ldr r2, [r7, #80] ; 0x50
465c: eb003471 bl 11828 <fprintf>
4660: eaffffe5 b 45fc <IMFS_dump_directory+0x120>
0000a75c <IMFS_fsunmount>:
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
void IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
a75c: e92d4070 push {r4, r5, r6, lr}
/*
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
loc = temp_mt_entry->mt_fs_root->location;
a760: e5905024 ldr r5, [r0, #36] ; 0x24
a764: e1a04005 mov r4, r5
a768: e8b4000f ldm r4!, {r0, r1, r2, r3}
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
void IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
a76c: e24dd018 sub sp, sp, #24
/*
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
loc = temp_mt_entry->mt_fs_root->location;
a770: e1a0c00d mov ip, sp
a774: e8ac000f stmia ip!, {r0, r1, r2, r3}
a778: e8940003 ldm r4, {r0, r1}
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root->location.node_access = NULL;
a77c: e592304c ldr r3, [r2, #76] ; 0x4c
/*
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
loc = temp_mt_entry->mt_fs_root->location;
a780: e88c0003 stm ip, {r0, r1}
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root->location.node_access = NULL;
a784: e3a01000 mov r1, #0
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
loc = temp_mt_entry->mt_fs_root->location;
jnode = (IMFS_jnode_t *)loc.node_access;
a788: e1a06002 mov r6, r2
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root->location.node_access = NULL;
a78c: e5932000 ldr r2, [r3]
a790: e5851008 str r1, [r5, #8]
a794: e5933004 ldr r3, [r3, #4]
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
a798: e3520000 cmp r2, #0
*/
temp_mt_entry->mt_fs_root->location.node_access = NULL;
do {
next = jnode->Parent;
a79c: e5964008 ldr r4, [r6, #8]
loc.node_access = (void *)jnode;
a7a0: e58d6008 str r6, [sp, #8]
a7a4: e58d3010 str r3, [sp, #16]
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
a7a8: 1a000018 bne a810 <IMFS_fsunmount+0xb4>
a7ac: e5962050 ldr r2, [r6, #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 );
a7b0: e2863054 add r3, r6, #84 ; 0x54
a7b4: e1520003 cmp r2, r3
a7b8: 0a000014 beq a810 <IMFS_fsunmount+0xb4>
if ( result != 0 )
rtems_fatal_error_occurred( 0xdeadbeef );
IMFS_node_destroy( jnode );
jnode = next;
}
if ( jnode != NULL ) {
a7bc: e3560000 cmp r6, #0
a7c0: 0a00001c beq a838 <IMFS_fsunmount+0xdc>
return node->control->imfs_type;
}
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )
{
return node->control->imfs_type == IMFS_DIRECTORY;
a7c4: e596304c ldr r3, [r6, #76] ; 0x4c
a7c8: e5932000 ldr r2, [r3]
if ( IMFS_is_directory( jnode ) ) {
a7cc: e3520000 cmp r2, #0
a7d0: 1affffef bne a794 <IMFS_fsunmount+0x38>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
a7d4: e5961050 ldr r1, [r6, #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 );
a7d8: e2860054 add r0, r6, #84 ; 0x54
if ( jnode_has_children( jnode ) )
a7dc: e1510000 cmp r1, r0
a7e0: 0affffeb beq a794 <IMFS_fsunmount+0x38>
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
a7e4: e3510000 cmp r1, #0
a7e8: 0a000012 beq a838 <IMFS_fsunmount+0xdc>
a7ec: e591304c ldr r3, [r1, #76] ; 0x4c
a7f0: e5932000 ldr r2, [r3]
static inline void IMFS_Set_handlers( rtems_filesystem_location_info_t *loc )
{
IMFS_jnode_t *node = (IMFS_jnode_t *) loc->node_access;
loc->handlers = node->control->handlers;
a7f4: e5933004 ldr r3, [r3, #4]
a7f8: e1a06001 mov r6, r1
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
a7fc: e3520000 cmp r2, #0
*/
temp_mt_entry->mt_fs_root->location.node_access = NULL;
do {
next = jnode->Parent;
a800: e5964008 ldr r4, [r6, #8]
loc.node_access = (void *)jnode;
a804: e58d6008 str r6, [sp, #8]
a808: e58d3010 str r3, [sp, #16]
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
a80c: 0affffe6 beq a7ac <IMFS_fsunmount+0x50>
result = IMFS_rmnod( NULL, &loc );
a810: e3a00000 mov r0, #0
a814: e1a0100d mov r1, sp
a818: ebffde0b bl 204c <IMFS_rmnod>
if ( result != 0 )
a81c: e3500000 cmp r0, #0
a820: 1a000006 bne a840 <IMFS_fsunmount+0xe4>
rtems_fatal_error_occurred( 0xdeadbeef );
IMFS_node_destroy( jnode );
a824: e1a00006 mov r0, r6
jnode = next;
a828: e1a06004 mov r6, r4
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
result = IMFS_rmnod( NULL, &loc );
if ( result != 0 )
rtems_fatal_error_occurred( 0xdeadbeef );
IMFS_node_destroy( jnode );
a82c: ebffdd34 bl 1d04 <IMFS_node_destroy>
jnode = next;
}
if ( jnode != NULL ) {
a830: e3560000 cmp r6, #0
a834: 1affffe2 bne a7c4 <IMFS_fsunmount+0x68>
if ( jnode_has_children( jnode ) )
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
}
a838: e28dd018 add sp, sp, #24
a83c: e8bd8070 pop {r4, r5, r6, pc}
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
result = IMFS_rmnod( NULL, &loc );
if ( result != 0 )
rtems_fatal_error_occurred( 0xdeadbeef );
a840: e59f0000 ldr r0, [pc] ; a848 <IMFS_fsunmount+0xec> <== NOT EXECUTED
a844: ebfff144 bl 6d5c <rtems_fatal_error_occurred> <== NOT EXECUTED
00003874 <IMFS_make_generic_node>:
void *context
)
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
3874: e59fc108 ldr ip, [pc, #264] ; 3984 <IMFS_make_generic_node+0x110>
3878: e59cc000 ldr ip, [ip]
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
387c: e92d40f0 push {r4, r5, r6, r7, lr}
int rv = 0;
mode &= ~rtems_filesystem_umask;
3880: e59c4008 ldr r4, [ip, #8]
3884: e1c14004 bic r4, r1, r4
switch (mode & S_IFMT) {
3888: e204ca0f and ip, r4, #61440 ; 0xf000
388c: e35c0a02 cmp ip, #8192 ; 0x2000
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
3890: e24dd05c sub sp, sp, #92 ; 0x5c
3894: e1a05002 mov r5, r2
3898: e1a06003 mov r6, r3
int rv = 0;
mode &= ~rtems_filesystem_umask;
switch (mode & S_IFMT) {
389c: 0a00000d beq 38d8 <IMFS_make_generic_node+0x64>
38a0: 8a000008 bhi 38c8 <IMFS_make_generic_node+0x54>
38a4: e35c0a01 cmp ip, #4096 ; 0x1000 <== NOT EXECUTED
38a8: 0a00000a beq 38d8 <IMFS_make_generic_node+0x64> <== NOT EXECUTED
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
} else {
errno = EINVAL;
38ac: eb003a79 bl 12298 <__errno>
38b0: e3a03016 mov r3, #22
38b4: e5803000 str r3, [r0]
rv = -1;
38b8: e3e05000 mvn r5, #0
}
}
return rv;
}
38bc: e1a00005 mov r0, r5
38c0: e28dd05c add sp, sp, #92 ; 0x5c
38c4: e8bd80f0 pop {r4, r5, r6, r7, pc}
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
switch (mode & S_IFMT) {
38c8: e35c0a06 cmp ip, #24576 ; 0x6000
38cc: 0a000001 beq 38d8 <IMFS_make_generic_node+0x64>
38d0: e35c0902 cmp ip, #32768 ; 0x8000
38d4: 1afffff4 bne 38ac <IMFS_make_generic_node+0x38>
rv = -1;
break;
}
if ( rv == 0 ) {
if ( node_control->imfs_type == IMFS_GENERIC ) {
38d8: e5953000 ldr r3, [r5]
38dc: e3530007 cmp r3, #7
38e0: 1afffff1 bne 38ac <IMFS_make_generic_node+0x38>
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 =
38e4: e1a01000 mov r1, r0
38e8: e3a02078 mov r2, #120 ; 0x78
38ec: e28d0008 add r0, sp, #8
38f0: eb0007fb bl 58e4 <rtems_filesystem_eval_path_start>
38f4: e1a07000 mov r7, r0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
38f8: ebffffcb bl 382c <IMFS_is_imfs_instance>
38fc: e3500000 cmp r0, #0
3900: 0a00001a beq 3970 <IMFS_make_generic_node+0xfc>
IMFS_types_union info;
IMFS_jnode_t *new_node;
info.generic.context = context;
new_node = IMFS_create_node_with_control(
3904: e28d2010 add r2, sp, #16
3908: e892000c ldm r2, {r2, r3}
390c: e1a01005 mov r1, r5
3910: e28dc040 add ip, sp, #64 ; 0x40
3914: e1a00007 mov r0, r7
if ( IMFS_is_imfs_instance( currentloc ) ) {
IMFS_types_union info;
IMFS_jnode_t *new_node;
info.generic.context = context;
3918: e58d6040 str r6, [sp, #64] ; 0x40
new_node = IMFS_create_node_with_control(
391c: e58d4000 str r4, [sp]
3920: e58dc004 str ip, [sp, #4]
3924: eb002d13 bl ed78 <IMFS_create_node_with_control>
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
mode,
&info
);
if ( new_node != NULL ) {
3928: e3500000 cmp r0, #0
IMFS_jnode_t *parent = currentloc->node_access;
IMFS_update_ctime( parent );
IMFS_update_mtime( parent );
} else {
rv = -1;
392c: 03e05000 mvneq r5, #0
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
mode,
&info
);
if ( new_node != NULL ) {
3930: 0a00000b beq 3964 <IMFS_make_generic_node+0xf0>
IMFS_jnode_t *parent = currentloc->node_access;
IMFS_update_ctime( parent );
3934: e3a01000 mov r1, #0
3938: e28d0054 add r0, sp, #84 ; 0x54
mode,
&info
);
if ( new_node != NULL ) {
IMFS_jnode_t *parent = currentloc->node_access;
393c: e5974008 ldr r4, [r7, #8]
IMFS_update_ctime( parent );
3940: eb000266 bl 42e0 <gettimeofday>
3944: e59d3054 ldr r3, [sp, #84] ; 0x54
IMFS_update_mtime( parent );
3948: e28d0054 add r0, sp, #84 ; 0x54
);
if ( new_node != NULL ) {
IMFS_jnode_t *parent = currentloc->node_access;
IMFS_update_ctime( parent );
394c: e5843048 str r3, [r4, #72] ; 0x48
IMFS_update_mtime( parent );
3950: e3a01000 mov r1, #0
3954: eb000261 bl 42e0 <gettimeofday>
3958: e59d3054 ldr r3, [sp, #84] ; 0x54
395c: e5843044 str r3, [r4, #68] ; 0x44
3960: e3a05000 mov r5, #0
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
3964: e28d0008 add r0, sp, #8
3968: eb0007e7 bl 590c <rtems_filesystem_eval_path_cleanup>
396c: eaffffd2 b 38bc <IMFS_make_generic_node+0x48>
IMFS_update_mtime( parent );
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
3970: e28d0008 add r0, sp, #8
3974: e3a01086 mov r1, #134 ; 0x86
3978: eb000718 bl 55e0 <rtems_filesystem_eval_path_error>
rv = -1;
397c: e3e05000 mvn r5, #0
3980: eafffff7 b 3964 <IMFS_make_generic_node+0xf0>
0000c3b8 <IMFS_memfile_get_block_pointer>:
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
c3b8: e59f31fc ldr r3, [pc, #508] ; c5bc <IMFS_memfile_get_block_pointer+0x204>
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
c3bc: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
c3c0: e5934000 ldr r4, [r3]
c3c4: e1a04124 lsr r4, r4, #2
c3c8: e2443001 sub r3, r4, #1
c3cc: e1510003 cmp r1, r3
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
c3d0: e24dd004 sub sp, sp, #4
c3d4: e1a05000 mov r5, r0
c3d8: e1a06002 mov r6, r2
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
c3dc: 8a000007 bhi c400 <IMFS_memfile_get_block_pointer+0x48>
p = info->indirect;
if ( malloc_it ) {
c3e0: e3520000 cmp r2, #0
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
p = info->indirect;
c3e4: e5900058 ldr r0, [r0, #88] ; 0x58
if ( malloc_it ) {
c3e8: 0a000040 beq c4f0 <IMFS_memfile_get_block_pointer+0x138>
if ( !p ) {
c3ec: e3500000 cmp r0, #0
c3f0: 0a000050 beq c538 <IMFS_memfile_get_block_pointer+0x180>
}
if ( !p )
return 0;
return &info->indirect[ my_block ];
c3f4: e0800101 add r0, r0, r1, lsl #2
/*
* This means the requested block number is out of range.
*/
return 0;
}
c3f8: e28dd004 add sp, sp, #4
c3fc: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
c400: e0274494 mla r7, r4, r4, r4
c404: e2473001 sub r3, r7, #1
c408: e1510003 cmp r1, r3
c40c: 9a000023 bls c4a0 <IMFS_memfile_get_block_pointer+0xe8>
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
c410: e0234497 mla r3, r7, r4, r4
c414: e2433001 sub r3, r3, #1
c418: e1510003 cmp r1, r3
}
/*
* This means the requested block number is out of range.
*/
return 0;
c41c: 83a00000 movhi r0, #0
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
c420: 8afffff4 bhi c3f8 <IMFS_memfile_get_block_pointer+0x40>
my_block -= FIRST_TRIPLY_INDIRECT;
c424: e0677001 rsb r7, r7, r1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
c428: e1a00007 mov r0, r7
c42c: e1a01004 mov r1, r4
c430: eb002923 bl 168c4 <__umodsi3>
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c434: e1a01004 mov r1, r4
* 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;
c438: e1a09000 mov r9, r0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c43c: e1a00007 mov r0, r7
c440: eb0028d9 bl 167ac <__aeabi_uidiv>
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
c444: e1a01004 mov r1, r4
*/
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;
c448: e1a0a000 mov sl, r0
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
c44c: eb0028d6 bl 167ac <__aeabi_uidiv>
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
c450: e1a01004 mov r1, r4
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;
c454: e1a07000 mov r7, r0
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
c458: e1a0000a mov r0, sl
c45c: eb002918 bl 168c4 <__umodsi3>
p = info->triply_indirect;
if ( malloc_it ) {
c460: e3560000 cmp r6, #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;
c464: e1a04000 mov r4, r0
p = info->triply_indirect;
c468: e5950060 ldr r0, [r5, #96] ; 0x60
if ( malloc_it ) {
c46c: 0a000028 beq c514 <IMFS_memfile_get_block_pointer+0x15c>
if ( !p ) {
c470: e3500000 cmp r0, #0
c474: 0a000045 beq c590 <IMFS_memfile_get_block_pointer+0x1d8>
if ( !p )
return 0;
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
c478: e7903107 ldr r3, [r0, r7, lsl #2]
if ( !p1 ) {
c47c: e3530000 cmp r3, #0
if ( !p )
return 0;
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
c480: e0807107 add r7, r0, r7, lsl #2
if ( !p1 ) {
c484: 0a000046 beq c5a4 <IMFS_memfile_get_block_pointer+0x1ec>
if ( !p1 )
return 0;
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
c488: e7930104 ldr r0, [r3, r4, lsl #2]
if ( !p2 ) {
c48c: e3500000 cmp r0, #0
if ( !p1 )
return 0;
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
c490: e0834104 add r4, r3, r4, lsl #2
if ( !p2 ) {
c494: 0a000033 beq c568 <IMFS_memfile_get_block_pointer+0x1b0>
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
c498: e0800109 add r0, r0, r9, lsl #2
c49c: eaffffd5 b c3f8 <IMFS_memfile_get_block_pointer+0x40>
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
c4a0: e0647001 rsb r7, r4, r1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
c4a4: e1a00007 mov r0, r7
c4a8: e1a01004 mov r1, r4
c4ac: eb002904 bl 168c4 <__umodsi3>
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c4b0: e1a01004 mov r1, r4
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
c4b4: e1a08000 mov r8, r0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c4b8: e1a00007 mov r0, r7
c4bc: eb0028ba bl 167ac <__aeabi_uidiv>
p = info->doubly_indirect;
if ( malloc_it ) {
c4c0: e3560000 cmp r6, #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;
c4c4: e1a04000 mov r4, r0
p = info->doubly_indirect;
c4c8: e595305c ldr r3, [r5, #92] ; 0x5c
if ( malloc_it ) {
c4cc: 0a00000a beq c4fc <IMFS_memfile_get_block_pointer+0x144>
if ( !p ) {
c4d0: e3530000 cmp r3, #0
c4d4: 0a000028 beq c57c <IMFS_memfile_get_block_pointer+0x1c4>
if ( !p )
return 0;
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
c4d8: e7930104 ldr r0, [r3, r4, lsl #2]
if ( !p1 ) {
c4dc: e3500000 cmp r0, #0
if ( !p )
return 0;
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
c4e0: e0834104 add r4, r3, r4, lsl #2
if ( !p1 ) {
c4e4: 0a00001a beq c554 <IMFS_memfile_get_block_pointer+0x19c>
p = (block_p *)p[ doubly ];
if ( !p )
return 0;
return (block_p *)&p[ singly ];
c4e8: e0800108 add r0, r0, r8, lsl #2
c4ec: eaffffc1 b c3f8 <IMFS_memfile_get_block_pointer+0x40>
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
c4f0: e3500000 cmp r0, #0
c4f4: 1affffbe bne c3f4 <IMFS_memfile_get_block_pointer+0x3c>
c4f8: eaffffbe b c3f8 <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
}
return (block_p *)&p1[ singly ];
}
if ( !p )
c4fc: e3530000 cmp r3, #0
c500: 0a00002b beq c5b4 <IMFS_memfile_get_block_pointer+0x1fc>
return 0;
p = (block_p *)p[ doubly ];
c504: e7930100 ldr r0, [r3, r0, lsl #2]
if ( !p )
c508: e3500000 cmp r0, #0
return 0;
return (block_p *)&p[ singly ];
c50c: 10800108 addne r0, r0, r8, lsl #2
c510: eaffffb8 b c3f8 <IMFS_memfile_get_block_pointer+0x40>
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
}
if ( !p )
c514: e3500000 cmp r0, #0
c518: 0affffb6 beq c3f8 <IMFS_memfile_get_block_pointer+0x40>
return 0;
p1 = (block_p *) p[ triply ];
c51c: e7900107 ldr r0, [r0, r7, lsl #2]
if ( !p1 )
c520: e3500000 cmp r0, #0
c524: 0affffb3 beq c3f8 <IMFS_memfile_get_block_pointer+0x40>
return 0;
p2 = (block_p *)p1[ doubly ];
c528: e7900104 ldr r0, [r0, r4, lsl #2]
if ( !p2 )
c52c: e3500000 cmp r0, #0
return 0;
return (block_p *)&p2[ singly ];
c530: 10800109 addne r0, r0, r9, lsl #2
c534: eaffffaf b c3f8 <IMFS_memfile_get_block_pointer+0x40>
p = info->indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
c538: e58d1000 str r1, [sp]
c53c: ebffff90 bl c384 <memfile_alloc_block>
if ( !p )
c540: e3500000 cmp r0, #0
c544: e59d1000 ldr r1, [sp]
return 0;
info->indirect = p;
c548: 15850058 strne r0, [r5, #88] ; 0x58
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
c54c: 1affffa8 bne c3f4 <IMFS_memfile_get_block_pointer+0x3c>
c550: eaffffa8 b c3f8 <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
if ( !p1 ) {
p1 = memfile_alloc_block();
c554: ebffff8a bl c384 <memfile_alloc_block>
if ( !p1 )
c558: e3500000 cmp r0, #0
return 0;
p[ doubly ] = (block_p) p1;
c55c: 15840000 strne r0, [r4]
p = (block_p *)p[ doubly ];
if ( !p )
return 0;
return (block_p *)&p[ singly ];
c560: 10800108 addne r0, r0, r8, lsl #2
c564: eaffffa3 b c3f8 <IMFS_memfile_get_block_pointer+0x40>
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
c568: ebffff85 bl c384 <memfile_alloc_block>
if ( !p2 )
c56c: e3500000 cmp r0, #0
return 0;
p1[ doubly ] = (block_p) p2;
c570: 15840000 strne r0, [r4]
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
c574: 10800109 addne r0, r0, r9, lsl #2
c578: eaffff9e b c3f8 <IMFS_memfile_get_block_pointer+0x40>
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
c57c: ebffff80 bl c384 <memfile_alloc_block>
if ( !p )
c580: e2503000 subs r3, r0, #0
c584: 0a00000a beq c5b4 <IMFS_memfile_get_block_pointer+0x1fc>
return 0;
info->doubly_indirect = p;
c588: e585305c str r3, [r5, #92] ; 0x5c
c58c: eaffffd1 b c4d8 <IMFS_memfile_get_block_pointer+0x120>
p = info->triply_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
c590: ebffff7b bl c384 <memfile_alloc_block>
if ( !p )
c594: e3500000 cmp r0, #0
c598: 0affff96 beq c3f8 <IMFS_memfile_get_block_pointer+0x40>
return 0;
info->triply_indirect = p;
c59c: e5850060 str r0, [r5, #96] ; 0x60
c5a0: eaffffb4 b c478 <IMFS_memfile_get_block_pointer+0xc0>
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
c5a4: ebffff76 bl c384 <memfile_alloc_block>
if ( !p1 )
c5a8: e2503000 subs r3, r0, #0
return 0;
p[ triply ] = (block_p) p1;
c5ac: 15873000 strne r3, [r7]
c5b0: 1affffb4 bne c488 <IMFS_memfile_get_block_pointer+0xd0>
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
return 0;
c5b4: e1a00003 mov r0, r3 <== NOT EXECUTED
c5b8: eaffff8e b c3f8 <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
0000c5c0 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
c5c0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
c5c4: e1a09000 mov r9, r0
rtems_chain_extract_unprotected( &node->Node );
}
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{
return node->control->imfs_type;
c5c8: e590004c ldr r0, [r0, #76] ; 0x4c
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {
c5cc: e5900000 ldr r0, [r0]
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
c5d0: e24dd014 sub sp, sp, #20
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {
c5d4: e3500005 cmp r0, #5
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
c5d8: e88d0006 stm sp, {r1, r2}
c5dc: e58d3008 str r3, [sp, #8]
c5e0: e59d7038 ldr r7, [sp, #56] ; 0x38
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {
c5e4: 0a000059 beq c750 <IMFS_memfile_read+0x190>
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
c5e8: e59dc000 ldr ip, [sp]
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
c5ec: e59f81bc ldr r8, [pc, #444] ; c7b0 <IMFS_memfile_read+0x1f0>
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
c5f0: e087e00c add lr, r7, ip
if ( last_byte > the_jnode->info.file.size )
c5f4: e2891050 add r1, r9, #80 ; 0x50
c5f8: e8910003 ldm r1, {r0, r1}
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
c5fc: e5986000 ldr r6, [r8]
/* * If the last byte we are supposed to read is past the end of this * in memory file, then shorten the length to read. */ last_byte = start + length; if ( last_byte > the_jnode->info.file.size )
c600: e1a0200e mov r2, lr
c604: e3a03000 mov r3, #0
c608: e1500002 cmp r0, r2
c60c: e0d1e003 sbcs lr, r1, r3
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
c610: e1a05fc6 asr r5, r6, #31
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
my_length = the_jnode->info.file.size - start;
c614: b06c7000 rsblt r7, ip, r0
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
c618: e1a03005 mov r3, r5
c61c: e1a02006 mov r2, r6
c620: e89d0003 ldm sp, {r0, r1}
c624: eb002c8e bl 17864 <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
c628: e1a03005 mov r3, r5
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
c62c: e1a0a000 mov sl, r0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
c630: e1a02006 mov r2, r6
c634: e89d0003 ldm sp, {r0, r1}
c638: eb002b4e bl 17378 <__divdi3>
if ( start_offset ) {
c63c: e35a0000 cmp sl, #0
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
c640: e1a04000 mov r4, r0
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
c644: 059d5008 ldreq r5, [sp, #8]
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
c648: 1a000016 bne c6a8 <IMFS_memfile_read+0xe8>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
c64c: e1570006 cmp r7, r6
c650: 2a000008 bcs c678 <IMFS_memfile_read+0xb8>
c654: ea000029 b c700 <IMFS_memfile_read+0x140>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
c658: e5931000 ldr r1, [r3]
c65c: eb00069b bl e0d0 <memcpy>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
c660: e5983000 ldr r3, [r8]
c664: e1530007 cmp r3, r7
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
dest += to_copy;
c668: e0855006 add r5, r5, r6
block++;
c66c: e2844001 add r4, r4, #1
my_length -= to_copy;
copied += to_copy;
c670: e08aa006 add sl, sl, r6
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
c674: 8a000021 bhi c700 <IMFS_memfile_read+0x140>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
c678: e3a02000 mov r2, #0
c67c: e1a01004 mov r1, r4
c680: e1a00009 mov r0, r9
c684: ebffff4b bl c3b8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
c688: e2503000 subs r3, r0, #0
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
c68c: e1a02006 mov r2, r6
dest += to_copy;
block++;
my_length -= to_copy;
c690: e0667007 rsb r7, r6, r7
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
c694: e1a00005 mov r0, r5
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
c698: 1affffee bne c658 <IMFS_memfile_read+0x98>
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
c69c: e1a0000a mov r0, sl <== NOT EXECUTED
}
IMFS_update_atime( the_jnode );
return copied;
}
c6a0: e28dd014 add sp, sp, #20
c6a4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
c6a8: e1a00009 mov r0, r9
c6ac: e1a01004 mov r1, r4
c6b0: e3a02000 mov r2, #0
c6b4: ebffff3f bl c3b8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
c6b8: e3500000 cmp r0, #0
c6bc: 0afffff7 beq c6a0 <IMFS_memfile_read+0xe0>
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
c6c0: e06a6006 rsb r6, sl, r6
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
c6c4: e5901000 ldr r1, [r0]
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
c6c8: e1570006 cmp r7, r6
c6cc: 31a0b007 movcc fp, r7
c6d0: 21a0b006 movcs fp, r6
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
c6d4: e081100a add r1, r1, sl
c6d8: e59d0008 ldr r0, [sp, #8]
c6dc: e1a0200b mov r2, fp
c6e0: eb00067a bl e0d0 <memcpy>
dest += to_copy;
c6e4: e59dc008 ldr ip, [sp, #8]
block++;
c6e8: e2844001 add r4, r4, #1
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
dest += to_copy;
c6ec: e08c500b add r5, ip, fp
block++;
my_length -= to_copy;
c6f0: e06b7007 rsb r7, fp, r7
c6f4: e5986000 ldr r6, [r8]
copied += to_copy;
c6f8: e1a0a00b mov sl, fp
c6fc: eaffffd2 b c64c <IMFS_memfile_read+0x8c>
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
c700: e3570000 cmp r7, #0
c704: 0a00000a beq c734 <IMFS_memfile_read+0x174>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
c708: e1a00009 mov r0, r9
c70c: e1a01004 mov r1, r4
c710: e3a02000 mov r2, #0
c714: ebffff27 bl c3b8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
c718: e2503000 subs r3, r0, #0
c71c: 0affffde beq c69c <IMFS_memfile_read+0xdc>
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
c720: e1a00005 mov r0, r5
c724: e5931000 ldr r1, [r3]
c728: e1a02007 mov r2, r7
c72c: eb000667 bl e0d0 <memcpy>
copied += my_length;
c730: e08aa007 add sl, sl, r7
}
IMFS_update_atime( the_jnode );
c734: e28d000c add r0, sp, #12
c738: e3a01000 mov r1, #0
c73c: ebffd79d bl 25b8 <gettimeofday>
c740: e59d300c ldr r3, [sp, #12]
return copied;
c744: e1a0000a mov r0, sl
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
c748: e5893040 str r3, [r9, #64] ; 0x40
return copied;
c74c: eaffffd3 b c6a0 <IMFS_memfile_read+0xe0>
if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
c750: e2895050 add r5, r9, #80 ; 0x50
c754: e8950030 ldm r5, {r4, r5}
c758: e89d0003 ldm sp, {r0, r1}
c75c: e1a02007 mov r2, r7
c760: e0540000 subs r0, r4, r0
c764: e0c51001 sbc r1, r5, r1
c768: e3a03000 mov r3, #0
c76c: e1500002 cmp r0, r2
c770: e0d1c003 sbcs ip, r1, r3
my_length = the_jnode->info.linearfile.size - start;
c774: b59de000 ldrlt lr, [sp]
memcpy(dest, &file_ptr[start], my_length);
c778: e59d3000 ldr r3, [sp]
my_length = length;
if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
c77c: e5991058 ldr r1, [r9, #88] ; 0x58
if (my_length > (the_jnode->info.linearfile.size - start))
my_length = the_jnode->info.linearfile.size - start;
c780: b06e7004 rsblt r7, lr, r4
memcpy(dest, &file_ptr[start], my_length);
c784: e0811003 add r1, r1, r3
c788: e1a02007 mov r2, r7
c78c: e59d0008 ldr r0, [sp, #8]
c790: eb00064e bl e0d0 <memcpy>
IMFS_update_atime( the_jnode );
c794: e28d000c add r0, sp, #12
c798: e3a01000 mov r1, #0
c79c: ebffd785 bl 25b8 <gettimeofday>
c7a0: e59d300c ldr r3, [sp, #12]
return my_length;
c7a4: e1a00007 mov r0, r7
if (my_length > (the_jnode->info.linearfile.size - start))
my_length = the_jnode->info.linearfile.size - start;
memcpy(dest, &file_ptr[start], my_length);
IMFS_update_atime( the_jnode );
c7a8: e5893040 str r3, [r9, #64] ; 0x40
return my_length;
c7ac: eaffffbb b c6a0 <IMFS_memfile_read+0xe0>
0000cbac <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
cbac: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
cbb0: e24dd010 sub sp, sp, #16
cbb4: e59db034 ldr fp, [sp, #52] ; 0x34
cbb8: e88d0006 stm sp, {r1, r2}
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
cbbc: e2805050 add r5, r0, #80 ; 0x50
cbc0: e8950030 ldm r5, {r4, r5}
/*
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
cbc4: e08b2001 add r2, fp, r1
if ( last_byte > the_jnode->info.file.size ) {
cbc8: e1a06002 mov r6, r2
cbcc: e3a07000 mov r7, #0
cbd0: e1540006 cmp r4, r6
cbd4: e0d51007 sbcs r1, r5, r7
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
cbd8: e1a09000 mov r9, r0
cbdc: e1a08003 mov r8, r3
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
cbe0: ba000050 blt cd28 <IMFS_memfile_write+0x17c>
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
cbe4: e59f7168 ldr r7, [pc, #360] ; cd54 <IMFS_memfile_write+0x1a8>
cbe8: e5976000 ldr r6, [r7]
cbec: e1a05fc6 asr r5, r6, #31
cbf0: e1a03005 mov r3, r5
cbf4: e1a02006 mov r2, r6
cbf8: e89d0003 ldm sp, {r0, r1}
cbfc: eb002b18 bl 17864 <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
cc00: e1a03005 mov r3, r5
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
cc04: e1a0a000 mov sl, r0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
cc08: e1a02006 mov r2, r6
cc0c: e89d0003 ldm sp, {r0, r1}
cc10: eb0029d8 bl 17378 <__divdi3>
if ( start_offset ) {
cc14: e35a0000 cmp sl, #0
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
cc18: e1a04006 mov r4, r6
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
cc1c: e1a05000 mov r5, r0
if ( start_offset ) {
cc20: 01a0400b moveq r4, fp
cc24: 1a000016 bne cc84 <IMFS_memfile_write+0xd8>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
cc28: e1540006 cmp r4, r6
cc2c: 2a000008 bcs cc54 <IMFS_memfile_write+0xa8>
cc30: ea000027 b ccd4 <IMFS_memfile_write+0x128>
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
cc34: e5900000 ldr r0, [r0]
cc38: eb000524 bl e0d0 <memcpy>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
cc3c: e5973000 ldr r3, [r7]
cc40: e1530004 cmp r3, r4
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
src += to_copy;
cc44: e0888006 add r8, r8, r6
block++;
cc48: e2855001 add r5, r5, #1
* IMFS_memfile_write * * This routine writes the specified data buffer into the in memory * file pointed to by the_jnode. The file is extended as needed. */ MEMFILE_STATIC ssize_t IMFS_memfile_write(
cc4c: e08aa006 add sl, sl, r6
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
cc50: 8a00001f bhi ccd4 <IMFS_memfile_write+0x128>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
cc54: e1a01005 mov r1, r5
cc58: e3a02000 mov r2, #0
cc5c: e1a00009 mov r0, r9
cc60: ebfffdd4 bl c3b8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
cc64: e3500000 cmp r0, #0
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
cc68: e1a01008 mov r1, r8
cc6c: e1a02006 mov r2, r6
src += to_copy;
block++;
my_length -= to_copy;
cc70: e0664004 rsb r4, r6, r4
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
cc74: 1affffee bne cc34 <IMFS_memfile_write+0x88>
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
cc78: e1a0000a mov r0, sl <== NOT EXECUTED
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
cc7c: e28dd010 add sp, sp, #16
cc80: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
cc84: e1a00009 mov r0, r9
cc88: e1a01005 mov r1, r5
cc8c: e3a02000 mov r2, #0
cc90: ebfffdc8 bl c3b8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
cc94: e3500000 cmp r0, #0
cc98: 0afffff7 beq cc7c <IMFS_memfile_write+0xd0>
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
cc9c: e06a6006 rsb r6, sl, r6
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
cca0: e5900000 ldr r0, [r0]
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
cca4: e156000b cmp r6, fp
cca8: 21a0600b movcs r6, fp
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
ccac: e080000a add r0, r0, sl
ccb0: e1a01008 mov r1, r8
ccb4: e1a02006 mov r2, r6
ccb8: eb000504 bl e0d0 <memcpy>
src += to_copy;
ccbc: e0888006 add r8, r8, r6
block++;
my_length -= to_copy;
ccc0: e066400b rsb r4, r6, fp
copied += to_copy;
ccc4: e1a0a006 mov sl, r6
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
src += to_copy;
block++;
ccc8: e2855001 add r5, r5, #1
my_length -= to_copy;
copied += to_copy;
cccc: e5976000 ldr r6, [r7]
ccd0: eaffffd4 b cc28 <IMFS_memfile_write+0x7c>
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
ccd4: e3540000 cmp r4, #0
ccd8: 0a00000a beq cd08 <IMFS_memfile_write+0x15c>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
ccdc: e1a00009 mov r0, r9
cce0: e1a01005 mov r1, r5
cce4: e3a02000 mov r2, #0
cce8: ebfffdb2 bl c3b8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
ccec: e3500000 cmp r0, #0
ccf0: 0affffe0 beq cc78 <IMFS_memfile_write+0xcc>
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, my_length );
ccf4: e5900000 ldr r0, [r0]
ccf8: e1a01008 mov r1, r8
ccfc: e1a02004 mov r2, r4
cd00: eb0004f2 bl e0d0 <memcpy>
my_length = 0;
copied += to_copy;
cd04: e08aa004 add sl, sl, r4
}
IMFS_mtime_ctime_update( the_jnode );
cd08: e28d0008 add r0, sp, #8
cd0c: e3a01000 mov r1, #0
cd10: ebffd628 bl 25b8 <gettimeofday>
cd14: e59d3008 ldr r3, [sp, #8]
return copied;
cd18: e1a0000a mov r0, sl
memcpy( &(*block_ptr)[ 0 ], src, my_length );
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
cd1c: e5893044 str r3, [r9, #68] ; 0x44
cd20: e5893048 str r3, [r9, #72] ; 0x48
return copied;
cd24: eaffffd4 b cc7c <IMFS_memfile_write+0xd0>
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
bool zero_fill = start > the_jnode->info.file.size;
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
cd28: e89d000c ldm sp, {r2, r3}
cd2c: e1540002 cmp r4, r2
cd30: e0d53003 sbcs r3, r5, r3
cd34: a3a01000 movge r1, #0
cd38: b3a01001 movlt r1, #1
cd3c: e1a02006 mov r2, r6
cd40: e1a03007 mov r3, r7
cd44: ebffff2f bl ca08 <IMFS_memfile_extend>
if ( status )
cd48: e3500000 cmp r0, #0
cd4c: 0affffa4 beq cbe4 <IMFS_memfile_write+0x38>
cd50: eaffffc9 b cc7c <IMFS_memfile_write+0xd0>
00001eb0 <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;
1eb0: e5903020 ldr r3, [r0, #32]
1eb4: 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;
1eb8: e593204c ldr r2, [r3, #76] ; 0x4c
if ( IMFS_is_directory( node ) ) {
1ebc: e5922000 ldr r2, [r2]
1ec0: e3520000 cmp r2, #0
#endif
#include "imfs.h"
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
1ec4: 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 ) ) {
1ec8: 1a000009 bne 1ef4 <IMFS_mount+0x44>
if ( node->info.directory.mt_fs == NULL ) {
1ecc: e593205c ldr r2, [r3, #92] ; 0x5c
1ed0: e3520000 cmp r2, #0
node->info.directory.mt_fs = mt_entry;
1ed4: 0583005c streq r0, [r3, #92] ; 0x5c
#include "imfs.h"
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
int rv = 0;
1ed8: 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 ) {
1edc: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
node->info.directory.mt_fs = mt_entry;
} else {
errno = EBUSY;
1ee0: eb002e40 bl d7e8 <__errno> <== NOT EXECUTED
1ee4: e3a03010 mov r3, #16 <== NOT EXECUTED
1ee8: e5803000 str r3, [r0] <== NOT EXECUTED
rv = -1;
1eec: e3e00000 mvn r0, #0 <== NOT EXECUTED
1ef0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
}
} else {
errno = ENOTDIR;
1ef4: eb002e3b bl d7e8 <__errno>
1ef8: e3a03014 mov r3, #20
1efc: e5803000 str r3, [r0]
rv = -1;
1f00: e3e00000 mvn r0, #0
}
return rv;
}
1f04: e49df004 pop {pc} ; (ldr pc, [sp], #4)
0000a8d8 <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 ) ) {
a8d8: 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 );
a8dc: e2803054 add r3, r0, #84 ; 0x54
a8e0: e1520003 cmp r2, r3
}
static IMFS_jnode_t *IMFS_node_remove_directory(
IMFS_jnode_t *node
)
{
a8e4: e52de004 push {lr} ; (str lr, [sp, #-4]!)
if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {
a8e8: 1a000007 bne a90c <IMFS_node_remove_directory+0x34>
errno = ENOTEMPTY;
node = NULL;
} else if ( IMFS_is_mount_point( node ) ) {
a8ec: e590305c ldr r3, [r0, #92] ; 0x5c
a8f0: e3530000 cmp r3, #0
a8f4: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
errno = EBUSY;
a8f8: eb000bba bl d7e8 <__errno> <== NOT EXECUTED
a8fc: e3a03010 mov r3, #16 <== NOT EXECUTED
a900: e5803000 str r3, [r0] <== NOT EXECUTED
a904: e3a00000 mov r0, #0 <== NOT EXECUTED
node = NULL;
}
return node;
}
a908: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
static IMFS_jnode_t *IMFS_node_remove_directory(
IMFS_jnode_t *node
)
{
if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {
errno = ENOTEMPTY;
a90c: eb000bb5 bl d7e8 <__errno>
a910: e3a0305a mov r3, #90 ; 0x5a
a914: e5803000 str r3, [r0]
node = NULL;
a918: e3a00000 mov r0, #0
a91c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
00001f98 <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
1f98: e92d40f0 push {r4, r5, r6, r7, lr}
int rv = 0; IMFS_jnode_t *node = oldloc->node_access;
1f9c: e5914008 ldr r4, [r1, #8]
/*
* FIXME: Due to insufficient checks we can create inaccessible nodes with
* this operation.
*/
if ( node->Parent != NULL ) {
1fa0: e5941008 ldr r1, [r4, #8]
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
1fa4: e24dd008 sub sp, sp, #8
/*
* FIXME: Due to insufficient checks we can create inaccessible nodes with
* this operation.
*/
if ( node->Parent != NULL ) {
1fa8: e3510000 cmp r1, #0
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
1fac: e59d601c ldr r6, [sp, #28]
int rv = 0; IMFS_jnode_t *node = oldloc->node_access; IMFS_jnode_t *new_parent = newparentloc->node_access;
1fb0: e5925008 ldr r5, [r2, #8]
/*
* FIXME: Due to insufficient checks we can create inaccessible nodes with
* this operation.
*/
if ( node->Parent != NULL ) {
1fb4: 0a00001f beq 2038 <IMFS_rename+0xa0>
if ( namelen < IMFS_NAME_MAX ) {
1fb8: e356001f cmp r6, #31
1fbc: 8a000018 bhi 2024 <IMFS_rename+0x8c>
memcpy( node->name, name, namelen );
1fc0: e1a01003 mov r1, r3
1fc4: e1a02006 mov r2, r6
node->name [namelen] = '\0';
1fc8: e3a07000 mov r7, #0
* this operation.
*/
if ( node->Parent != NULL ) {
if ( namelen < IMFS_NAME_MAX ) {
memcpy( node->name, name, namelen );
1fcc: e284000c add r0, r4, #12
node->name [namelen] = '\0';
1fd0: e0846006 add r6, r4, r6
* this operation.
*/
if ( node->Parent != NULL ) {
if ( namelen < IMFS_NAME_MAX ) {
memcpy( node->name, name, namelen );
1fd4: eb00303d bl e0d0 <memcpy>
node->name [namelen] = '\0';
1fd8: e5c6700c strb r7, [r6, #12]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
1fdc: e8940003 ldm r4, {r0, r1}
next->previous = previous;
1fe0: e5801004 str r1, [r0, #4]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
1fe4: 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 );
1fe8: e2852054 add r2, r5, #84 ; 0x54
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
previous->next = next;
1fec: e5810000 str r0, [r1]
static inline void IMFS_add_to_directory(
IMFS_jnode_t *dir,
IMFS_jnode_t *node
)
{
node->Parent = dir;
1ff0: e5845008 str r5, [r4, #8]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
1ff4: e5842000 str r2, [r4]
tail->previous = the_node;
1ff8: e5854058 str r4, [r5, #88] ; 0x58
old_last->next = the_node;
1ffc: e5834000 str r4, [r3]
the_node->previous = old_last;
2000: e5843004 str r3, [r4, #4]
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
2004: e1a0000d mov r0, sp
2008: e1a01007 mov r1, r7
200c: eb000169 bl 25b8 <gettimeofday>
2010: e59d3000 ldr r3, [sp]
2014: e5843048 str r3, [r4, #72] ; 0x48
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
int rv = 0;
2018: e1a00007 mov r0, r7
errno = EINVAL;
rv = -1;
}
return rv;
}
201c: e28dd008 add sp, sp, #8
2020: e8bd80f0 pop {r4, r5, r6, r7, pc}
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
} else {
errno = ENAMETOOLONG;
2024: eb002def bl d7e8 <__errno> <== NOT EXECUTED
2028: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED
202c: e5803000 str r3, [r0] <== NOT EXECUTED
rv = -1;
2030: e3e00000 mvn r0, #0 <== NOT EXECUTED
2034: eafffff8 b 201c <IMFS_rename+0x84> <== NOT EXECUTED
}
} else {
errno = EINVAL;
2038: eb002dea bl d7e8 <__errno> <== NOT EXECUTED
203c: e3a03016 mov r3, #22 <== NOT EXECUTED
2040: e5803000 str r3, [r0] <== NOT EXECUTED
rv = -1;
2044: e3e00000 mvn r0, #0 <== NOT EXECUTED
2048: eafffff3 b 201c <IMFS_rename+0x84> <== NOT EXECUTED
00002130 <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;
2130: e5903020 ldr r3, [r0, #32]
2134: 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;
2138: e593204c ldr r2, [r3, #76] ; 0x4c
if ( IMFS_is_directory( node ) ) {
213c: e5922000 ldr r2, [r2]
2140: e3520000 cmp r2, #0
#endif
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
2144: 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 ) ) {
2148: 1a000009 bne 2174 <IMFS_unmount+0x44>
if ( node->info.directory.mt_fs == mt_entry ) {
214c: e593105c ldr r1, [r3, #92] ; 0x5c
2150: e1510000 cmp r1, r0
node->info.directory.mt_fs = NULL;
2154: 0583205c streq r2, [r3, #92] ; 0x5c
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
int rv = 0;
2158: 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 == mt_entry ) {
215c: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
node->info.directory.mt_fs = NULL;
} else {
errno = EINVAL;
2160: eb002da0 bl d7e8 <__errno> <== NOT EXECUTED
2164: e3a03016 mov r3, #22 <== NOT EXECUTED
2168: e5803000 str r3, [r0] <== NOT EXECUTED
rv = -1;
216c: e3e00000 mvn r0, #0 <== NOT EXECUTED
2170: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
}
} else {
errno = ENOTDIR;
2174: eb002d9b bl d7e8 <__errno> <== NOT EXECUTED
2178: e3a03014 mov r3, #20 <== NOT EXECUTED
217c: e5803000 str r3, [r0] <== NOT EXECUTED
rv = -1;
2180: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return rv;
}
2184: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00021a60 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
static void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
21a60: e92d4ff0 push {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);
21a64: e28060b0 add r6, r0, #176 ; 0xb0
21a68: e8960840 ldm r6, {r6, fp}
size = Stack_check_usable_stack_size(stack);
21a6c: e2466010 sub r6, r6, #16
static rtems_printk_plugin_t print_handler;
static void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
21a70: e1a05000 mov r5, r0
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
21a74: e28b3020 add r3, fp, #32
for (ebase = base + length; base < ebase; base++)
21a78: e3c60003 bic r0, r6, #3 21a7c: e0830000 add r0, r3, r0 21a80: e1530000 cmp r3, r0
static rtems_printk_plugin_t print_handler;
static void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
21a84: e24dd010 sub sp, sp, #16
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
21a88: e59590e0 ldr r9, [r5, #224] ; 0xe0
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
21a8c: 2a00000b bcs 21ac0 <Stack_check_Dump_threads_usage+0x60>
if (*base != U32_PATTERN)
21a90: e59f20d8 ldr r2, [pc, #216] ; 21b70 <Stack_check_Dump_threads_usage+0x110> 21a94: e59bc020 ldr ip, [fp, #32] 21a98: e15c0002 cmp ip, r2
* Try to print out how much stack was actually used by the task.
*/
static void *print_context;
static rtems_printk_plugin_t print_handler;
static void Stack_check_Dump_threads_usage(
21a9c: 01a02003 moveq r2, r3
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
if (*base != U32_PATTERN)
21aa0: 0a000003 beq 21ab4 <Stack_check_Dump_threads_usage+0x54>
21aa4: ea000027 b 21b48 <Stack_check_Dump_threads_usage+0xe8> <== NOT EXECUTED
21aa8: e5b21004 ldr r1, [r2, #4]! 21aac: e151000c cmp r1, ip
21ab0: 1a000024 bne 21b48 <Stack_check_Dump_threads_usage+0xe8>
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
21ab4: e2833004 add r3, r3, #4 21ab8: e1500003 cmp r0, r3
21abc: 8afffff9 bhi 21aa8 <Stack_check_Dump_threads_usage+0x48>
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;
21ac0: e3a0b000 mov fp, #0 <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
#endif
{
(*print_handler)(
21ac4: e5958008 ldr r8, [r5, #8] 21ac8: e59f40a4 ldr r4, [pc, #164] ; 21b74 <Stack_check_Dump_threads_usage+0x114> 21acc: e3a01005 mov r1, #5 21ad0: e28d2008 add r2, sp, #8 21ad4: e1a00008 mov r0, r8 21ad8: e594a004 ldr sl, [r4, #4] 21adc: e5947000 ldr r7, [r4] 21ae0: ebffb23c bl e3d8 <rtems_object_get_name> 21ae4: e59f108c ldr r1, [pc, #140] ; 21b78 <Stack_check_Dump_threads_usage+0x118> 21ae8: e1a03000 mov r3, r0 21aec: e1a02008 mov r2, r8 21af0: e1a0000a mov r0, sl 21af4: e1a0e00f mov lr, pc 21af8: e12fff17 bx r7
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
21afc: e59530b0 ldr r3, [r5, #176] ; 0xb0 21b00: e59520b4 ldr r2, [r5, #180] ; 0xb4 21b04: e2433001 sub r3, r3, #1
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
21b08: e0823003 add r3, r2, r3 21b0c: e5940004 ldr r0, [r4, #4] 21b10: e58d9000 str r9, [sp] 21b14: e58d6004 str r6, [sp, #4] 21b18: e59f105c ldr r1, [pc, #92] ; 21b7c <Stack_check_Dump_threads_usage+0x11c> 21b1c: e1a0e00f mov lr, pc 21b20: e594f000 ldr pc, [r4]
current,
size
);
if (Stack_check_Initialized == 0) {
(*print_handler)( print_context, "Unavailable\n" );
21b24: e9940009 ldmib r4, {r0, r3}
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
21b28: e3530000 cmp r3, #0
21b2c: 0a00000b beq 21b60 <Stack_check_Dump_threads_usage+0x100>
(*print_handler)( print_context, "Unavailable\n" );
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
21b30: e59f1048 ldr r1, [pc, #72] ; 21b80 <Stack_check_Dump_threads_usage+0x120> 21b34: e1a0200b mov r2, fp 21b38: e1a0e00f mov lr, pc 21b3c: e594f000 ldr pc, [r4]
}
}
21b40: e28dd010 add sp, sp, #16
21b44: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
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 )
21b48: e3530000 cmp r3, #0
used = Stack_check_Calculate_used( low, size, high_water_mark );
else
used = 0;
21b4c: 01a0b003 moveq fp, r3
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
21b50: 128bb010 addne fp, fp, #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 );
21b54: 108bb006 addne fp, fp, r6 21b58: 1063b00b rsbne fp, r3, fp 21b5c: eaffffd8 b 21ac4 <Stack_check_Dump_threads_usage+0x64>
current,
size
);
if (Stack_check_Initialized == 0) {
(*print_handler)( print_context, "Unavailable\n" );
21b60: e59f101c ldr r1, [pc, #28] ; 21b84 <Stack_check_Dump_threads_usage+0x124><== NOT EXECUTED 21b64: e1a0e00f mov lr, pc <== NOT EXECUTED 21b68: e594f000 ldr pc, [r4] <== NOT EXECUTED 21b6c: eafffff3 b 21b40 <Stack_check_Dump_threads_usage+0xe0> <== NOT EXECUTED
0000f89c <_CORE_message_queue_Initialize>:
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
f89c: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* Check if allocated_message_size is aligned to uintptr-size boundary.
* If not, it will increase allocated_message_size to multiplicity of pointer
* size.
*/
if (allocated_message_size & (sizeof(uintptr_t) - 1)) {
f8a0: e3130003 tst r3, #3
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
f8a4: e1a04000 mov r4, r0
size_t message_buffering_required = 0;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
the_message_queue->number_of_pending_messages = 0;
f8a8: e3a00000 mov r0, #0
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
f8ac: e1a05002 mov r5, r2
f8b0: e1a07001 mov r7, r1
size_t message_buffering_required = 0;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
f8b4: e5842044 str r2, [r4, #68] ; 0x44
the_message_queue->number_of_pending_messages = 0;
f8b8: e5840048 str r0, [r4, #72] ; 0x48
the_message_queue->maximum_message_size = maximum_message_size;
f8bc: e584304c str r3, [r4, #76] ; 0x4c
/*
* Check if allocated_message_size is aligned to uintptr-size boundary.
* If not, it will increase allocated_message_size to multiplicity of pointer
* size.
*/
if (allocated_message_size & (sizeof(uintptr_t) - 1)) {
f8c0: 01a06003 moveq r6, r3
f8c4: 0a000003 beq f8d8 <_CORE_message_queue_Initialize+0x3c>
allocated_message_size += sizeof(uintptr_t);
f8c8: e2836004 add r6, r3, #4
allocated_message_size &= ~(sizeof(uintptr_t) - 1);
f8cc: e3c66003 bic r6, r6, #3
/*
* Check for an overflow. It can occur while increasing allocated_message_size
* to multiplicity of uintptr_t above.
*/
if (allocated_message_size < maximum_message_size)
f8d0: e1530006 cmp r3, r6
f8d4: 88bd80f0 pophi {r4, r5, r6, r7, pc}
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
if ( !size_t_mult32_with_overflow(
f8d8: e2866010 add r6, r6, #16
size_t a,
size_t b,
size_t *c
)
{
long long x = (long long)a*b;
f8dc: e0810695 umull r0, r1, r5, r6
if ( x > SIZE_MAX )
f8e0: e3e02000 mvn r2, #0
f8e4: e3a03000 mov r3, #0
f8e8: e1520000 cmp r2, r0
f8ec: e0d3c001 sbcs ip, r3, r1
*/
if ( !size_t_mult32_with_overflow(
(size_t) maximum_pending_messages,
allocated_message_size + sizeof(CORE_message_queue_Buffer_control),
&message_buffering_required ) )
return false;
f8f0: b3a00000 movlt r0, #0
size_t *c
)
{
long long x = (long long)a*b;
if ( x > SIZE_MAX )
f8f4: b8bd80f0 poplt {r4, r5, r6, r7, pc}
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
f8f8: eb000bd0 bl 12840 <_Workspace_Allocate>
if (the_message_queue->message_buffers == 0)
f8fc: e3500000 cmp r0, #0
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
f900: e1a01000 mov r1, r0
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
f904: e584005c str r0, [r4, #92] ; 0x5c
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
f908: 0a000013 beq f95c <_CORE_message_queue_Initialize+0xc0>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
f90c: e2840060 add r0, r4, #96 ; 0x60
f910: e1a02005 mov r2, r5
f914: e1a03006 mov r3, r6
f918: ebffffc6 bl f838 <_Chain_Initialize>
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
f91c: e5971000 ldr r1, [r7]
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 );
f920: e2843050 add r3, r4, #80 ; 0x50
f924: e2842054 add r2, r4, #84 ; 0x54
head->next = tail;
head->previous = NULL;
tail->previous = head;
f928: e5843058 str r3, [r4, #88] ; 0x58
f92c: e2413001 sub r3, r1, #1
f930: e2731000 rsbs r1, r3, #0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
f934: e5842050 str r2, [r4, #80] ; 0x50
head->previous = NULL;
f938: e3a02000 mov r2, #0
f93c: e5842054 str r2, [r4, #84] ; 0x54
f940: e1a00004 mov r0, r4
f944: e0a11003 adc r1, r1, r3
f948: e3a02080 mov r2, #128 ; 0x80
f94c: e3a03006 mov r3, #6
f950: eb000982 bl 11f60 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
f954: e3a00001 mov r0, #1
f958: e8bd80f0 pop {r4, r5, r6, r7, pc}
}
f95c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
0000baac <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
baac: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
bab0: e1a08002 mov r8, r2
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
bab4: e5902010 ldr r2, [r0, #16]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
bab8: e24dd01c sub sp, sp, #28
babc: e1a06001 mov r6, r1
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
bac0: e2911004 adds r1, r1, #4
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
bac4: e1a07000 mov r7, r0
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
bac8: e58d1000 str r1, [sp]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
bacc: e1a0b003 mov fp, r3
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
bad0: e58d200c str r2, [sp, #12]
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
bad4: 2a000086 bcs bcf4 <_Heap_Allocate_aligned_with_boundary+0x248>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
bad8: e3530000 cmp r3, #0
badc: 1a000078 bne bcc4 <_Heap_Allocate_aligned_with_boundary+0x218>
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
bae0: e597a008 ldr sl, [r7, #8]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
bae4: e157000a cmp r7, sl
bae8: e3a05000 mov r5, #0
baec: 0a00007b beq bce0 <_Heap_Allocate_aligned_with_boundary+0x234>
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
baf0: e59d300c ldr r3, [sp, #12]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
baf4: e2662004 rsb r2, r6, #4
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
baf8: e2833007 add r3, r3, #7
bafc: e58d3010 str r3, [sp, #16]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
bb00: e58d2014 str r2, [sp, #20]
bb04: ea000005 b bb20 <_Heap_Allocate_aligned_with_boundary+0x74>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
bb08: e3540000 cmp r4, #0
);
}
}
/* Statistics */
++search_count;
bb0c: e2855001 add r5, r5, #1
if ( alloc_begin != 0 ) {
bb10: 1a00005a bne bc80 <_Heap_Allocate_aligned_with_boundary+0x1d4>
break;
}
block = block->next;
bb14: e59aa008 ldr sl, [sl, #8]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
bb18: e157000a cmp r7, sl
bb1c: 0a00006f beq bce0 <_Heap_Allocate_aligned_with_boundary+0x234>
/*
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
bb20: e59a9004 ldr r9, [sl, #4]
bb24: e59d3000 ldr r3, [sp]
bb28: e1530009 cmp r3, r9
);
}
}
/* Statistics */
++search_count;
bb2c: 22855001 addcs r5, r5, #1
/*
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
bb30: 2afffff7 bcs bb14 <_Heap_Allocate_aligned_with_boundary+0x68>
if ( alignment == 0 ) {
bb34: e3580000 cmp r8, #0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
bb38: 028a4008 addeq r4, sl, #8
bb3c: 0afffff1 beq bb08 <_Heap_Allocate_aligned_with_boundary+0x5c>
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
bb40: e59d3014 ldr r3, [sp, #20]
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
bb44: e3c99001 bic r9, r9, #1
uintptr_t alignment,
uintptr_t boundary
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
bb48: e5972014 ldr r2, [r7, #20]
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
bb4c: e08a9009 add r9, sl, r9
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
bb50: e59d1010 ldr r1, [sp, #16]
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
bb54: e0834009 add r4, r3, r9
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
bb58: e1a00004 mov r0, r4
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
bb5c: e0623001 rsb r3, r2, r1
bb60: e1a01008 mov r1, r8
uintptr_t alignment,
uintptr_t boundary
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
bb64: e58d2004 str r2, [sp, #4]
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
bb68: e0839009 add r9, r3, r9
bb6c: eb002b54 bl 168c4 <__umodsi3>
bb70: e0604004 rsb r4, r0, r4
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
bb74: e28a2008 add r2, sl, #8
uintptr_t alloc_begin = alloc_end - alloc_size;
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
bb78: e1590004 cmp r9, r4
bb7c: e58d2008 str r2, [sp, #8]
bb80: 2a000003 bcs bb94 <_Heap_Allocate_aligned_with_boundary+0xe8>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
bb84: e1a00009 mov r0, r9
bb88: e1a01008 mov r1, r8
bb8c: eb002b4c bl 168c4 <__umodsi3>
bb90: e0604009 rsb r4, r0, r9
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
bb94: e35b0000 cmp fp, #0
bb98: 0a000025 beq bc34 <_Heap_Allocate_aligned_with_boundary+0x188>
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment );
}
alloc_end = alloc_begin + alloc_size;
bb9c: e0849006 add r9, r4, r6
bba0: e1a00009 mov r0, r9
bba4: e1a0100b mov r1, fp
bba8: eb002b45 bl 168c4 <__umodsi3>
bbac: e0600009 rsb r0, r0, r9
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
bbb0: e1540000 cmp r4, r0
bbb4: 23a03000 movcs r3, #0
bbb8: 33a03001 movcc r3, #1
bbbc: e1590000 cmp r9, r0
bbc0: 93a03000 movls r3, #0
bbc4: e3530000 cmp r3, #0
bbc8: 0a000019 beq bc34 <_Heap_Allocate_aligned_with_boundary+0x188>
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
bbcc: e59d3008 ldr r3, [sp, #8]
bbd0: e0839006 add r9, r3, r6
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
if ( boundary_line < boundary_floor ) {
bbd4: e1590000 cmp r9, r0
bbd8: 958da018 strls sl, [sp, #24]
bbdc: 9a000002 bls bbec <_Heap_Allocate_aligned_with_boundary+0x140>
bbe0: ea00003c b bcd8 <_Heap_Allocate_aligned_with_boundary+0x22c>
bbe4: e1590000 cmp r9, r0
bbe8: 8a00003e bhi bce8 <_Heap_Allocate_aligned_with_boundary+0x23c>
return 0;
}
alloc_begin = boundary_line - alloc_size;
bbec: e0664000 rsb r4, r6, r0
bbf0: e1a01008 mov r1, r8
bbf4: e1a00004 mov r0, r4
bbf8: eb002b31 bl 168c4 <__umodsi3>
bbfc: e0604004 rsb r4, r0, r4
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
bc00: e084a006 add sl, r4, r6
bc04: e1a0000a mov r0, sl
bc08: e1a0100b mov r1, fp
bc0c: eb002b2c bl 168c4 <__umodsi3>
bc10: e060000a rsb r0, r0, sl
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
bc14: e15a0000 cmp sl, r0
bc18: 93a0a000 movls sl, #0
bc1c: 83a0a001 movhi sl, #1
bc20: e1540000 cmp r4, r0
bc24: 23a0a000 movcs sl, #0
bc28: e35a0000 cmp sl, #0
bc2c: 1affffec bne bbe4 <_Heap_Allocate_aligned_with_boundary+0x138>
bc30: e59da018 ldr sl, [sp, #24]
boundary_line = _Heap_Align_down( alloc_end, boundary );
}
}
/* Ensure that the we have a valid new block at the beginning */
if ( alloc_begin >= alloc_begin_floor ) {
bc34: e59d2008 ldr r2, [sp, #8]
bc38: e1520004 cmp r2, r4
bc3c: 8a000025 bhi bcd8 <_Heap_Allocate_aligned_with_boundary+0x22c>
bc40: e1a00004 mov r0, r4
bc44: e59d100c ldr r1, [sp, #12]
bc48: eb002b1d bl 168c4 <__umodsi3>
bc4c: e3e09007 mvn r9, #7
bc50: e06a9009 rsb r9, sl, r9
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
bc54: e0899004 add r9, r9, r4
if ( free_size >= min_block_size || free_size == 0 ) {
return alloc_begin;
}
}
return 0;
bc58: e59d2004 ldr r2, [sp, #4]
if ( alloc_begin >= alloc_begin_floor ) {
uintptr_t const alloc_block_begin =
(uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size );
uintptr_t const free_size = alloc_block_begin - block_begin;
if ( free_size >= min_block_size || free_size == 0 ) {
bc5c: e0603009 rsb r3, r0, r9
return alloc_begin;
}
}
return 0;
bc60: e1590000 cmp r9, r0
bc64: 11520003 cmpne r2, r3
bc68: 83a03000 movhi r3, #0
bc6c: 93a03001 movls r3, #1
bc70: 81a04003 movhi r4, r3
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
bc74: e3540000 cmp r4, #0
);
}
}
/* Statistics */
++search_count;
bc78: e2855001 add r5, r5, #1
if ( alloc_begin != 0 ) {
bc7c: 0affffa4 beq bb14 <_Heap_Allocate_aligned_with_boundary+0x68>
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
stats->searches += search_count;
bc80: e2872048 add r2, r7, #72 ; 0x48
bc84: e892000c ldm r2, {r2, r3}
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
bc88: e2822001 add r2, r2, #1
stats->searches += search_count;
bc8c: e0833005 add r3, r3, r5
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
bc90: e5872048 str r2, [r7, #72] ; 0x48
stats->searches += search_count;
bc94: e587304c str r3, [r7, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
bc98: e1a00007 mov r0, r7
bc9c: e1a0100a mov r1, sl
bca0: e1a02004 mov r2, r4
bca4: e1a03006 mov r3, r6
bca8: ebffef05 bl 78c4 <_Heap_Block_allocate>
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
bcac: e5973044 ldr r3, [r7, #68] ; 0x44
bcb0: e1530005 cmp r3, r5
stats->max_search = search_count;
bcb4: 35875044 strcc r5, [r7, #68] ; 0x44
}
return (void *) alloc_begin;
bcb8: e1a00004 mov r0, r4
}
bcbc: e28dd01c add sp, sp, #28
bcc0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
bcc4: e1560003 cmp r6, r3
bcc8: 8a000009 bhi bcf4 <_Heap_Allocate_aligned_with_boundary+0x248>
return NULL;
}
if ( alignment == 0 ) {
alignment = page_size;
bccc: e3580000 cmp r8, #0
bcd0: 01a08002 moveq r8, r2
bcd4: eaffff81 b bae0 <_Heap_Allocate_aligned_with_boundary+0x34>
if ( free_size >= min_block_size || free_size == 0 ) {
return alloc_begin;
}
}
return 0;
bcd8: e3a04000 mov r4, #0
bcdc: eaffff89 b bb08 <_Heap_Allocate_aligned_with_boundary+0x5c>
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
bce0: e3a04000 mov r4, #0
bce4: eafffff0 b bcac <_Heap_Allocate_aligned_with_boundary+0x200>
bce8: e59da018 ldr sl, [sp, #24] <== NOT EXECUTED
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
if ( boundary_line < boundary_floor ) {
return 0;
bcec: e3a04000 mov r4, #0 <== NOT EXECUTED
bcf0: eaffff84 b bb08 <_Heap_Allocate_aligned_with_boundary+0x5c><== NOT EXECUTED
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
return NULL;
bcf4: e3a00000 mov r0, #0
bcf8: eaffffef b bcbc <_Heap_Allocate_aligned_with_boundary+0x210>
0000bcfc <_Heap_Free>:
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
bcfc: e2513000 subs r3, r1, #0
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
bd00: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
bd04: e1a04000 mov r4, r0
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
return true;
bd08: 03a00001 moveq r0, #1
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
bd0c: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
bd10: e1a00003 mov r0, r3
bd14: e5941010 ldr r1, [r4, #16]
bd18: e2435008 sub r5, r3, #8
bd1c: eb002ae8 bl 168c4 <__umodsi3>
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
bd20: e5942020 ldr r2, [r4, #32]
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
bd24: e0605005 rsb r5, r0, r5
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
bd28: e1550002 cmp r5, r2
bd2c: 3a00002f bcc bdf0 <_Heap_Free+0xf4>
bd30: e5941024 ldr r1, [r4, #36] ; 0x24
bd34: e1550001 cmp r5, r1
bd38: 8a00002c bhi bdf0 <_Heap_Free+0xf4>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
bd3c: e595c004 ldr ip, [r5, #4]
bd40: e3cc6001 bic r6, ip, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
bd44: e0853006 add r3, r5, r6
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
bd48: e1520003 cmp r2, r3
bd4c: 8a000027 bhi bdf0 <_Heap_Free+0xf4>
bd50: e1510003 cmp r1, r3
bd54: 3a000027 bcc bdf8 <_Heap_Free+0xfc>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
bd58: e5937004 ldr r7, [r3, #4]
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
bd5c: e2170001 ands r0, r7, #1
bd60: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
bd64: e1510003 cmp r1, r3
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
bd68: e3c77001 bic r7, r7, #1
bd6c: 03a08000 moveq r8, #0
bd70: 0a000004 beq bd88 <_Heap_Free+0x8c>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
bd74: e0830007 add r0, r3, r7
bd78: e5900004 ldr r0, [r0, #4]
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
bd7c: e3100001 tst r0, #1
bd80: 13a08000 movne r8, #0
bd84: 03a08001 moveq r8, #1
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
bd88: e21c0001 ands r0, ip, #1
bd8c: 1a00001b bne be00 <_Heap_Free+0x104>
uintptr_t const prev_size = block->prev_size;
bd90: e595c000 ldr ip, [r5]
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
bd94: e06ca005 rsb sl, ip, r5
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
bd98: e152000a cmp r2, sl
bd9c: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
bda0: e151000a cmp r1, sl
bda4: 38bd85f0 popcc {r4, r5, r6, r7, r8, sl, pc}
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
bda8: e59a0004 ldr r0, [sl, #4]
return( false );
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
bdac: e2100001 ands r0, r0, #1
bdb0: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
bdb4: e3580000 cmp r8, #0
bdb8: 0a000039 beq bea4 <_Heap_Free+0x1a8>
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
bdbc: e5940038 ldr r0, [r4, #56] ; 0x38
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
bdc0: e0867007 add r7, r6, r7
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
bdc4: e2832008 add r2, r3, #8
bdc8: e892000c ldm r2, {r2, r3}
bdcc: e087c00c add ip, r7, ip
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
bdd0: e2400001 sub r0, r0, #1
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
bdd4: e38c1001 orr r1, ip, #1
prev->next = next;
bdd8: e5832008 str r2, [r3, #8]
next->prev = prev;
bddc: e582300c str r3, [r2, #12]
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
bde0: e5840038 str r0, [r4, #56] ; 0x38
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
bde4: e58a1004 str r1, [sl, #4]
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
bde8: e78ac00c str ip, [sl, ip]
bdec: ea00000f b be30 <_Heap_Free+0x134>
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
return false;
bdf0: e3a00000 mov r0, #0
bdf4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
bdf8: e3a00000 mov r0, #0 <== NOT EXECUTED
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
bdfc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
be00: e3580000 cmp r8, #0
be04: 0a000014 beq be5c <_Heap_Free+0x160>
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
be08: e2832008 add r2, r3, #8
be0c: e892000c ldm r2, {r2, r3}
uintptr_t const size = block_size + next_block_size;
be10: e0877006 add r7, r7, r6
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
be14: e3871001 orr r1, r7, #1
new_block->next = next;
be18: e5852008 str r2, [r5, #8]
new_block->prev = prev;
be1c: e585300c str r3, [r5, #12]
next->prev = new_block;
prev->next = new_block;
be20: e5835008 str r5, [r3, #8]
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
next->prev = new_block;
be24: e582500c str r5, [r2, #12]
be28: e5851004 str r1, [r5, #4]
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
be2c: e7857007 str r7, [r5, r7]
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
be30: e5942040 ldr r2, [r4, #64] ; 0x40
++stats->frees;
be34: e5943050 ldr r3, [r4, #80] ; 0x50
stats->free_size += block_size;
be38: e5941030 ldr r1, [r4, #48] ; 0x30
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
be3c: e2422001 sub r2, r2, #1
++stats->frees;
be40: e2833001 add r3, r3, #1
stats->free_size += block_size;
be44: e0816006 add r6, r1, r6
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
be48: e5842040 str r2, [r4, #64] ; 0x40
++stats->frees;
be4c: e5843050 str r3, [r4, #80] ; 0x50
stats->free_size += block_size;
be50: e5846030 str r6, [r4, #48] ; 0x30
return( true );
be54: e3a00001 mov r0, #1
be58: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
next_block->prev_size = size;
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
be5c: e3862001 orr r2, r6, #1
be60: e5852004 str r2, [r5, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
be64: e5942038 ldr r2, [r4, #56] ; 0x38
if ( stats->max_free_blocks < stats->free_blocks ) {
be68: e594c03c ldr ip, [r4, #60] ; 0x3c
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
be6c: e5930004 ldr r0, [r3, #4]
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
be70: e5941008 ldr r1, [r4, #8]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
be74: e2822001 add r2, r2, #1
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
be78: e3c00001 bic r0, r0, #1
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
if ( stats->max_free_blocks < stats->free_blocks ) {
be7c: e152000c cmp r2, ip
new_block->next = next;
be80: e5851008 str r1, [r5, #8]
new_block->prev = block_before;
be84: e585400c str r4, [r5, #12]
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
be88: e5830004 str r0, [r3, #4]
block_before->next = new_block; next->prev = new_block;
be8c: e581500c str r5, [r1, #12]
next_block->prev_size = block_size;
be90: e7856006 str r6, [r5, r6]
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
be94: e5845008 str r5, [r4, #8]
/* Statistics */
++stats->free_blocks;
be98: e5842038 str r2, [r4, #56] ; 0x38
if ( stats->max_free_blocks < stats->free_blocks ) {
stats->max_free_blocks = stats->free_blocks;
be9c: 8584203c strhi r2, [r4, #60] ; 0x3c
bea0: eaffffe2 b be30 <_Heap_Free+0x134>
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
bea4: e086c00c add ip, r6, ip
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
bea8: e38c2001 orr r2, ip, #1
beac: e58a2004 str r2, [sl, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
beb0: e5932004 ldr r2, [r3, #4]
beb4: e3c22001 bic r2, r2, #1
beb8: e5832004 str r2, [r3, #4]
next_block->prev_size = size;
bebc: e785c006 str ip, [r5, r6]
bec0: eaffffda b be30 <_Heap_Free+0x134>
0000961c <_Heap_Greedy_allocate>:
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
961c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
9620: e2528000 subs r8, r2, #0
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
9624: e1a04000 mov r4, r0
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); Heap_Block *allocated_blocks = NULL;
9628: 01a05008 moveq r5, r8
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
962c: 0a000012 beq 967c <_Heap_Greedy_allocate+0x60>
9630: e3a06000 mov r6, #0
9634: e1a07001 mov r7, r1
const uintptr_t *block_sizes,
size_t block_count
)
{
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
Heap_Block *allocated_blocks = NULL;
9638: e1a05006 mov r5, r6
* @brief See _Heap_Allocate_aligned_with_boundary() with alignment and
* boundary equals zero.
*/
RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size )
{
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
963c: e3a02000 mov r2, #0
9640: e4971004 ldr r1, [r7], #4
9644: e1a03002 mov r3, r2
9648: e1a00004 mov r0, r4
964c: eb001be1 bl 105d8 <_Heap_Allocate_aligned_with_boundary>
size_t i;
for (i = 0; i < block_count; ++i) {
void *next = _Heap_Allocate( heap, block_sizes [i] );
if ( next != NULL ) {
9650: e250a000 subs sl, r0, #0
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
9654: e2866001 add r6, r6, #1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
9658: e24aa008 sub sl, sl, #8
void *next = _Heap_Allocate( heap, block_sizes [i] );
if ( next != NULL ) {
965c: 0a000004 beq 9674 <_Heap_Greedy_allocate+0x58>
9660: e5941010 ldr r1, [r4, #16]
9664: eb004755 bl 1b3c0 <__umodsi3>
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
9668: e060000a rsb r0, r0, sl
Heap_Block *next_block = _Heap_Block_of_alloc_area(
(uintptr_t) next,
heap->page_size
);
next_block->next = allocated_blocks;
966c: e5805008 str r5, [r0, #8]
9670: e1a05000 mov r5, r0
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
9674: e1560008 cmp r6, r8
9678: 1affffef bne 963c <_Heap_Greedy_allocate+0x20>
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
967c: e5946008 ldr r6, [r4, #8]
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
9680: e1540006 cmp r4, r6
9684: 13a07000 movne r7, #0
9688: 1a000002 bne 9698 <_Heap_Greedy_allocate+0x7c>
968c: ea000018 b 96f4 <_Heap_Greedy_allocate+0xd8> <== NOT EXECUTED
9690: e1a07006 mov r7, r6
9694: e1a06003 mov r6, r3
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
9698: e5963004 ldr r3, [r6, #4]
969c: e3c33001 bic r3, r3, #1
_Heap_Block_allocate(
96a0: e2433008 sub r3, r3, #8
96a4: e1a01006 mov r1, r6
96a8: e2862008 add r2, r6, #8
96ac: e1a00004 mov r0, r4
96b0: eb0000d0 bl 99f8 <_Heap_Block_allocate>
current,
_Heap_Alloc_area_of_block( current ),
_Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE
);
current->next = blocks;
96b4: e5867008 str r7, [r6, #8]
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
96b8: e5943008 ldr r3, [r4, #8]
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
96bc: e1540003 cmp r4, r3
96c0: 1afffff2 bne 9690 <_Heap_Greedy_allocate+0x74>
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
96c4: e3550000 cmp r5, #0
96c8: 1a000001 bne 96d4 <_Heap_Greedy_allocate+0xb8>
96cc: ea000006 b 96ec <_Heap_Greedy_allocate+0xd0>
current = allocated_blocks;
allocated_blocks = allocated_blocks->next;
96d0: e1a05007 mov r5, r7
96d4: e1a01005 mov r1, r5
96d8: e5b17008 ldr r7, [r1, #8]!
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
96dc: e1a00004 mov r0, r4
96e0: eb001c50 bl 10828 <_Heap_Free>
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
96e4: e3570000 cmp r7, #0
96e8: 1afffff8 bne 96d0 <_Heap_Greedy_allocate+0xb4>
allocated_blocks = allocated_blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
}
return blocks;
}
96ec: e1a00006 mov r0, r6
96f0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
96f4: e3a06000 mov r6, #0 <== NOT EXECUTED
96f8: eafffff1 b 96c4 <_Heap_Greedy_allocate+0xa8> <== NOT EXECUTED
0001136c <_Heap_Iterate>:
Heap_Block_visitor visitor,
void *visitor_arg
)
{
Heap_Block *current = heap->first_block;
Heap_Block *end = heap->last_block;
1136c: e2800020 add r0, r0, #32
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
11370: e92d40f0 push {r4, r5, r6, r7, lr}
Heap_Block *current = heap->first_block; Heap_Block *end = heap->last_block;
11374: e8900021 ldm r0, {r0, r5}
bool stop = false;
while ( !stop && current != end ) {
11378: e1500005 cmp r0, r5
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
1137c: e1a07001 mov r7, r1 11380: e1a06002 mov r6, r2
Heap_Block *current = heap->first_block;
Heap_Block *end = heap->last_block;
bool stop = false;
while ( !stop && current != end ) {
11384: 1a000001 bne 11390 <_Heap_Iterate+0x24>
11388: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
1138c: e1a00004 mov r0, r4 11390: e5901004 ldr r1, [r0, #4] 11394: e3c11001 bic r1, r1, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
11398: e0804001 add r4, r0, r1
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
1139c: e5942004 ldr r2, [r4, #4]
uintptr_t size = _Heap_Block_size( current );
Heap_Block *next = _Heap_Block_at( current, size );
bool used = _Heap_Is_prev_used( next );
stop = (*visitor)( current, size, used, visitor_arg );
113a0: e1a03006 mov r3, r6 113a4: e2022001 and r2, r2, #1 113a8: e1a0e00f mov lr, pc 113ac: e12fff17 bx r7
{
Heap_Block *current = heap->first_block;
Heap_Block *end = heap->last_block;
bool stop = false;
while ( !stop && current != end ) {
113b0: e3500000 cmp r0, #0
113b4: 18bd80f0 popne {r4, r5, r6, r7, pc}
113b8: e1550004 cmp r5, r4
113bc: 1afffff2 bne 1138c <_Heap_Iterate+0x20>
113c0: e8bd80f0 pop {r4, r5, r6, r7, pc}
0000bff8 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
bff8: e92d4070 push {r4, r5, r6, lr}
bffc: e1a04000 mov r4, r0
c000: e1a05001 mov r5, r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
c004: e1a00001 mov r0, r1
c008: e5941010 ldr r1, [r4, #16]
c00c: e1a06002 mov r6, r2
c010: eb002a2b bl 168c4 <__umodsi3>
c014: e2452008 sub r2, r5, #8
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
c018: e5943020 ldr r3, [r4, #32]
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
c01c: e0602002 rsb r2, r0, r2
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
c020: e1520003 cmp r2, r3
c024: 3a000010 bcc c06c <_Heap_Size_of_alloc_area+0x74>
c028: e5941024 ldr r1, [r4, #36] ; 0x24
c02c: e1520001 cmp r2, r1
c030: 8a00000d bhi c06c <_Heap_Size_of_alloc_area+0x74>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
c034: e5920004 ldr r0, [r2, #4]
c038: e3c00001 bic r0, r0, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
c03c: e0822000 add r2, r2, r0
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
c040: e1530002 cmp r3, r2
c044: 8a000008 bhi c06c <_Heap_Size_of_alloc_area+0x74>
c048: e1510002 cmp r1, r2
c04c: 3a000008 bcc c074 <_Heap_Size_of_alloc_area+0x7c>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
c050: e5920004 ldr r0, [r2, #4]
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
c054: e2100001 ands r0, r0, #1
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
c058: 12655004 rsbne r5, r5, #4
c05c: 10852002 addne r2, r5, r2
c060: 15862000 strne r2, [r6]
return true;
c064: 13a00001 movne r0, #1
c068: e8bd8070 pop {r4, r5, r6, pc}
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
c06c: e3a00000 mov r0, #0
c070: e8bd8070 pop {r4, r5, r6, pc}
c074: e3a00000 mov r0, #0 <== NOT EXECUTED
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
c078: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00007a04 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
7a04: e52de004 push {lr} ; (str lr, [sp, #-4]!)
7a08: e24dd00c sub sp, sp, #12
7a0c: e1a04000 mov r4, r0
7a10: e20160ff and r6, r1, #255 ; 0xff
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, is_internal, error };
_User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );
7a14: e1a0000d mov r0, sp
7a18: e59f1040 ldr r1, [pc, #64] ; 7a60 <_Internal_error_Occurred+0x5c>
7a1c: e1a05002 mov r5, r2
Internal_errors_Source source,
bool is_internal,
Internal_errors_t error
)
{
User_extensions_Fatal_context ctx = { source, is_internal, error };
7a20: e58d2008 str r2, [sp, #8]
7a24: e58d4000 str r4, [sp]
7a28: e5cd6004 strb r6, [sp, #4]
_User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );
7a2c: eb0007be bl 992c <_User_extensions_Iterate>
_User_extensions_Fatal( the_source, is_internal, the_error );
_Internal_errors_What_happened.the_source = the_source;
7a30: e59f302c ldr r3, [pc, #44] ; 7a64 <_Internal_error_Occurred+0x60><== NOT EXECUTED
7a34: e5834000 str r4, [r3] <== NOT EXECUTED
_Internal_errors_What_happened.is_internal = is_internal;
7a38: e5c36004 strb r6, [r3, #4] <== NOT EXECUTED
_Internal_errors_What_happened.the_error = the_error;
7a3c: e5835008 str r5, [r3, #8] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
7a40: e59f3020 ldr r3, [pc, #32] ; 7a68 <_Internal_error_Occurred+0x64><== NOT EXECUTED
7a44: e3a02005 mov r2, #5 <== NOT EXECUTED
7a48: e5832000 str r2, [r3] <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
7a4c: e10f2000 mrs r2, CPSR <== NOT EXECUTED
7a50: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED
7a54: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
7a58: e1a00005 mov r0, r5 <== NOT EXECUTED
7a5c: eafffffe b 7a5c <_Internal_error_Occurred+0x58> <== NOT EXECUTED
00007b20 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
7b20: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
7b24: e5904034 ldr r4, [r0, #52] ; 0x34
7b28: e3540000 cmp r4, #0
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
7b2c: e24dd014 sub sp, sp, #20
7b30: e1a05000 mov r5, r0
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
7b34: e1d070b8 ldrh r7, [r0, #8]
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
7b38: e1d081b0 ldrh r8, [r0, #16]
7b3c: 0a0000a0 beq 7dc4 <_Objects_Extend_information+0x2a4>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
7b40: e1d0a1b4 ldrh sl, [r0, #20]
7b44: e1a00008 mov r0, r8
7b48: e1a0100a mov r1, sl
7b4c: eb003b16 bl 167ac <__aeabi_uidiv>
7b50: e1a0b800 lsl fp, r0, #16
for ( ; block < block_count; block++ ) {
7b54: e1b0b82b lsrs fp, fp, #16
7b58: 0a0000a1 beq 7de4 <_Objects_Extend_information+0x2c4>
if ( information->object_blocks[ block ] == NULL ) {
7b5c: e5949000 ldr r9, [r4]
7b60: e3590000 cmp r9, #0
7b64: 11a03004 movne r3, r4
7b68: e1a0200a mov r2, sl
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
7b6c: 11a06007 movne r6, r7
index_base = minimum_index; block = 0;
7b70: 13a04000 movne r4, #0
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
7b74: 01a06007 moveq r6, r7
index_base = minimum_index; block = 0;
7b78: 01a04009 moveq r4, r9
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
7b7c: 1a000003 bne 7b90 <_Objects_Extend_information+0x70>
7b80: ea000007 b 7ba4 <_Objects_Extend_information+0x84> <== NOT EXECUTED
7b84: e5b39004 ldr r9, [r3, #4]!
7b88: e3590000 cmp r9, #0
7b8c: 0a000004 beq 7ba4 <_Objects_Extend_information+0x84>
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
7b90: e2844001 add r4, r4, #1
7b94: e15b0004 cmp fp, r4
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
break;
} else
index_base += information->allocation_size;
7b98: e086600a add r6, r6, sl
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
7b9c: 8afffff8 bhi 7b84 <_Objects_Extend_information+0x64>
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
7ba0: e3a09001 mov r9, #1
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
7ba4: e0888002 add r8, r8, r2
/*
* We need to limit the number of objects to the maximum number
* representable in the index portion of the object Id. In the
* case of 16-bit Ids, this is only 256 object instances.
*/
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
7ba8: e3580801 cmp r8, #65536 ; 0x10000
7bac: 2a000063 bcs 7d40 <_Objects_Extend_information+0x220>
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
if ( information->auto_extend ) {
7bb0: e5d53012 ldrb r3, [r5, #18]
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
7bb4: e5950018 ldr r0, [r5, #24]
if ( information->auto_extend ) {
7bb8: e3530000 cmp r3, #0
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
7bbc: e0000092 mul r0, r2, r0
if ( information->auto_extend ) {
7bc0: 1a000060 bne 7d48 <_Objects_Extend_information+0x228>
new_object_block = _Workspace_Allocate( block_size );
if ( !new_object_block )
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
7bc4: eb0008b3 bl 9e98 <_Workspace_Allocate_or_fatal_error>
7bc8: e58d0004 str r0, [sp, #4]
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
7bcc: e3590000 cmp r9, #0
7bd0: 0a000039 beq 7cbc <_Objects_Extend_information+0x19c>
*/
/*
* Up the block count and maximum
*/
block_count++;
7bd4: e28b9001 add r9, fp, #1
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
7bd8: e0890089 add r0, r9, r9, lsl #1
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
7bdc: e5d53012 ldrb r3, [r5, #18]
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
7be0: e0880000 add r0, r8, r0
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
7be4: e0800007 add r0, r0, r7
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
7be8: e3530000 cmp r3, #0
block_count++;
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
7bec: e1a00100 lsl r0, r0, #2
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
7bf0: 0a000059 beq 7d5c <_Objects_Extend_information+0x23c>
object_blocks = _Workspace_Allocate( block_size );
7bf4: eb00089d bl 9e70 <_Workspace_Allocate>
if ( !object_blocks ) {
7bf8: e250a000 subs sl, r0, #0
7bfc: 0a000075 beq 7dd8 <_Objects_Extend_information+0x2b8>
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
7c00: e1d531b0 ldrh r3, [r5, #16]
7c04: e1570003 cmp r7, r3
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
7c08: e08a3109 add r3, sl, r9, lsl #2
7c0c: e08a9189 add r9, sl, r9, lsl #3
7c10: 3a000058 bcc 7d78 <_Objects_Extend_information+0x258>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
7c14: e3570000 cmp r7, #0
7c18: 13a02000 movne r2, #0
7c1c: 11a01009 movne r1, r9
local_table[ index ] = NULL;
7c20: 11a00002 movne r0, r2
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
7c24: 0a000003 beq 7c38 <_Objects_Extend_information+0x118>
7c28: e2822001 add r2, r2, #1
7c2c: e1570002 cmp r7, r2
local_table[ index ] = NULL;
7c30: e4810004 str r0, [r1], #4
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
7c34: 8afffffb bhi 7c28 <_Objects_Extend_information+0x108>
7c38: e1a0b10b lsl fp, fp, #2
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
7c3c: e1d501b4 ldrh r0, [r5, #20]
7c40: e0860000 add r0, r6, r0
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
7c44: e3a0c000 mov ip, #0
inactive_per_block[block_count] = 0;
for ( index=index_base ;
7c48: e1560000 cmp r6, r0
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
7c4c: e78ac00b str ip, [sl, fp]
inactive_per_block[block_count] = 0;
7c50: e783c00b str ip, [r3, fp]
for ( index=index_base ;
7c54: 2a000005 bcs 7c70 <_Objects_Extend_information+0x150>
7c58: e0891106 add r1, r9, r6, lsl #2
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
7c5c: e1a02006 mov r2, r6
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
7c60: e2822001 add r2, r2, #1
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
7c64: e1500002 cmp r0, r2
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
7c68: e481c004 str ip, [r1], #4
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
7c6c: 8afffffb bhi 7c60 <_Objects_Extend_information+0x140>
7c70: e10f2000 mrs r2, CPSR
7c74: e3821080 orr r1, r2, #128 ; 0x80
7c78: e129f001 msr CPSR_fc, r1
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
7c7c: e5951000 ldr r1, [r5]
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
7c80: e1d500b4 ldrh r0, [r5, #4]
7c84: e1a01c01 lsl r1, r1, #24
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
7c88: e1a08808 lsl r8, r8, #16
7c8c: e3811801 orr r1, r1, #65536 ; 0x10000
7c90: e1a08828 lsr r8, r8, #16
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
7c94: e1811d80 orr r1, r1, r0, lsl #27
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
7c98: e1811008 orr r1, r1, r8
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
7c9c: e5950034 ldr r0, [r5, #52] ; 0x34
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
7ca0: e5853030 str r3, [r5, #48] ; 0x30
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
7ca4: e585a034 str sl, [r5, #52] ; 0x34
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
7ca8: e585901c str r9, [r5, #28]
information->maximum = (Objects_Maximum) maximum;
7cac: e1c581b0 strh r8, [r5, #16]
information->maximum_id = _Objects_Build_id(
7cb0: e585100c str r1, [r5, #12]
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
7cb4: e129f002 msr CPSR_fc, r2
information->maximum
);
_ISR_Enable( level );
_Workspace_Free( old_tables );
7cb8: eb000872 bl 9e88 <_Workspace_Free>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
7cbc: e5953034 ldr r3, [r5, #52] ; 0x34
7cc0: e59d2004 ldr r2, [sp, #4]
7cc4: e7832104 str r2, [r3, r4, lsl #2]
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
7cc8: e5953034 ldr r3, [r5, #52] ; 0x34
7ccc: e28d0008 add r0, sp, #8
7cd0: e7931104 ldr r1, [r3, r4, lsl #2]
7cd4: e1d521b4 ldrh r2, [r5, #20]
7cd8: e5953018 ldr r3, [r5, #24]
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
7cdc: e1a04104 lsl r4, r4, #2
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
7ce0: ebfffcf2 bl 70b0 <_Chain_Initialize>
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
7ce4: e2857020 add r7, r5, #32
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
7ce8: ea000008 b 7d10 <_Objects_Extend_information+0x1f0>
7cec: e5952000 ldr r2, [r5]
the_object->id = _Objects_Build_id(
7cf0: e1d5c0b4 ldrh ip, [r5, #4]
7cf4: e1a02c02 lsl r2, r2, #24
7cf8: e3822801 orr r2, r2, #65536 ; 0x10000
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
7cfc: e1822d8c orr r2, r2, ip, lsl #27
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
7d00: e1822006 orr r2, r2, r6
7d04: e5832008 str r2, [r3, #8]
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
7d08: ebfffcd0 bl 7050 <_Chain_Append>
index++;
7d0c: e2866001 add r6, r6, #1
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
7d10: e28d0008 add r0, sp, #8
7d14: ebfffcd8 bl 707c <_Chain_Get>
7d18: e2503000 subs r3, r0, #0
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
7d1c: e1a01003 mov r1, r3
7d20: e1a00007 mov r0, r7
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
7d24: 1afffff0 bne 7cec <_Objects_Extend_information+0x1cc>
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
7d28: e1d522bc ldrh r2, [r5, #44] ; 0x2c
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
7d2c: e1d531b4 ldrh r3, [r5, #20]
7d30: e5951030 ldr r1, [r5, #48] ; 0x30
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
7d34: e0832002 add r2, r3, r2
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
7d38: e7813004 str r3, [r1, r4]
information->inactive =
7d3c: e1c522bc strh r2, [r5, #44] ; 0x2c
(Objects_Maximum)(information->inactive + information->allocation_size);
}
7d40: e28dd014 add sp, sp, #20
7d44: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
if ( information->auto_extend ) {
new_object_block = _Workspace_Allocate( block_size );
7d48: eb000848 bl 9e70 <_Workspace_Allocate>
if ( !new_object_block )
7d4c: e3500000 cmp r0, #0
7d50: e58d0004 str r0, [sp, #4]
7d54: 1affff9c bne 7bcc <_Objects_Extend_information+0xac>
7d58: eafffff8 b 7d40 <_Objects_Extend_information+0x220>
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
return;
}
} else {
object_blocks = _Workspace_Allocate_or_fatal_error( block_size );
7d5c: eb00084d bl 9e98 <_Workspace_Allocate_or_fatal_error>
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
7d60: e1d531b0 ldrh r3, [r5, #16]
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
return;
}
} else {
object_blocks = _Workspace_Allocate_or_fatal_error( block_size );
7d64: e1a0a000 mov sl, r0
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
7d68: e1570003 cmp r7, r3
7d6c: e08a3109 add r3, sl, r9, lsl #2
7d70: e08a9189 add r9, sl, r9, lsl #3
7d74: 2affffa6 bcs 7c14 <_Objects_Extend_information+0xf4>
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
7d78: e1a0b10b lsl fp, fp, #2
7d7c: e5951034 ldr r1, [r5, #52] ; 0x34
7d80: e1a0200b mov r2, fp
7d84: e1a0000a mov r0, sl
7d88: e58d3000 str r3, [sp]
7d8c: eb0018cf bl e0d0 <memcpy>
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
7d90: e59d3000 ldr r3, [sp]
7d94: e5951030 ldr r1, [r5, #48] ; 0x30
7d98: e1a00003 mov r0, r3
7d9c: e1a0200b mov r2, fp
7da0: eb0018ca bl e0d0 <memcpy>
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
7da4: e1d521b0 ldrh r2, [r5, #16]
7da8: e0872002 add r2, r7, r2
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
7dac: e1a00009 mov r0, r9
7db0: e595101c ldr r1, [r5, #28]
7db4: e1a02102 lsl r2, r2, #2
7db8: eb0018c4 bl e0d0 <memcpy>
7dbc: e59d3000 ldr r3, [sp]
7dc0: eaffff9d b 7c3c <_Objects_Extend_information+0x11c>
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
7dc4: e1d021b4 ldrh r2, [r0, #20]
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
7dc8: e1a06007 mov r6, r7
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
7dcc: e3a09001 mov r9, #1
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
7dd0: e1a0b004 mov fp, r4
7dd4: eaffff72 b 7ba4 <_Objects_Extend_information+0x84>
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
if ( information->auto_extend ) {
object_blocks = _Workspace_Allocate( block_size );
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
7dd8: e59d0004 ldr r0, [sp, #4]
7ddc: eb000829 bl 9e88 <_Workspace_Free>
return;
7de0: eaffffd6 b 7d40 <_Objects_Extend_information+0x220>
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
7de4: e1a0200a mov r2, sl <== NOT EXECUTED
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
7de8: e1a06007 mov r6, r7 <== NOT EXECUTED
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
7dec: e3a09001 mov r9, #1 <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0;
7df0: e1a0400b mov r4, fp <== NOT EXECUTED
7df4: eaffff6a b 7ba4 <_Objects_Extend_information+0x84> <== NOT EXECUTED
0000812c <_Objects_Shrink_information>:
#include <rtems/score/isr.h>
void _Objects_Shrink_information(
Objects_Information *information
)
{
812c: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
8130: e1d040b8 ldrh r4, [r0, #8]
block_count = (information->maximum - index_base) /
8134: e1d051b4 ldrh r5, [r0, #20]
#include <rtems/score/isr.h>
void _Objects_Shrink_information(
Objects_Information *information
)
{
8138: e1a06000 mov r6, r0
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
813c: e1d001b0 ldrh r0, [r0, #16]
8140: e1a01005 mov r1, r5
8144: e0640000 rsb r0, r4, r0
8148: eb003997 bl 167ac <__aeabi_uidiv>
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
814c: e3500000 cmp r0, #0
8150: 08bd80f0 popeq {r4, r5, r6, r7, pc}
if ( information->inactive_per_block[ block ] ==
8154: e5962030 ldr r2, [r6, #48] ; 0x30
8158: e5923000 ldr r3, [r2]
815c: e1550003 cmp r5, r3
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
8160: 13a03000 movne r3, #0
if ( information->inactive_per_block[ block ] ==
8164: 1a000005 bne 8180 <_Objects_Shrink_information+0x54>
8168: ea000008 b 8190 <_Objects_Shrink_information+0x64> <== NOT EXECUTED
816c: e5b21004 ldr r1, [r2, #4]!
8170: e1550001 cmp r5, r1
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
8174: e0844005 add r4, r4, r5
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] ==
8178: e1a07103 lsl r7, r3, #2
817c: 0a000004 beq 8194 <_Objects_Shrink_information+0x68>
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
8180: e2833001 add r3, r3, #1
8184: e1530000 cmp r3, r0
8188: 1afffff7 bne 816c <_Objects_Shrink_information+0x40>
818c: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( information->inactive_per_block[ block ] ==
8190: e3a07000 mov r7, #0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
8194: e5960020 ldr r0, [r6, #32]
8198: ea000002 b 81a8 <_Objects_Shrink_information+0x7c>
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
819c: e3550000 cmp r5, #0
81a0: 0a00000b beq 81d4 <_Objects_Shrink_information+0xa8>
index = _Objects_Get_index( the_object->id );
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
81a4: e1a00005 mov r0, r5
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
do {
index = _Objects_Get_index( the_object->id );
81a8: e1d030b8 ldrh r3, [r0, #8]
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
81ac: e1530004 cmp r3, r4
index = _Objects_Get_index( the_object->id );
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
81b0: e5905000 ldr r5, [r0]
if ((index >= index_base) &&
81b4: 3afffff8 bcc 819c <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
81b8: e1d621b4 ldrh r2, [r6, #20]
81bc: e0842002 add r2, r4, r2
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
81c0: e1530002 cmp r3, r2
81c4: 2afffff4 bcs 819c <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
81c8: eb000de3 bl b95c <_Chain_Extract>
}
}
while ( the_object );
81cc: e3550000 cmp r5, #0
81d0: 1afffff3 bne 81a4 <_Objects_Shrink_information+0x78>
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
81d4: e5963034 ldr r3, [r6, #52] ; 0x34
81d8: e7930007 ldr r0, [r3, r7]
81dc: eb000729 bl 9e88 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
81e0: e5963034 ldr r3, [r6, #52] ; 0x34
81e4: e7835007 str r5, [r3, r7]
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
81e8: e1d612bc ldrh r1, [r6, #44] ; 0x2c
81ec: e1d631b4 ldrh r3, [r6, #20]
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
81f0: e5962030 ldr r2, [r6, #48] ; 0x30
information->inactive -= information->allocation_size;
81f4: e0633001 rsb r3, r3, r1
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
81f8: e7825007 str r5, [r2, r7]
information->inactive -= information->allocation_size;
81fc: e1c632bc strh r3, [r6, #44] ; 0x2c
return;
8200: e8bd80f0 pop {r4, r5, r6, r7, pc}
00008ef8 <_RBTree_Extract_validate_unprotected>:
)
{
RBTree_Node *parent, *sibling;
RBTree_Direction dir;
parent = the_node->parent;
8ef8: e5903000 ldr r3, [r0]
if(!parent->parent) return;
8efc: e5932000 ldr r2, [r3]
8f00: e3520000 cmp r2, #0
* of the extract operation.
*/
static void _RBTree_Extract_validate_unprotected(
RBTree_Node *the_node
)
{
8f04: e92d07f0 push {r4, r5, r6, r7, r8, r9, sl}
RBTree_Node *parent, *sibling;
RBTree_Direction dir;
parent = the_node->parent;
if(!parent->parent) return;
8f08: 0a00002f beq 8fcc <_RBTree_Extract_validate_unprotected+0xd4>
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
if(the_node == the_node->parent->child[RBT_LEFT])
8f0c: e5932004 ldr r2, [r3, #4]
8f10: e1500002 cmp r0, r2
return the_node->parent->child[RBT_RIGHT];
8f14: 05932008 ldreq r2, [r3, #8]
* Now the_node has a black sibling and red parent. After rotation,
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
8f18: e3a06000 mov r6, #0
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
8f1c: e3a05001 mov r5, #1
8f20: ea000022 b 8fb0 <_RBTree_Extract_validate_unprotected+0xb8>
if(!parent->parent) return;
sibling = _RBTree_Sibling(the_node);
/* continue to correct tree as long as the_node is black and not the root */
while (!_RBTree_Is_red(the_node) && parent->parent) {
8f24: e5931000 ldr r1, [r3]
8f28: e3510000 cmp r1, #0
8f2c: 0a000022 beq 8fbc <_RBTree_Extract_validate_unprotected+0xc4>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
8f30: e3520000 cmp r2, #0
8f34: 0a000002 beq 8f44 <_RBTree_Extract_validate_unprotected+0x4c>
8f38: e592c00c ldr ip, [r2, #12]
8f3c: e35c0001 cmp ip, #1
8f40: 0a000023 beq 8fd4 <_RBTree_Extract_validate_unprotected+0xdc>
_RBTree_Rotate(parent, dir);
sibling = parent->child[_RBTree_Opposite_direction(dir)];
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
8f44: e5921008 ldr r1, [r2, #8]
8f48: e3510000 cmp r1, #0
8f4c: 0a000002 beq 8f5c <_RBTree_Extract_validate_unprotected+0x64>
8f50: e591c00c ldr ip, [r1, #12]
8f54: e35c0001 cmp ip, #1
8f58: 0a000042 beq 9068 <_RBTree_Extract_validate_unprotected+0x170>
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
8f5c: e592c004 ldr ip, [r2, #4]
8f60: e35c0000 cmp ip, #0
8f64: 0a000002 beq 8f74 <_RBTree_Extract_validate_unprotected+0x7c>
8f68: e59cc00c ldr ip, [ip, #12]
8f6c: e35c0001 cmp ip, #1
8f70: 0a00003c beq 9068 <_RBTree_Extract_validate_unprotected+0x170>
sibling->color = RBT_RED;
8f74: e582500c str r5, [r2, #12]
8f78: e593200c ldr r2, [r3, #12]
8f7c: e3520001 cmp r2, #1
8f80: 0a000033 beq 9054 <_RBTree_Extract_validate_unprotected+0x15c>
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
break;
}
the_node = parent; /* done if parent is red */
parent = the_node->parent;
8f84: e5931000 ldr r1, [r3]
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
8f88: e3510000 cmp r1, #0
8f8c: 0a000033 beq 9060 <_RBTree_Extract_validate_unprotected+0x168>
if(!(the_node->parent->parent)) return NULL;
8f90: e5912000 ldr r2, [r1]
8f94: e3520000 cmp r2, #0
8f98: 0a000002 beq 8fa8 <_RBTree_Extract_validate_unprotected+0xb0>
if(the_node == the_node->parent->child[RBT_LEFT])
8f9c: e5912004 ldr r2, [r1, #4]
8fa0: e1530002 cmp r3, r2
return the_node->parent->child[RBT_RIGHT];
8fa4: 05912008 ldreq r2, [r1, #8]
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
c->parent = the_node->parent;
the_node->parent = c;
8fa8: e1a00003 mov r0, r3
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
8fac: e1a03001 mov r3, r1
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
8fb0: e590100c ldr r1, [r0, #12]
8fb4: e3510001 cmp r1, #1
8fb8: 1affffd9 bne 8f24 <_RBTree_Extract_validate_unprotected+0x2c>
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
8fbc: e5903000 ldr r3, [r0]
8fc0: e5933000 ldr r3, [r3]
8fc4: e3530000 cmp r3, #0
8fc8: 0580300c streq r3, [r0, #12]
}
8fcc: e8bd07f0 pop {r4, r5, r6, r7, r8, r9, sl}
8fd0: e12fff1e bx lr
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
8fd4: e5934004 ldr r4, [r3, #4]
8fd8: e054a000 subs sl, r4, r0
8fdc: 13a0a001 movne sl, #1
* This function maintains the properties of the red-black tree. * * @note It does NOT disable interrupts to ensure the atomicity * of the extract operation. */ static void _RBTree_Extract_validate_unprotected(
8fe0: e22a7001 eor r7, sl, #1
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
8fe4: e2878001 add r8, r7, #1
8fe8: e7939108 ldr r9, [r3, r8, lsl #2]
8fec: e3590000 cmp r9, #0
* then rotate parent left, making the sibling be the_node's grandparent.
* Now the_node has a black sibling and red parent. After rotation,
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
8ff0: e583c00c str ip, [r3, #12]
sibling->color = RBT_BLACK;
8ff4: e582600c str r6, [r2, #12]
8ff8: 01a02009 moveq r2, r9
8ffc: 0affffd0 beq 8f44 <_RBTree_Extract_validate_unprotected+0x4c>
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
9000: e3570000 cmp r7, #0
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
9004: 15934008 ldrne r4, [r3, #8]
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
9008: e28a2001 add r2, sl, #1
900c: e794a102 ldr sl, [r4, r2, lsl #2]
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
9010: 01a0c007 moveq ip, r7
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
9014: e28cc001 add ip, ip, #1
9018: e783a10c str sl, [r3, ip, lsl #2]
if (c->child[dir])
901c: e794c102 ldr ip, [r4, r2, lsl #2]
9020: e35c0000 cmp ip, #0
c->child[dir]->parent = the_node;
9024: 158c3000 strne r3, [ip]
c->child[dir] = the_node;
9028: e7843102 str r3, [r4, r2, lsl #2]
902c: 15931000 ldrne r1, [r3]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
9030: e5912004 ldr r2, [r1, #4]
9034: e1530002 cmp r3, r2
9038: 13a02008 movne r2, #8
903c: 03a02004 moveq r2, #4
9040: e7824001 str r4, [r2, r1]
c->parent = the_node->parent;
9044: e5841000 str r1, [r4]
the_node->parent = c;
9048: e7932108 ldr r2, [r3, r8, lsl #2]
904c: e5834000 str r4, [r3]
9050: eaffffbb b 8f44 <_RBTree_Extract_validate_unprotected+0x4c>
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
sibling->color = RBT_RED;
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
9054: e3a02000 mov r2, #0
9058: e583200c str r2, [r3, #12]
break;
905c: eaffffd6 b 8fbc <_RBTree_Extract_validate_unprotected+0xc4>
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
9060: e1a02001 mov r2, r1 <== NOT EXECUTED
9064: eaffffcf b 8fa8 <_RBTree_Extract_validate_unprotected+0xb0><== NOT EXECUTED
* cases, either the_node is to the left or the right of the parent.
* In both cases, first check if one of sibling's children is black,
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
9068: e5936004 ldr r6, [r3, #4]
906c: e0566000 subs r6, r6, r0
9070: 13a06001 movne r6, #1
* This function maintains the properties of the red-black tree. * * @note It does NOT disable interrupts to ensure the atomicity * of the extract operation. */ static void _RBTree_Extract_validate_unprotected(
9074: e2265001 eor r5, r6, #1
* In both cases, first check if one of sibling's children is black,
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
9078: e285c001 add ip, r5, #1
907c: e792410c ldr r4, [r2, ip, lsl #2]
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
9080: e3540000 cmp r4, #0
9084: 0a000003 beq 9098 <_RBTree_Extract_validate_unprotected+0x1a0>
9088: e594700c ldr r7, [r4, #12]
908c: e3570001 cmp r7, #1
9090: 0793710c ldreq r7, [r3, ip, lsl #2]
9094: 0a00001f beq 9118 <_RBTree_Extract_validate_unprotected+0x220>
* This function maintains the properties of the red-black tree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
static void _RBTree_Extract_validate_unprotected(
9098: e2254001 eor r4, r5, #1
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
909c: e2848001 add r8, r4, #1
90a0: e792a108 ldr sl, [r2, r8, lsl #2]
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
90a4: e2867001 add r7, r6, #1
90a8: e7928107 ldr r8, [r2, r7, lsl #2]
90ac: e35a0000 cmp sl, #0
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
sibling->color = RBT_RED;
90b0: e3a07001 mov r7, #1
sibling->child[dir]->color = RBT_BLACK;
90b4: e3a0a000 mov sl, #0
* and if so rotate in the proper direction and update sibling pointer.
* Then switch the sibling and parent colors, and rotate through parent.
*/
dir = the_node != parent->child[0];
if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
sibling->color = RBT_RED;
90b8: e582700c str r7, [r2, #12]
sibling->child[dir]->color = RBT_BLACK;
90bc: e588a00c str sl, [r8, #12]
90c0: 0a000011 beq 910c <_RBTree_Extract_validate_unprotected+0x214>
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
90c4: e3540000 cmp r4, #0
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
90c8: 05921004 ldreq r1, [r2, #4]
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
90cc: 11a04007 movne r4, r7
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
90d0: e791810c ldr r8, [r1, ip, lsl #2]
90d4: e2844001 add r4, r4, #1
90d8: e7828104 str r8, [r2, r4, lsl #2]
if (c->child[dir])
90dc: e791410c ldr r4, [r1, ip, lsl #2]
90e0: e3540000 cmp r4, #0
c->child[dir]->parent = the_node;
90e4: 15842000 strne r2, [r4]
c->child[dir] = the_node;
90e8: e781210c str r2, [r1, ip, lsl #2]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
90ec: e5924000 ldr r4, [r2]
90f0: e5947004 ldr r7, [r4, #4]
90f4: e1520007 cmp r2, r7
90f8: 13a07008 movne r7, #8
90fc: 03a07004 moveq r7, #4
c->parent = the_node->parent;
9100: e5814000 str r4, [r1]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
9104: e7871004 str r1, [r7, r4]
c->parent = the_node->parent;
the_node->parent = c;
9108: e5821000 str r1, [r2]
_RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));
sibling = parent->child[_RBTree_Opposite_direction(dir)];
910c: e793210c ldr r2, [r3, ip, lsl #2]
9110: e792410c ldr r4, [r2, ip, lsl #2]
9114: e1a07002 mov r7, r2
}
sibling->color = parent->color;
9118: e593c00c ldr ip, [r3, #12]
parent->color = RBT_BLACK;
911c: e3a01000 mov r1, #0
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
9120: e1570001 cmp r7, r1
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, _RBTree_Opposite_direction(dir));
sibling = parent->child[_RBTree_Opposite_direction(dir)];
}
sibling->color = parent->color;
9124: e582c00c str ip, [r2, #12]
parent->color = RBT_BLACK;
9128: e583100c str r1, [r3, #12]
sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
912c: e584100c str r1, [r4, #12]
9130: 0affffa1 beq 8fbc <_RBTree_Extract_validate_unprotected+0xc4>
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
9134: e1550001 cmp r5, r1
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
9138: 05932004 ldreq r2, [r3, #4]
913c: 15932008 ldrne r2, [r3, #8]
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
9140: e2866001 add r6, r6, #1
9144: e7921106 ldr r1, [r2, r6, lsl #2]
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
9148: 13a05001 movne r5, #1
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
914c: e2855001 add r5, r5, #1
9150: e7831105 str r1, [r3, r5, lsl #2]
if (c->child[dir])
9154: e7921106 ldr r1, [r2, r6, lsl #2]
9158: e3510000 cmp r1, #0
c->child[dir]->parent = the_node;
915c: 15813000 strne r3, [r1]
c->child[dir] = the_node;
9160: e7823106 str r3, [r2, r6, lsl #2]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
9164: e5931000 ldr r1, [r3]
9168: e591c004 ldr ip, [r1, #4]
916c: e153000c cmp r3, ip
9170: 13a0c008 movne ip, #8
9174: 03a0c004 moveq ip, #4
c->parent = the_node->parent;
9178: e5821000 str r1, [r2]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
917c: e78c2001 str r2, [ip, r1]
c->parent = the_node->parent;
the_node->parent = c;
9180: e5832000 str r2, [r3]
9184: eaffff8c b 8fbc <_RBTree_Extract_validate_unprotected+0xc4>
00009bd8 <_Scheduler_CBS_Cleanup>:
#include <rtems/config.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulercbs.h>
int _Scheduler_CBS_Cleanup (void)
{
9bd8: e92d4070 push {r4, r5, r6, lr}
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
9bdc: e59f5054 ldr r5, [pc, #84] ; 9c38 <_Scheduler_CBS_Cleanup+0x60>
9be0: e5953000 ldr r3, [r5]
9be4: e3530000 cmp r3, #0
9be8: 0a00000f beq 9c2c <_Scheduler_CBS_Cleanup+0x54>
9bec: e59f6048 ldr r6, [pc, #72] ; 9c3c <_Scheduler_CBS_Cleanup+0x64>
9bf0: e5960000 ldr r0, [r6]
9bf4: e3a04000 mov r4, #0
if ( _Scheduler_CBS_Server_list[ i ] )
9bf8: e7903104 ldr r3, [r0, r4, lsl #2]
9bfc: e3530000 cmp r3, #0
9c00: 0a000002 beq 9c10 <_Scheduler_CBS_Cleanup+0x38>
_Scheduler_CBS_Destroy_server( i );
9c04: e1a00004 mov r0, r4
9c08: eb000043 bl 9d1c <_Scheduler_CBS_Destroy_server>
9c0c: e5960000 ldr r0, [r6]
int _Scheduler_CBS_Cleanup (void)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
9c10: e5953000 ldr r3, [r5]
9c14: e2844001 add r4, r4, #1
9c18: e1530004 cmp r3, r4
9c1c: 8afffff5 bhi 9bf8 <_Scheduler_CBS_Cleanup+0x20>
if ( _Scheduler_CBS_Server_list[ i ] )
_Scheduler_CBS_Destroy_server( i );
}
_Workspace_Free( _Scheduler_CBS_Server_list );
9c20: eb0007cc bl bb58 <_Workspace_Free>
return SCHEDULER_CBS_OK; }
9c24: e3a00000 mov r0, #0
9c28: e8bd8070 pop {r4, r5, r6, pc}
int _Scheduler_CBS_Cleanup (void)
{
unsigned int i;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
9c2c: e59f3008 ldr r3, [pc, #8] ; 9c3c <_Scheduler_CBS_Cleanup+0x64><== NOT EXECUTED
9c30: e5930000 ldr r0, [r3] <== NOT EXECUTED
9c34: eafffff9 b 9c20 <_Scheduler_CBS_Cleanup+0x48> <== NOT EXECUTED
00009c40 <_Scheduler_CBS_Create_server>:
)
{
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
9c40: e5903004 ldr r3, [r0, #4]
9c44: e3530000 cmp r3, #0
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
9c48: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
9c4c: e1a04000 mov r4, r0
9c50: e1a05001 mov r5, r1
9c54: e1a07002 mov r7, r2
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
9c58: da000029 ble 9d04 <_Scheduler_CBS_Create_server+0xc4>
9c5c: e5903000 ldr r3, [r0]
9c60: e3530000 cmp r3, #0
9c64: da000026 ble 9d04 <_Scheduler_CBS_Create_server+0xc4>
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++ ) {
9c68: e59f30a4 ldr r3, [pc, #164] ; 9d14 <_Scheduler_CBS_Create_server+0xd4>
9c6c: e5930000 ldr r0, [r3]
9c70: e3500000 cmp r0, #0
9c74: 0a00000d beq 9cb0 <_Scheduler_CBS_Create_server+0x70>
if ( !_Scheduler_CBS_Server_list[i] )
9c78: e59f8098 ldr r8, [pc, #152] ; 9d18 <_Scheduler_CBS_Create_server+0xd8>
9c7c: e5986000 ldr r6, [r8]
9c80: e596a000 ldr sl, [r6]
9c84: e35a0000 cmp sl, #0
9c88: 11a02006 movne r2, r6
9c8c: 13a03000 movne r3, #0
9c90: 1a000003 bne 9ca4 <_Scheduler_CBS_Create_server+0x64>
9c94: ea000018 b 9cfc <_Scheduler_CBS_Create_server+0xbc>
9c98: e5b21004 ldr r1, [r2, #4]!
9c9c: e3510000 cmp r1, #0
9ca0: 0a000004 beq 9cb8 <_Scheduler_CBS_Create_server+0x78>
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++ ) {
9ca4: e2833001 add r3, r3, #1
9ca8: e1530000 cmp r3, r0
9cac: 1afffff9 bne 9c98 <_Scheduler_CBS_Create_server+0x58>
if ( !_Scheduler_CBS_Server_list[i] )
break;
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
9cb0: e3e00019 mvn r0, #25
9cb4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
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++ ) {
9cb8: e1a0a103 lsl sl, r3, #2
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
9cbc: e5873000 str r3, [r7]
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
9cc0: e3a00010 mov r0, #16
9cc4: eb00079d bl bb40 <_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 *)
9cc8: e786000a str r0, [r6, sl]
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
9ccc: e5972000 ldr r2, [r7]
9cd0: e5983000 ldr r3, [r8]
9cd4: e7933102 ldr r3, [r3, r2, lsl #2]
if ( !the_server )
9cd8: e3530000 cmp r3, #0
9cdc: 0a00000a beq 9d0c <_Scheduler_CBS_Create_server+0xcc>
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
9ce0: e8940003 ldm r4, {r0, r1}
the_server->task_id = -1;
9ce4: 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;
9ce8: e9830003 stmib r3, {r0, r1}
the_server->task_id = -1;
9cec: e5832000 str r2, [r3]
the_server->cbs_budget_overrun = budget_overrun_callback;
9cf0: e583500c str r5, [r3, #12]
return SCHEDULER_CBS_OK;
9cf4: e3a00000 mov r0, #0
9cf8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
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++ ) {
if ( !_Scheduler_CBS_Server_list[i] )
9cfc: e1a0300a mov r3, sl
9d00: eaffffed b 9cbc <_Scheduler_CBS_Create_server+0x7c>
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;
9d04: e3e00011 mvn r0, #17
9d08: e8bd85f0 pop {r4, r5, r6, r7, r8, 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;
9d0c: 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;
}
9d10: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
00007274 <_TOD_Validate>:
};
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
7274: e92d4010 push {r4, lr}
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
7278: e2504000 subs r4, r0, #0
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
727c: 01a00004 moveq r0, r4
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
7280: 08bd8010 popeq {r4, pc}
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
7284: e59f3098 ldr r3, [pc, #152] ; 7324 <_TOD_Validate+0xb0>
7288: e59f0098 ldr r0, [pc, #152] ; 7328 <_TOD_Validate+0xb4>
728c: e593100c ldr r1, [r3, #12]
7290: eb00454b bl 187c4 <__aeabi_uidiv>
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
7294: e5943018 ldr r3, [r4, #24]
7298: e1500003 cmp r0, r3
729c: 9a00001c bls 7314 <_TOD_Validate+0xa0>
(the_tod->ticks >= ticks_per_second) ||
72a0: e5943014 ldr r3, [r4, #20]
72a4: e353003b cmp r3, #59 ; 0x3b
72a8: 8a000019 bhi 7314 <_TOD_Validate+0xa0>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
72ac: e5943010 ldr r3, [r4, #16]
72b0: e353003b cmp r3, #59 ; 0x3b
72b4: 8a000016 bhi 7314 <_TOD_Validate+0xa0>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
72b8: e594300c ldr r3, [r4, #12]
72bc: e3530017 cmp r3, #23
72c0: 8a000013 bhi 7314 <_TOD_Validate+0xa0>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
72c4: e5940004 ldr r0, [r4, #4]
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
72c8: e3500000 cmp r0, #0
72cc: 08bd8010 popeq {r4, pc}
(the_tod->month == 0) ||
72d0: e350000c cmp r0, #12
72d4: 8a00000e bhi 7314 <_TOD_Validate+0xa0>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
72d8: e5943000 ldr r3, [r4]
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
72dc: e59f2048 ldr r2, [pc, #72] ; 732c <_TOD_Validate+0xb8>
72e0: e1530002 cmp r3, r2
72e4: 9a00000a bls 7314 <_TOD_Validate+0xa0>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
72e8: e5944008 ldr r4, [r4, #8]
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
72ec: e3540000 cmp r4, #0
72f0: 0a000009 beq 731c <_TOD_Validate+0xa8>
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
72f4: e3130003 tst r3, #3
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
72f8: e59f3030 ldr r3, [pc, #48] ; 7330 <_TOD_Validate+0xbc>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
72fc: 0280000d addeq r0, r0, #13
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
7300: e7930100 ldr r0, [r3, r0, lsl #2]
const uint32_t _TOD_Days_per_month[ 2 ][ 13 ] = {
{ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
{ 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
};
bool _TOD_Validate(
7304: e1500004 cmp r0, r4
7308: 33a00000 movcc r0, #0
730c: 23a00001 movcs r0, #1
7310: e8bd8010 pop {r4, pc}
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
7314: e3a00000 mov r0, #0
7318: e8bd8010 pop {r4, pc}
731c: e1a00004 mov r0, r4 <== NOT EXECUTED
if ( the_tod->day > days_in_month )
return false;
return true;
}
7320: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00009390 <_Thread_queue_Enqueue_priority>:
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
9390: e5913014 ldr r3, [r1, #20]
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
9394: e1a0c323 lsr ip, r3, #6
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
9398: e92d07f0 push {r4, r5, r6, r7, r8, r9, sl}
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
939c: e08cc08c add ip, ip, ip, lsl #1
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 );
93a0: e281503c add r5, r1, #60 ; 0x3c
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
93a4: e3130020 tst r3, #32
93a8: e2814038 add r4, r1, #56 ; 0x38
head->next = tail;
93ac: e5815038 str r5, [r1, #56] ; 0x38
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
93b0: e080c10c add ip, r0, ip, lsl #2
head->previous = NULL;
93b4: e3a05000 mov r5, #0
93b8: e581503c str r5, [r1, #60] ; 0x3c
tail->previous = head;
93bc: e5814040 str r4, [r1, #64] ; 0x40
block_state = the_thread_queue->state;
93c0: e5906038 ldr r6, [r0, #56] ; 0x38
93c4: 028c9004 addeq r9, ip, #4
93c8: 159f9164 ldrne r9, [pc, #356] ; 9534 <_Thread_queue_Enqueue_priority+0x1a4>
if ( _Thread_queue_Is_reverse_search( priority ) )
93cc: 1a00001b bne 9440 <_Thread_queue_Enqueue_priority+0xb0>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
93d0: e10fa000 mrs sl, CPSR
93d4: e38a4080 orr r4, sl, #128 ; 0x80
93d8: e129f004 msr CPSR_fc, r4
93dc: e1a0800a mov r8, sl
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
93e0: e59c4000 ldr r4, [ip]
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 ) ) {
93e4: e1540009 cmp r4, r9
93e8: 1a000009 bne 9414 <_Thread_queue_Enqueue_priority+0x84>
93ec: ea00004e b 952c <_Thread_queue_Enqueue_priority+0x19c>
static inline void arm_interrupt_flash( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
93f0: e10f7000 mrs r7, CPSR
93f4: e129f00a msr CPSR_fc, sl
93f8: e129f007 msr CPSR_fc, r7
RTEMS_INLINE_ROUTINE bool _States_Are_set (
States_Control the_states,
States_Control mask
)
{
return ( (the_states & mask) != STATES_READY);
93fc: e5947010 ldr r7, [r4, #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) ) {
9400: e1160007 tst r6, r7
9404: 0a000031 beq 94d0 <_Thread_queue_Enqueue_priority+0x140>
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
9408: e5944000 ldr r4, [r4]
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 ) ) {
940c: e1540009 cmp r4, r9
9410: 0a000002 beq 9420 <_Thread_queue_Enqueue_priority+0x90>
search_priority = search_thread->current_priority;
9414: e5945014 ldr r5, [r4, #20]
if ( priority <= search_priority )
9418: e1530005 cmp r3, r5
941c: 8afffff3 bhi 93f0 <_Thread_queue_Enqueue_priority+0x60>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
9420: e590c030 ldr ip, [r0, #48] ; 0x30
9424: e35c0001 cmp ip, #1
9428: 0a00002a beq 94d8 <_Thread_queue_Enqueue_priority+0x148>
* 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;
942c: e5828000 str r8, [r2]
return the_thread_queue->sync_state; }
9430: e1a0000c mov r0, ip
9434: e8bd07f0 pop {r4, r5, r6, r7, r8, r9, sl}
9438: e12fff1e bx lr
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
943c: e129f00a msr CPSR_fc, sl <== NOT EXECUTED
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
9440: e5d95000 ldrb r5, [r9]
9444: e2855001 add r5, r5, #1
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
9448: e10fa000 mrs sl, CPSR
944c: e38a4080 orr r4, sl, #128 ; 0x80
9450: e129f004 msr CPSR_fc, r4
9454: e1a0800a mov r8, sl
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
9458: e59c4008 ldr r4, [ip, #8]
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
945c: e154000c cmp r4, ip
9460: 1a000009 bne 948c <_Thread_queue_Enqueue_priority+0xfc>
9464: ea00000b b 9498 <_Thread_queue_Enqueue_priority+0x108>
static inline void arm_interrupt_flash( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
9468: e10f7000 mrs r7, CPSR
946c: e129f00a msr CPSR_fc, sl
9470: e129f007 msr CPSR_fc, r7
9474: e5947010 ldr r7, [r4, #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) ) {
9478: e1160007 tst r6, r7
947c: 0affffee beq 943c <_Thread_queue_Enqueue_priority+0xac>
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
9480: e5944004 ldr r4, [r4, #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 ) ) {
9484: e154000c cmp r4, ip
9488: 0a000002 beq 9498 <_Thread_queue_Enqueue_priority+0x108>
search_priority = search_thread->current_priority;
948c: e5945014 ldr r5, [r4, #20]
if ( priority >= search_priority )
9490: e1530005 cmp r3, r5
9494: 3afffff3 bcc 9468 <_Thread_queue_Enqueue_priority+0xd8>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
9498: e590c030 ldr ip, [r0, #48] ; 0x30
949c: e35c0001 cmp ip, #1
94a0: 1affffe1 bne 942c <_Thread_queue_Enqueue_priority+0x9c>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
94a4: e1530005 cmp r3, r5
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
94a8: e3a03000 mov r3, #0
94ac: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
94b0: 0a000014 beq 9508 <_Thread_queue_Enqueue_priority+0x178>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
94b4: e5943000 ldr r3, [r4]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
94b8: e8810018 stm r1, {r3, r4}
the_node->previous = search_node; search_node->next = the_node; next_node->previous = the_node;
94bc: e5831004 str r1, [r3, #4]
next_node = search_node->next;
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
search_node->next = the_node;
94c0: e5841000 str r1, [r4]
next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
94c4: e5810044 str r0, [r1, #68] ; 0x44
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
94c8: e129f00a msr CPSR_fc, sl
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
94cc: eaffffd7 b 9430 <_Thread_queue_Enqueue_priority+0xa0>
94d0: e129f00a msr CPSR_fc, sl
94d4: eaffffbd b 93d0 <_Thread_queue_Enqueue_priority+0x40>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
94d8: e1530005 cmp r3, r5
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
94dc: e3a03000 mov r3, #0
94e0: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
94e4: 0a000007 beq 9508 <_Thread_queue_Enqueue_priority+0x178>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
94e8: e5943004 ldr r3, [r4, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
94ec: e5814000 str r4, [r1]
the_node->previous = previous_node;
94f0: e5813004 str r3, [r1, #4]
previous_node->next = the_node;
94f4: e5831000 str r1, [r3]
search_node->previous = the_node;
94f8: e5841004 str r1, [r4, #4]
the_thread->Wait.queue = the_thread_queue;
94fc: e5810044 str r0, [r1, #68] ; 0x44
9500: e129f00a msr CPSR_fc, sl
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
9504: eaffffc9 b 9430 <_Thread_queue_Enqueue_priority+0xa0>
_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;
9508: e5943040 ldr r3, [r4, #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 );
950c: e284203c add r2, r4, #60 ; 0x3c
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
9510: e881000c stm r1, {r2, r3}
previous_node->next = the_node;
9514: e5831000 str r1, [r3]
search_node->previous = the_node;
9518: e5841040 str r1, [r4, #64] ; 0x40
the_thread->Wait.queue = the_thread_queue;
951c: e5810044 str r0, [r1, #68] ; 0x44
9520: e129f008 msr CPSR_fc, r8
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
9524: e3a0c001 mov ip, #1
9528: eaffffc0 b 9430 <_Thread_queue_Enqueue_priority+0xa0>
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
952c: e3e05000 mvn r5, #0
9530: eaffffba b 9420 <_Thread_queue_Enqueue_priority+0x90>
00016d24 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
16d24: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
16d28: e24dd024 sub sp, sp, #36 ; 0x24
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
16d2c: e28d6018 add r6, sp, #24 16d30: e28d1010 add r1, sp, #16 16d34: e2862004 add r2, r6, #4 16d38: e58d100c str r1, [sp, #12] 16d3c: e58d2018 str r2, [sp, #24]
head->previous = NULL; tail->previous = head;
16d40: e28d100c add r1, sp, #12 16d44: e28d201c add r2, sp, #28
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
16d48: e3a03000 mov r3, #0
tail->previous = head;
16d4c: e58d1014 str r1, [sp, #20] 16d50: e58d2000 str r2, [sp] 16d54: e2801008 add r1, r0, #8 16d58: e2802040 add r2, r0, #64 ; 0x40 16d5c: e2807068 add r7, r0, #104 ; 0x68 16d60: e2805030 add r5, r0, #48 ; 0x30
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
16d64: e58d3010 str r3, [sp, #16] 16d68: e58d301c str r3, [sp, #28]
tail->previous = head;
16d6c: e58d6020 str r6, [sp, #32] 16d70: e59f81b8 ldr r8, [pc, #440] ; 16f30 <_Timer_server_Body+0x20c> 16d74: e59f91b8 ldr r9, [pc, #440] ; 16f34 <_Timer_server_Body+0x210> 16d78: e58d1004 str r1, [sp, #4] 16d7c: e58d2008 str r2, [sp, #8]
* 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;
16d80: e1a0a007 mov sl, r7
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
16d84: e1a04000 mov r4, r0 16d88: e28db010 add fp, sp, #16
* 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;
16d8c: e1a07005 mov r7, r5
{
/*
* 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;
16d90: e28d300c add r3, sp, #12 16d94: e5843078 str r3, [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;
16d98: e5983000 ldr r3, [r8]
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
16d9c: e594103c ldr r1, [r4, #60] ; 0x3c
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
16da0: e1a00007 mov r0, r7 16da4: e0611003 rsb r1, r1, r3 16da8: e1a02006 mov r2, r6
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
16dac: e584303c str r3, [r4, #60] ; 0x3c
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
16db0: eb00113f bl 1b2b4 <_Watchdog_Adjust_to_chain>
16db4: e59f217c ldr r2, [pc, #380] ; 16f38 <_Timer_server_Body+0x214>
16db8: e8990003 ldm r9, {r0, r1}
16dbc: e3a03000 mov r3, #0
16dc0: eb004d32 bl 2a290 <__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;
16dc4: 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 ) {
16dc8: e1500002 cmp r0, r2 16dcc: e1a05000 mov r5, r0
16dd0: 8a000022 bhi 16e60 <_Timer_server_Body+0x13c>
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
16dd4: 3a000018 bcc 16e3c <_Timer_server_Body+0x118>
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
16dd8: e5845074 str r5, [r4, #116] ; 0x74
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
16ddc: e5940078 ldr r0, [r4, #120] ; 0x78 16de0: eb0002d0 bl 17928 <_Chain_Get>
if ( timer == NULL ) {
16de4: e2501000 subs r1, r0, #0
16de8: 0a00000b beq 16e1c <_Timer_server_Body+0xf8>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
16dec: e5913038 ldr r3, [r1, #56] ; 0x38 16df0: e3530001 cmp r3, #1
16df4: 0a000015 beq 16e50 <_Timer_server_Body+0x12c>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
16df8: e3530003 cmp r3, #3
16dfc: 1afffff6 bne 16ddc <_Timer_server_Body+0xb8>
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
16e00: e2811010 add r1, r1, #16 16e04: e1a0000a mov r0, sl 16e08: eb001152 bl 1b358 <_Watchdog_Insert>
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
16e0c: e5940078 ldr r0, [r4, #120] ; 0x78 16e10: eb0002c4 bl 17928 <_Chain_Get>
if ( timer == NULL ) {
16e14: e2501000 subs r1, r0, #0
16e18: 1afffff3 bne 16dec <_Timer_server_Body+0xc8>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
16e1c: e10f2000 mrs r2, CPSR 16e20: e3823080 orr r3, r2, #128 ; 0x80 16e24: e129f003 msr CPSR_fc, r3
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
16e28: e59d300c ldr r3, [sp, #12] 16e2c: e153000b cmp r3, fp
16e30: 0a00000f beq 16e74 <_Timer_server_Body+0x150>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
16e34: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 16e38: eaffffd6 b 16d98 <_Timer_server_Body+0x74> <== NOT EXECUTED
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
16e3c: e1a0000a mov r0, sl 16e40: e3a01001 mov r1, #1 16e44: e0652002 rsb r2, r5, r2 16e48: eb0010eb bl 1b1fc <_Watchdog_Adjust> 16e4c: eaffffe1 b 16dd8 <_Timer_server_Body+0xb4>
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
16e50: e1a00007 mov r0, r7 16e54: e2811010 add r1, r1, #16 16e58: eb00113e bl 1b358 <_Watchdog_Insert> 16e5c: eaffffde b 16ddc <_Timer_server_Body+0xb8>
/*
* 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 );
16e60: e0621005 rsb r1, r2, r5 16e64: e1a0000a mov r0, sl 16e68: e1a02006 mov r2, r6 16e6c: eb001110 bl 1b2b4 <_Watchdog_Adjust_to_chain> 16e70: eaffffd8 b 16dd8 <_Timer_server_Body+0xb4>
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
16e74: e5841078 str r1, [r4, #120] ; 0x78 16e78: e129f002 msr CPSR_fc, r2
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
if ( !_Chain_Is_empty( &fire_chain ) ) {
16e7c: e59d3018 ldr r3, [sp, #24] 16e80: e59d1000 ldr r1, [sp] 16e84: e1530001 cmp r3, r1
16e88: 1a00000a bne 16eb8 <_Timer_server_Body+0x194>
16e8c: ea000012 b 16edc <_Timer_server_Body+0x1b8>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
16e90: e5932000 ldr r2, [r3]
head->next = new_first;
new_first->previous = head;
16e94: e5826004 str r6, [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;
16e98: e58d2018 str r2, [sp, #24]
* 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;
16e9c: e3a02000 mov r2, #0 16ea0: e5832008 str r2, [r3, #8] 16ea4: e129f001 msr CPSR_fc, r1
/*
* The timer server may block here and wait for resources or time.
* The system watchdogs are inactive and will remain inactive since
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
16ea8: e2830020 add r0, r3, #32
16eac: e8900003 ldm r0, {r0, r1}
16eb0: e1a0e00f mov lr, pc
16eb4: e593f01c ldr pc, [r3, #28]
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
16eb8: e10f1000 mrs r1, CPSR 16ebc: e3813080 orr r3, r1, #128 ; 0x80 16ec0: e129f003 msr CPSR_fc, r3
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
16ec4: e59d3018 ldr r3, [sp, #24]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
16ec8: e59d2000 ldr r2, [sp] 16ecc: e1530002 cmp r3, r2
16ed0: 1affffee bne 16e90 <_Timer_server_Body+0x16c>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
16ed4: e129f001 msr CPSR_fc, r1 16ed8: eaffffac b 16d90 <_Timer_server_Body+0x6c>
}
} else {
ts->active = false;
16edc: e3a03000 mov r3, #0 16ee0: 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;
16ee4: e59f1050 ldr r1, [pc, #80] ; 16f3c <_Timer_server_Body+0x218> 16ee8: e5913000 ldr r3, [r1]
++level;
16eec: e2833001 add r3, r3, #1
_Thread_Dispatch_disable_level = level;
16ef0: e5813000 str r3, [r1]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
16ef4: e3a01008 mov r1, #8 16ef8: e5940000 ldr r0, [r4] 16efc: eb000fdc bl 1ae74 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
16f00: e1a00004 mov r0, r4 16f04: ebffff5a bl 16c74 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
16f08: e1a00004 mov r0, r4 16f0c: ebffff6e bl 16ccc <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
16f10: eb000d9b bl 1a584 <_Thread_Enable_dispatch>
ts->active = true;
16f14: e3a03001 mov r3, #1 16f18: 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 );
16f1c: e59d0004 ldr r0, [sp, #4] 16f20: eb001179 bl 1b50c <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
16f24: e59d0008 ldr r0, [sp, #8] 16f28: eb001177 bl 1b50c <_Watchdog_Remove> 16f2c: eaffff97 b 16d90 <_Timer_server_Body+0x6c>
000098e4 <_User_extensions_Thread_exitted_visitor>:
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
User_extensions_thread_exitted_extension callout = callouts->thread_exitted;
98e4: e5923018 ldr r3, [r2, #24]
if ( callout != NULL ) {
98e8: e3530000 cmp r3, #0
void _User_extensions_Thread_exitted_visitor(
Thread_Control *executing,
void *arg,
const User_extensions_Table *callouts
)
{
98ec: e52de004 push {lr} ; (str lr, [sp, #-4]!)
User_extensions_thread_exitted_extension callout = callouts->thread_exitted;
if ( callout != NULL ) {
98f0: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
(*callout)( executing );
98f4: e1a0e00f mov lr, pc
98f8: e12fff13 bx r3
98fc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
0000b250 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
b250: e92d41f0 push {r4, r5, r6, r7, r8, lr}
b254: e1a04000 mov r4, r0
b258: e1a05002 mov r5, r2
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
b25c: e10f2000 mrs r2, CPSR
b260: e3823080 orr r3, r2, #128 ; 0x80
b264: e129f003 msr CPSR_fc, r3
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
b268: e1a07000 mov r7, r0
b26c: e4973004 ldr r3, [r7], #4
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
b270: e1530007 cmp r3, r7
b274: 0a000017 beq b2d8 <_Watchdog_Adjust+0x88>
switch ( direction ) {
b278: e3510000 cmp r1, #0
b27c: 1a000017 bne b2e0 <_Watchdog_Adjust+0x90>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
b280: e3550000 cmp r5, #0
b284: 0a000013 beq b2d8 <_Watchdog_Adjust+0x88>
if ( units < _Watchdog_First( header )->delta_interval ) {
b288: e5936010 ldr r6, [r3, #16]
b28c: e1550006 cmp r5, r6
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
b290: 23a08001 movcs r8, #1
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
b294: 2a000005 bcs b2b0 <_Watchdog_Adjust+0x60>
b298: ea000017 b b2fc <_Watchdog_Adjust+0xac> <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
b29c: e0555006 subs r5, r5, r6
b2a0: 0a00000c beq b2d8 <_Watchdog_Adjust+0x88>
if ( units < _Watchdog_First( header )->delta_interval ) {
b2a4: e5936010 ldr r6, [r3, #16]
b2a8: e1560005 cmp r6, r5
b2ac: 8a000012 bhi b2fc <_Watchdog_Adjust+0xac>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
b2b0: e5838010 str r8, [r3, #16]
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
b2b4: e129f002 msr CPSR_fc, r2
_ISR_Enable( level );
_Watchdog_Tickle( header );
b2b8: e1a00004 mov r0, r4
b2bc: eb0000a9 bl b568 <_Watchdog_Tickle>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
b2c0: e10f2000 mrs r2, CPSR
b2c4: e3823080 orr r3, r2, #128 ; 0x80
b2c8: e129f003 msr CPSR_fc, r3
b2cc: e5943000 ldr r3, [r4]
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
b2d0: e1570003 cmp r7, r3
b2d4: 1afffff0 bne b29c <_Watchdog_Adjust+0x4c>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
b2d8: e129f002 msr CPSR_fc, r2
}
}
_ISR_Enable( level );
}
b2dc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
b2e0: e3510001 cmp r1, #1
b2e4: 1afffffb bne b2d8 <_Watchdog_Adjust+0x88>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
b2e8: e5931010 ldr r1, [r3, #16]
b2ec: e0815005 add r5, r1, r5
b2f0: e5835010 str r5, [r3, #16]
b2f4: e129f002 msr CPSR_fc, r2
}
}
_ISR_Enable( level );
}
b2f8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
b2fc: e0655006 rsb r5, r5, r6
b300: e5835010 str r5, [r3, #16]
break;
b304: eafffff3 b b2d8 <_Watchdog_Adjust+0x88>
00009d38 <_Workspace_Handler_initialization>:
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
9d38: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize; uintptr_t remaining = rtems_configuration_get_work_space_size();
9d3c: e59f3120 ldr r3, [pc, #288] ; 9e64 <_Workspace_Handler_initialization+0x12c>
9d40: e5d3c032 ldrb ip, [r3, #50] ; 0x32
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
9d44: e24dd004 sub sp, sp, #4
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize; uintptr_t remaining = rtems_configuration_get_work_space_size();
9d48: e35c0000 cmp ip, #0
9d4c: 05937004 ldreq r7, [r3, #4]
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
9d50: e58d2000 str r2, [sp]
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize; uintptr_t remaining = rtems_configuration_get_work_space_size();
9d54: e5932000 ldr r2, [r3]
9d58: 13a07000 movne r7, #0
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
9d5c: e3510000 cmp r1, #0
void _Workspace_Handler_initialization(
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
9d60: e1a08001 mov r8, r1
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize; uintptr_t remaining = rtems_configuration_get_work_space_size();
9d64: e0877002 add r7, r7, r2
bool do_zero = rtems_configuration_get_do_zero_of_workspace();
9d68: e5d3a030 ldrb sl, [r3, #48] ; 0x30
bool unified = rtems_configuration_get_unified_work_area();
9d6c: e5d3b031 ldrb fp, [r3, #49] ; 0x31
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
9d70: 0a000033 beq 9e44 <_Workspace_Handler_initialization+0x10c>
Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
9d74: e59f90ec ldr r9, [pc, #236] ; 9e68 <_Workspace_Handler_initialization+0x130>
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
9d78: e1a04000 mov r4, r0
9d7c: e3a06000 mov r6, #0
9d80: ea00001d b 9dfc <_Workspace_Handler_initialization+0xc4>
if ( do_zero ) {
memset( area->begin, 0, area->size );
}
if ( area->size > overhead ) {
9d84: e5945004 ldr r5, [r4, #4]
9d88: e3550016 cmp r5, #22
9d8c: 9a000016 bls 9dec <_Workspace_Handler_initialization+0xb4>
uintptr_t space_available;
uintptr_t size;
if ( unified ) {
9d90: e35b0000 cmp fp, #0
9d94: 1a000004 bne 9dac <_Workspace_Handler_initialization+0x74>
size = area->size;
} else {
if ( remaining > 0 ) {
9d98: e3570000 cmp r7, #0
9d9c: 0a00001d beq 9e18 <_Workspace_Handler_initialization+0xe0>
size = remaining < area->size - overhead ?
9da0: e2453016 sub r3, r5, #22
remaining + overhead : area->size;
9da4: e1530007 cmp r3, r7
9da8: 82875016 addhi r5, r7, #22
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
9dac: e1a02005 mov r2, r5
9db0: e3a03008 mov r3, #8
9db4: e59f00b0 ldr r0, [pc, #176] ; 9e6c <_Workspace_Handler_initialization+0x134>
9db8: e5941000 ldr r1, [r4]
9dbc: e1a0e00f mov lr, pc
9dc0: e12fff19 bx r9
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
9dc4: e5943000 ldr r3, [r4]
area->size -= size;
9dc8: e5942004 ldr r2, [r4, #4]
area->begin,
size,
page_size
);
area->begin = (char *) area->begin + size;
9dcc: e0833005 add r3, r3, r5
area->size -= size;
9dd0: e0655002 rsb r5, r5, r2
if ( space_available < remaining ) {
9dd4: e1500007 cmp r0, r7
size,
page_size
);
area->begin = (char *) area->begin + size;
area->size -= size;
9dd8: e8840028 stm r4, {r3, r5}
remaining -= space_available;
} else {
remaining = 0;
}
init_or_extend = extend;
9ddc: 359d9000 ldrcc r9, [sp]
9de0: 259d9000 ldrcs r9, [sp]
area->begin = (char *) area->begin + size;
area->size -= size;
if ( space_available < remaining ) {
remaining -= space_available;
9de4: 30607007 rsbcc r7, r0, r7
} else {
remaining = 0;
9de8: 23a07000 movcs r7, #0
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
9dec: e2866001 add r6, r6, #1
9df0: e1560008 cmp r6, r8
9df4: e2844008 add r4, r4, #8
9df8: 0a000011 beq 9e44 <_Workspace_Handler_initialization+0x10c>
Heap_Area *area = &areas [i];
if ( do_zero ) {
9dfc: e35a0000 cmp sl, #0
9e00: 0affffdf beq 9d84 <_Workspace_Handler_initialization+0x4c>
memset( area->begin, 0, area->size );
9e04: e5940000 ldr r0, [r4]
9e08: e3a01000 mov r1, #0
9e0c: e5942004 ldr r2, [r4, #4]
9e10: eb0010e4 bl e1a8 <memset>
9e14: eaffffda b 9d84 <_Workspace_Handler_initialization+0x4c>
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
9e18: e5941000 ldr r1, [r4] <== NOT EXECUTED
9e1c: e59f0048 ldr r0, [pc, #72] ; 9e6c <_Workspace_Handler_initialization+0x134><== NOT EXECUTED
9e20: e1a02007 mov r2, r7 <== NOT EXECUTED
9e24: e3a03008 mov r3, #8 <== NOT EXECUTED
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
9e28: e2866001 add r6, r6, #1 <== NOT EXECUTED
} else {
size = 0;
}
}
space_available = (*init_or_extend)(
9e2c: e1a0e00f mov lr, pc <== NOT EXECUTED
9e30: e12fff19 bx r9 <== NOT EXECUTED
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
9e34: e1560008 cmp r6, r8 <== NOT EXECUTED
remaining -= space_available;
} else {
remaining = 0;
}
init_or_extend = extend;
9e38: e59d9000 ldr r9, [sp] <== NOT EXECUTED
bool unified = rtems_configuration_get_unified_work_area();
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
uintptr_t overhead = _Heap_Area_overhead( page_size );
size_t i;
for (i = 0; i < area_count; ++i) {
9e3c: e2844008 add r4, r4, #8 <== NOT EXECUTED
9e40: 1affffed bne 9dfc <_Workspace_Handler_initialization+0xc4> <== NOT EXECUTED
init_or_extend = extend;
}
}
if ( remaining > 0 ) {
9e44: e3570000 cmp r7, #0
9e48: 1a000001 bne 9e54 <_Workspace_Handler_initialization+0x11c>
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_TOO_LITTLE_WORKSPACE
);
}
}
9e4c: e28dd004 add sp, sp, #4
9e50: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
init_or_extend = extend;
}
}
if ( remaining > 0 ) {
_Internal_error_Occurred(
9e54: e3a00000 mov r0, #0
9e58: e3a01001 mov r1, #1
9e5c: e3a02002 mov r2, #2
9e60: ebfff6e7 bl 7a04 <_Internal_error_Occurred>
00018b90 <__kill>:
#endif
int __kill( pid_t pid, int sig )
{
return 0;
}
18b90: e3a00000 mov r0, #0 <== NOT EXECUTED 18b94: e12fff1e bx lr <== NOT EXECUTED
0001209c <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
1209c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while (count > 0)
120a0: e2534000 subs r4, r3, #0
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
120a4: e24dd004 sub sp, sp, #4 120a8: e1a09000 mov r9, r0 120ac: e59db028 ldr fp, [sp, #40] ; 0x28
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while (count > 0)
120b0: 11a07002 movne r7, r2 120b4: 11a06001 movne r6, r1 120b8: 13a05000 movne r5, #0
120bc: 1a00000d bne 120f8 <_fat_block_read+0x5c>
120c0: ea000018 b 12128 <_fat_block_read+0x8c> <== NOT EXECUTED
{
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));
120c4: e1d980b0 ldrh r8, [r9]
memcpy((buff + cmpltd), (sec_buf + ofs), c);
120c8: 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));
120cc: e0678008 rsb r8, r7, r8 120d0: e1580004 cmp r8, r4 120d4: 21a08004 movcs r8, r4
memcpy((buff + cmpltd), (sec_buf + ofs), c);
120d8: e0811007 add r1, r1, r7 120dc: e1a02008 mov r2, r8 120e0: eb00209a bl 1a350 <memcpy>
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while (count > 0)
120e4: e0544008 subs r4, r4, r8
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (sec_buf + ofs), c);
count -= c;
cmpltd += c;
120e8: e0885005 add r5, r8, r5
sec_num++;
120ec: e2866001 add r6, r6, #1
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while (count > 0)
120f0: 0a000009 beq 1211c <_fat_block_read+0x80>
memcpy((buff + cmpltd), (sec_buf + ofs), c);
count -= c;
cmpltd += c;
sec_num++;
ofs = 0;
120f4: e1a0700a mov r7, sl
uint8_t *sec_buf;
uint32_t c = 0;
while (count > 0)
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
120f8: e1a01006 mov r1, r6 120fc: e3a02001 mov r2, #1 12100: e1a0300d mov r3, sp 12104: e1a00009 mov r0, r9 12108: ebffffb8 bl 11ff0 <fat_buf_access>
if (rc != RC_OK)
1210c: e250a000 subs sl, r0, #0
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (sec_buf + ofs), c);
12110: e08b0005 add r0, fp, r5
uint32_t c = 0;
while (count > 0)
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
if (rc != RC_OK)
12114: 0affffea beq 120c4 <_fat_block_read+0x28>
return -1;
12118: e3e05000 mvn r5, #0 <== NOT EXECUTED
cmpltd += c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
1211c: e1a00005 mov r0, r5
12120: e28dd004 add sp, sp, #4
12124: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
uint32_t count,
void *buff
)
{
int rc = RC_OK;
ssize_t cmpltd = 0;
12128: e1a05004 mov r5, r4 <== NOT EXECUTED 1212c: eafffffa b 1211c <_fat_block_read+0x80> <== NOT EXECUTED
00002648 <_gettimeofday>:
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
2648: eaffffda b 25b8 <gettimeofday> <== NOT EXECUTED
000032bc <_lstat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
32bc: e1a00001 mov r0, r1 <== NOT EXECUTED
32c0: e1a01002 mov r1, r2 <== NOT EXECUTED
32c4: eaffffe5 b 3260 <lstat> <== NOT EXECUTED
00003498 <_stat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
3498: e1a00001 mov r0, r1 <== NOT EXECUTED
349c: e1a01002 mov r1, r2 <== NOT EXECUTED
34a0: eaffffe5 b 343c <stat> <== NOT EXECUTED
0000267c <create_disk>:
dev_t dev,
const char *name,
rtems_disk_device **dd_ptr,
char **alloc_name_ptr
)
{
267c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
2680: e59f6168 ldr r6, [pc, #360] ; 27f0 <create_disk+0x174>
2684: e5967000 ldr r7, [r6]
2688: e1500007 cmp r0, r7
dev_t dev,
const char *name,
rtems_disk_device **dd_ptr,
char **alloc_name_ptr
)
{
268c: e1a05000 mov r5, r0
2690: e1a04001 mov r4, r1
2694: e1a09002 mov r9, r2
2698: e1a0b003 mov fp, r3
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
269c: 35968004 ldrcc r8, [r6, #4]
26a0: 3a00000e bcc 26e0 <create_disk+0x64>
rtems_disk_device_table *table = disktab;
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
26a4: e1a0a087 lsl sl, r7, #1
if (major >= new_size) {
26a8: e150000a cmp r0, sl
new_size = major + 1;
26ac: 2285a001 addcs sl, r5, #1
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
rtems_disk_device_table *table = disktab;
26b0: e5960004 ldr r0, [r6, #4]
if (major >= new_size) {
new_size = major + 1;
}
table = realloc(table, new_size * sizeof(*table));
26b4: e1a0118a lsl r1, sl, #3
26b8: eb000841 bl 47c4 <realloc>
if (table == NULL) {
26bc: e2508000 subs r8, r0, #0
26c0: 0a00003c beq 27b8 <create_disk+0x13c>
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
26c4: e067200a rsb r2, r7, sl <== NOT EXECUTED
26c8: e0880187 add r0, r8, r7, lsl #3 <== NOT EXECUTED
26cc: e3a01000 mov r1, #0 <== NOT EXECUTED
26d0: e1a02182 lsl r2, r2, #3 <== NOT EXECUTED
26d4: eb004004 bl 126ec <memset> <== NOT EXECUTED
disktab = table;
26d8: e5868004 str r8, [r6, #4] <== NOT EXECUTED
disktab_size = new_size;
26dc: e586a000 str sl, [r6] <== NOT EXECUTED
}
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
26e0: e7987185 ldr r7, [r8, r5, lsl #3]
26e4: e0888185 add r8, r8, r5, lsl #3
26e8: e3570000 cmp r7, #0
26ec: e598a004 ldr sl, [r8, #4]
26f0: 0a000001 beq 26fc <create_disk+0x80>
26f4: e154000a cmp r4, sl
26f8: 3a000010 bcc 2740 <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) {
26fc: e35a0000 cmp sl, #0
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
2700: 11a0608a lslne r6, sl, #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;
2704: 03a06008 moveq r6, #8
} else {
new_size = 2 * old_size;
}
if (minor >= new_size) {
2708: e1540006 cmp r4, r6
new_size = minor + 1;
270c: 22846001 addcs r6, r4, #1
}
table = realloc(table, new_size * sizeof(*table));
2710: e1a00007 mov r0, r7
2714: e1a01106 lsl r1, r6, #2
2718: eb000829 bl 47c4 <realloc>
if (table == NULL) {
271c: e2507000 subs r7, r0, #0
2720: 0a000024 beq 27b8 <create_disk+0x13c>
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
2724: e06a2006 rsb r2, sl, r6
2728: e087010a add r0, r7, sl, lsl #2
272c: e3a01000 mov r1, #0
2730: e1a02102 lsl r2, r2, #2
2734: eb003fec bl 126ec <memset>
disktab [major].minor = table;
2738: e5887000 str r7, [r8]
disktab [major].size = new_size;
273c: e5886004 str r6, [r8, #4]
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
2740: e0976104 adds r6, r7, r4, lsl #2
2744: 0a00001b beq 27b8 <create_disk+0x13c>
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
2748: e7973104 ldr r3, [r7, r4, lsl #2]
274c: e3530000 cmp r3, #0
return RTEMS_RESOURCE_IN_USE;
2750: 13a0000c movne r0, #12
if (dd_entry == NULL) {
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
2754: 18bd8ff0 popne {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
2758: e3a00074 mov r0, #116 ; 0x74
275c: eb00056c bl 3d14 <malloc>
if (dd == NULL) {
2760: e2508000 subs r8, r0, #0
2764: 0a000015 beq 27c0 <create_disk+0x144>
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
2768: e3590000 cmp r9, #0
276c: 0a00000b beq 27a0 <create_disk+0x124>
alloc_name = strdup(name);
2770: e1a00009 mov r0, r9
2774: eb004190 bl 12dbc <strdup>
if (alloc_name == NULL) {
2778: e3500000 cmp r0, #0
if (dd == NULL) {
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
alloc_name = strdup(name);
277c: e1a07000 mov r7, r0
2780: e1a09000 mov r9, r0
if (alloc_name == NULL) {
2784: 0a000015 beq 27e0 <create_disk+0x164>
return RTEMS_NO_MEMORY;
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
2788: e59f1064 ldr r1, [pc, #100] ; 27f4 <create_disk+0x178>
278c: e1a02005 mov r2, r5
2790: e1a03004 mov r3, r4
2794: eb0005be bl 3e94 <mknod>
2798: e3500000 cmp r0, #0
279c: ba000009 blt 27c8 <create_disk+0x14c>
}
}
*dd_entry = dd;
*dd_ptr = dd;
*alloc_name_ptr = alloc_name;
27a0: e59d3024 ldr r3, [sp, #36] ; 0x24
free(dd);
return RTEMS_UNSATISFIED;
}
}
*dd_entry = dd;
27a4: e5868000 str r8, [r6]
*dd_ptr = dd;
*alloc_name_ptr = alloc_name;
return RTEMS_SUCCESSFUL;
27a8: e3a00000 mov r0, #0
return RTEMS_UNSATISFIED;
}
}
*dd_entry = dd;
*dd_ptr = dd;
27ac: e58b8000 str r8, [fp]
*alloc_name_ptr = alloc_name;
27b0: e5839000 str r9, [r3]
return RTEMS_SUCCESSFUL;
27b4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
return RTEMS_NO_MEMORY;
27b8: e3a0001a mov r0, #26
27bc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
if (dd == NULL) {
return RTEMS_NO_MEMORY;
27c0: e3a0001a mov r0, #26 <== NOT EXECUTED
*dd_entry = dd;
*dd_ptr = dd;
*alloc_name_ptr = alloc_name;
return RTEMS_SUCCESSFUL;
}
27c4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
free(alloc_name);
27c8: e1a00007 mov r0, r7 <== NOT EXECUTED
27cc: eb000415 bl 3828 <free> <== NOT EXECUTED
free(dd);
27d0: e1a00008 mov r0, r8 <== NOT EXECUTED
27d4: eb000413 bl 3828 <free> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
27d8: e3a0000d mov r0, #13 <== NOT EXECUTED
27dc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (name != NULL) {
alloc_name = strdup(name);
if (alloc_name == NULL) {
free(dd);
27e0: e1a00008 mov r0, r8 <== NOT EXECUTED
27e4: eb00040f bl 3828 <free> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
27e8: e3a0001a mov r0, #26 <== NOT EXECUTED
27ec: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0000b244 <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;
b244: e590302c ldr r3, [r0, #44] ; 0x2c
b248: e5933010 ldr r3, [r3, #16]
}
void devFS_eval_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
b24c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
size_t pathlen,
devFS_node **free_node_ptr
)
{
size_t i = 0;
size_t n = data->count;
b250: e593a004 ldr sl, [r3, #4]
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) {
b254: e35a0000 cmp sl, #0
)
{
size_t i = 0;
size_t n = data->count;
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
b258: 13a06000 movne r6, #0
}
void devFS_eval_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
b25c: e1a09000 mov r9, r0
static inline const char *rtems_filesystem_eval_path_get_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->path;
b260: e590b000 ldr fp, [r0]
static inline size_t rtems_filesystem_eval_path_get_pathlen(
rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->pathlen;
b264: e5908004 ldr r8, [r0, #4]
devFS_node **free_node_ptr
)
{
size_t i = 0;
size_t n = data->count;
devFS_node *nodes = data->nodes;
b268: e5934000 ldr r4, [r3]
devFS_node *node = NULL; devFS_node *free_node = NULL;
b26c: 11a07006 movne r7, r6
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
b270: 11a05006 movne r5, r6
b274: 1a000008 bne b29c <devFS_eval_path+0x58>
b278: ea000024 b b310 <devFS_eval_path+0xcc>
b27c: e3530000 cmp r3, #0
b280: 13560000 cmpne r6, #0
b284: e2855001 add r5, r5, #1
b288: 1a000015 bne b2e4 <devFS_eval_path+0xa0>
b28c: e155000a cmp r5, sl
b290: e2844014 add r4, r4, #20
b294: 0a000012 beq b2e4 <devFS_eval_path+0xa0>
b298: e1a07003 mov r7, r3
devFS_node *current = nodes + i;
if (current->name != NULL) {
b29c: e5940000 ldr r0, [r4]
b2a0: 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;
b2a4: e1a03004 mov r3, r4
if (current->name != NULL) {
b2a8: 0afffff3 beq b27c <devFS_eval_path+0x38>
if (
b2ac: e5943004 ldr r3, [r4, #4]
b2b0: e1580003 cmp r8, r3
b2b4: 11a03007 movne r3, r7
b2b8: 1affffef bne b27c <devFS_eval_path+0x38>
current->namelen == pathlen
&& memcmp(current->name, path, pathlen) == 0
b2bc: e1a0100b mov r1, fp
b2c0: e1a02008 mov r2, r8
b2c4: eb000912 bl d714 <memcmp>
b2c8: e3500000 cmp r0, #0
b2cc: e1a03007 mov r3, r7
b2d0: 01a06004 moveq r6, r4
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) {
b2d4: e3530000 cmp r3, #0
b2d8: 13560000 cmpne r6, #0
b2dc: e2855001 add r5, r5, #1
b2e0: 0affffe9 beq b28c <devFS_eval_path+0x48>
rtems_filesystem_eval_path_get_pathlen(ctx),
&free_node
);
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (node != NULL) {
b2e4: e3560000 cmp r6, #0
static inline int rtems_filesystem_eval_path_get_flags(
const rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->flags;
b2e8: e5992010 ldr r2, [r9, #16]
b2ec: 0a000014 beq b344 <devFS_eval_path+0x100>
if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {
b2f0: e2122040 ands r2, r2, #64 ; 0x40
currentloc->node_access = node;
b2f4: 05896020 streq r6, [r9, #32]
static inline void rtems_filesystem_eval_path_clear_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->pathlen = 0;
b2f8: 05892004 streq r2, [r9, #4]
&free_node
);
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (node != NULL) {
if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {
b2fc: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
currentloc->node_access = node;
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, EEXIST);
b300: e1a00009 mov r0, r9
b304: e3a01011 mov r1, #17
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
}
}
}
b308: e8bd4ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, lr}
if (node != NULL) {
if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {
currentloc->node_access = node;
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, EEXIST);
b30c: eaffe471 b 44d8 <rtems_filesystem_eval_path_error>
static inline int rtems_filesystem_eval_path_get_flags(
const rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->flags;
b310: e5902010 ldr r2, [r0, #16]
}
} else {
if ((eval_flags & RTEMS_FS_MAKE) != 0) {
b314: e3120020 tst r2, #32
b318: 0a00000b beq b34c <devFS_eval_path+0x108>
if (free_node != NULL) {
b31c: e35a0000 cmp sl, #0
b320: 0a00000d beq b35c <devFS_eval_path+0x118>
free_node->mode = S_IRWXU | S_IRWXG | S_IRWXO;
b324: e59f3040 ldr r3, [pc, #64] ; b36c <devFS_eval_path+0x128>
b328: e58a3010 str r3, [sl, #16]
static inline void rtems_filesystem_eval_path_clear_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->pathlen = 0;
b32c: e3a03000 mov r3, #0
currentloc->node_access = free_node;
b330: e589a020 str sl, [r9, #32]
rtems_filesystem_eval_path_context_t *ctx,
const char *token,
size_t tokenlen
)
{
ctx->token = token;
b334: e589b008 str fp, [r9, #8]
ctx->tokenlen = tokenlen;
b338: e589800c str r8, [r9, #12]
static inline void rtems_filesystem_eval_path_clear_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->pathlen = 0;
b33c: e5893004 str r3, [r9, #4]
b340: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rtems_filesystem_eval_path_get_pathlen(ctx),
&free_node
);
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (node != NULL) {
b344: e1a0a003 mov sl, r3
b348: eafffff1 b b314 <devFS_eval_path+0xd0>
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, ENOSPC);
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
b34c: e1a00009 mov r0, r9 <== NOT EXECUTED
b350: e3a01002 mov r1, #2 <== NOT EXECUTED
}
}
}
b354: e8bd4ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, ENOSPC);
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
b358: eaffe45e b 44d8 <rtems_filesystem_eval_path_error> <== NOT EXECUTED
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);
b35c: e1a00009 mov r0, r9
b360: e3a0101c mov r1, #28
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
}
}
}
b364: e8bd4ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, lr}
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);
b368: eaffe45a b 44d8 <rtems_filesystem_eval_path_error>
0000264c <disk_unlock>:
static void
disk_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
264c: e59f3020 ldr r3, [pc, #32] ; 2674 <disk_unlock+0x28>
2650: e3a02000 mov r2, #0
}
}
static void
disk_unlock(void)
{
2654: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
sc = rtems_semaphore_release(diskdevs_mutex);
2658: e5930008 ldr r0, [r3, #8]
static void
disk_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
265c: e5c3200c strb r2, [r3, #12]
sc = rtems_semaphore_release(diskdevs_mutex);
2660: eb001567 bl 7c04 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL) {
2664: e3500000 cmp r0, #0
2668: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
/* FIXME: Error number */
rtems_fatal_error_occurred(0xdeadbeef);
266c: e59f0004 ldr r0, [pc, #4] ; 2678 <disk_unlock+0x2c> <== NOT EXECUTED
2670: eb0016dd bl 81ec <rtems_fatal_error_occurred> <== NOT EXECUTED
000040ac <drainOutput.part.0>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
40ac: e92d4030 push {r4, r5, lr}
40b0: e1a04000 mov r4, r0
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
40b4: e10f3000 mrs r3, CPSR
40b8: e3832080 orr r2, r3, #128 ; 0x80
40bc: e129f002 msr CPSR_fc, r2
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) {
40c0: e5901084 ldr r1, [r0, #132] ; 0x84
40c4: e5902080 ldr r2, [r0, #128] ; 0x80
40c8: e1510002 cmp r1, r2
40cc: 0a00000f beq 4110 <drainOutput.part.0+0x64>
tty->rawOutBufState = rob_wait;
40d0: e3a05002 mov r5, #2 <== NOT EXECUTED
40d4: e5845094 str r5, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
40d8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
40dc: e3a01000 mov r1, #0 <== NOT EXECUTED
40e0: e594008c ldr r0, [r4, #140] ; 0x8c <== NOT EXECUTED
40e4: e1a02001 mov r2, r1 <== NOT EXECUTED
40e8: eb000941 bl 65f4 <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40ec: e3500000 cmp r0, #0 <== NOT EXECUTED
40f0: 1a000008 bne 4118 <drainOutput.part.0+0x6c> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
40f4: e10f3000 mrs r3, CPSR <== NOT EXECUTED
40f8: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
40fc: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
4100: e5941084 ldr r1, [r4, #132] ; 0x84 <== NOT EXECUTED
4104: e5942080 ldr r2, [r4, #128] ; 0x80 <== NOT EXECUTED
4108: e1510002 cmp r1, r2 <== NOT EXECUTED
410c: 1afffff0 bne 40d4 <drainOutput.part.0+0x28> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
4110: e129f003 msr CPSR_fc, r3
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
rtems_interrupt_enable (level);
}
}
4114: e8bd8030 pop {r4, r5, pc}
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
4118: eb000b0f bl 6d5c <rtems_fatal_error_occurred> <== NOT EXECUTED
00004eec <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)
4eec: e5903020 ldr r3, [r0, #32]
4ef0: 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)
{
4ef4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
4ef8: e1a04000 mov r4, r0
4efc: e1a06001 mov r6, r1
if (tty->ccount == 0)
4f00: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
4f04: e590103c ldr r1, [r0, #60] ; 0x3c
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
return;
if (lineFlag) {
4f08: e3560000 cmp r6, #0
4f0c: 02012008 andeq r2, r1, #8
4f10: 1a000026 bne 4fb0 <erase+0xc4>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
4f14: e59f71d8 ldr r7, [pc, #472] ; 50f4 <erase+0x208>
4f18: ea000008 b 4f40 <erase+0x54>
4f1c: e3110c02 tst r1, #512 ; 0x200 <== NOT EXECUTED
4f20: 1a00005b bne 5094 <erase+0x1a8> <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
4f24: e3560000 cmp r6, #0 <== NOT EXECUTED
4f28: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
4f2c: e5943020 ldr r3, [r4, #32]
4f30: e3530000 cmp r3, #0
4f34: 0a000055 beq 5090 <erase+0x1a4>
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
4f38: e594103c ldr r1, [r4, #60] ; 0x3c
4f3c: e2012008 and r2, r1, #8
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
4f40: e2433001 sub r3, r3, #1
4f44: e594001c ldr r0, [r4, #28]
4f48: e5843020 str r3, [r4, #32]
if (tty->termios.c_lflag & ECHO) {
4f4c: e3520000 cmp r2, #0
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
4f50: e7d05003 ldrb r5, [r0, r3]
if (tty->termios.c_lflag & ECHO) {
4f54: 0afffff2 beq 4f24 <erase+0x38>
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
4f58: e3560000 cmp r6, #0
4f5c: 1a000001 bne 4f68 <erase+0x7c>
4f60: e3110010 tst r1, #16
4f64: 0a000045 beq 5080 <erase+0x194>
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
4f68: e3550009 cmp r5, #9
4f6c: 0a00001f beq 4ff0 <erase+0x104>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
4f70: e5973000 ldr r3, [r7]
4f74: e2855001 add r5, r5, #1
4f78: e7d33005 ldrb r3, [r3, r5]
4f7c: e3130020 tst r3, #32
4f80: 1affffe5 bne 4f1c <erase+0x30>
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
4f84: e59f016c ldr r0, [pc, #364] ; 50f8 <erase+0x20c>
4f88: e3a01003 mov r1, #3
4f8c: e1a02004 mov r2, r4
4f90: ebffff11 bl 4bdc <rtems_termios_puts>
if (tty->column)
4f94: e5943028 ldr r3, [r4, #40] ; 0x28
4f98: e3530000 cmp r3, #0
tty->column--;
4f9c: 12433001 subne r3, r3, #1
4fa0: 15843028 strne r3, [r4, #40] ; 0x28
}
}
}
if (!lineFlag)
4fa4: e3560000 cmp r6, #0
4fa8: 1affffdf bne 4f2c <erase+0x40>
4fac: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
4fb0: e2112008 ands r2, r1, #8
tty->ccount = 0;
4fb4: 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)) {
4fb8: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
4fbc: e2110010 ands r0, r1, #16
4fc0: 1affffd3 bne 4f14 <erase+0x28>
tty->ccount = 0;
4fc4: e5840020 str r0, [r4, #32] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
4fc8: e1a01004 mov r1, r4 <== NOT EXECUTED
4fcc: e5d40044 ldrb r0, [r4, #68] ; 0x44 <== NOT EXECUTED
4fd0: ebffffa0 bl 4e58 <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
4fd4: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
4fd8: e3130020 tst r3, #32 <== NOT EXECUTED
4fdc: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
echo ('\n', tty);
4fe0: e3a0000a mov r0, #10 <== NOT EXECUTED
4fe4: e1a01004 mov r1, r4 <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
4fe8: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
4fec: eaffff99 b 4e58 <echo> <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
4ff0: e3530000 cmp r3, #0
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;
4ff4: e594502c ldr r5, [r4, #44] ; 0x2c
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
4ff8: 0a000011 beq 5044 <erase+0x158>
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
4ffc: e5978000 ldr r8, [r7]
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;
5000: 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)
5004: e201ac02 and sl, r1, #512 ; 0x200
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
5008: e7d01002 ldrb r1, [r0, r2]
if (c == '\t') {
500c: e3510009 cmp r1, #9
col = (col | 7) + 1;
5010: 03855007 orreq r5, r5, #7
} else if (iscntrl (c)) {
5014: e088c001 add ip, r8, r1
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
5018: e2822001 add r2, r2, #1
if (c == '\t') {
col = (col | 7) + 1;
501c: 02855001 addeq r5, r5, #1
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
5020: 0a000005 beq 503c <erase+0x150>
col = (col | 7) + 1;
} else if (iscntrl (c)) {
5024: e5dcc001 ldrb ip, [ip, #1]
5028: e31c0020 tst ip, #32
if (tty->termios.c_lflag & ECHOCTL)
col += 2;
} else {
col++;
502c: 02855001 addeq r5, r5, #1
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
5030: 0a000001 beq 503c <erase+0x150>
if (tty->termios.c_lflag & ECHOCTL)
5034: e35a0000 cmp sl, #0 <== NOT EXECUTED
col += 2;
5038: 12855002 addne r5, r5, #2 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
503c: e1530002 cmp r3, r2
5040: 1afffff0 bne 5008 <erase+0x11c>
}
/*
* Back up over the tab
*/
while (tty->column > col) {
5044: e5943028 ldr r3, [r4, #40] ; 0x28
5048: e1550003 cmp r5, r3
504c: aaffffb4 bge 4f24 <erase+0x38>
rtems_termios_puts ("\b", 1, tty);
5050: e59f00a4 ldr r0, [pc, #164] ; 50fc <erase+0x210>
5054: e3a01001 mov r1, #1
5058: e1a02004 mov r2, r4
505c: ebfffede bl 4bdc <rtems_termios_puts>
tty->column--;
5060: e5943028 ldr r3, [r4, #40] ; 0x28
5064: e2433001 sub r3, r3, #1
}
/*
* Back up over the tab
*/
while (tty->column > col) {
5068: e1530005 cmp r3, r5
rtems_termios_puts ("\b", 1, tty);
tty->column--;
506c: e5843028 str r3, [r4, #40] ; 0x28
}
/*
* Back up over the tab
*/
while (tty->column > col) {
5070: cafffff6 bgt 5050 <erase+0x164>
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
5074: e3560000 cmp r6, #0
5078: 1affffab bne 4f2c <erase+0x40>
507c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
5080: e5d40043 ldrb r0, [r4, #67] ; 0x43 <== NOT EXECUTED
5084: e1a01004 mov r1, r4 <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
5088: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
508c: eaffff71 b 4e58 <echo> <== NOT EXECUTED
5090: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
5094: e59f005c ldr r0, [pc, #92] ; 50f8 <erase+0x20c> <== NOT EXECUTED
5098: e3a01003 mov r1, #3 <== NOT EXECUTED
509c: e1a02004 mov r2, r4 <== NOT EXECUTED
50a0: ebfffecd bl 4bdc <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
50a4: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
50a8: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
50ac: 12433001 subne r3, r3, #1 <== NOT EXECUTED
50b0: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
50b4: e5973000 ldr r3, [r7] <== NOT EXECUTED
50b8: e7d33005 ldrb r3, [r3, r5] <== NOT EXECUTED
50bc: e3130020 tst r3, #32 <== NOT EXECUTED
50c0: 0affffaf beq 4f84 <erase+0x98> <== NOT EXECUTED
50c4: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
50c8: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
50cc: 0affff94 beq 4f24 <erase+0x38> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
50d0: e59f0020 ldr r0, [pc, #32] ; 50f8 <erase+0x20c> <== NOT EXECUTED
50d4: e3a01003 mov r1, #3 <== NOT EXECUTED
50d8: e1a02004 mov r2, r4 <== NOT EXECUTED
50dc: ebfffebe bl 4bdc <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
50e0: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
50e4: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
50e8: 12433001 subne r3, r3, #1 <== NOT EXECUTED
50ec: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
50f0: eaffffab b 4fa4 <erase+0xb8> <== NOT EXECUTED
00011ff0 <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)
{
11ff0: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
11ff4: e1a04000 mov r4, r0
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);
11ff8: e5d06002 ldrb r6, [r0, #2] 11ffc: e5d0700c ldrb r7, [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)
12000: e5d00089 ldrb r0, [r0, #137] ; 0x89 12004: e0667007 rsb r7, r6, r7 12008: e3500000 cmp r0, #0
int
fat_buf_access(fat_fs_info_t *fs_info,
const uint32_t sec_num,
const int op_type,
uint8_t **sec_buf)
{
1200c: e1a05001 mov r5, r1 12010: e1a09002 mov r9, r2 12014: e1a0a003 mov sl, r3 12018: e1a08731 lsr r8, r1, r7
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)
1201c: 0a000002 beq 1202c <fat_buf_access+0x3c>
12020: e5943084 ldr r3, [r4, #132] ; 0x84 12024: e1530001 cmp r3, r1
12028: 0a00000d beq 12064 <fat_buf_access+0x74>
{
fat_buf_release(fs_info);
1202c: e1a00004 mov r0, r4 12030: ebffff85 bl 11e4c <fat_buf_release>
if (op_type == FAT_OP_TYPE_READ)
12034: e3590001 cmp r9, #1
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
12038: e5940064 ldr r0, [r4, #100] ; 0x64 1203c: e1a01008 mov r1, r8 12040: 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)
12044: 0a00000d beq 12080 <fat_buf_access+0x90>
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);
12048: ebfff763 bl fddc <rtems_bdbuf_get>
if (sc != RTEMS_SUCCESSFUL)
1204c: e3500000 cmp r0, #0
12050: 1a00000c bne 12088 <fat_buf_access+0x98>
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;
12054: 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;
12058: e5845084 str r5, [r4, #132] ; 0x84
fs_info->c.modified = 0;
1205c: e5c40088 strb r0, [r4, #136] ; 0x88
fs_info->c.state = FAT_CACHE_ACTUAL;
12060: 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 -
12064: e0455718 sub r5, r5, r8, lsl r7
}
*sec_buf = &fs_info->c.buf->buffer[blk_ofs];
12068: e594308c ldr r3, [r4, #140] ; 0x8c 1206c: e593301c ldr r3, [r3, #28] 12070: e0836615 add r6, r3, r5, lsl r6
return RC_OK;
12074: 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];
12078: e58a6000 str r6, [sl]
return RC_OK;
}
1207c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
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)
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
12080: ebfff793 bl fed4 <rtems_bdbuf_read> 12084: eafffff0 b 1204c <fat_buf_access+0x5c>
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);
12088: eb001e09 bl 198b4 <__errno> <== NOT EXECUTED
1208c: e3a03005 mov r3, #5 <== NOT EXECUTED
12090: e5803000 str r3, [r0] <== NOT EXECUTED
12094: e3e00000 mvn r0, #0 <== NOT EXECUTED
12098: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
00011e4c <fat_buf_release>:
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
11e4c: e92d4070 push {r4, r5, r6, lr}
11e50: e1a04000 mov r4, r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (fs_info->c.state == FAT_CACHE_EMPTY)
11e54: e5d00089 ldrb r0, [r0, #137] ; 0x89 11e58: e3500000 cmp r0, #0
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
11e5c: e24dd004 sub sp, sp, #4
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (fs_info->c.state == FAT_CACHE_EMPTY)
11e60: 0a000047 beq 11f84 <fat_buf_release+0x138>
return RC_OK;
if (fs_info->c.modified)
11e64: e5d43088 ldrb r3, [r4, #136] ; 0x88 11e68: e3530000 cmp r3, #0
11e6c: 0a00003c beq 11f64 <fat_buf_release+0x118>
{
uint32_t sec_num = fs_info->c.blk_num;
11e70: e5942084 ldr r2, [r4, #132] ; 0x84
bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
11e74: e1d431b8 ldrh r3, [r4, #24] 11e78: e1520003 cmp r2, r3
11e7c: 3a000002 bcc 11e8c <fat_buf_release+0x40>
11e80: e5943020 ldr r3, [r4, #32] 11e84: e1520003 cmp r2, r3
11e88: 3a000042 bcc 11f98 <fat_buf_release+0x14c>
11e8c: e3a05000 mov r5, #0
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf,
fs_info->c.buf->buffer + blk_ofs,
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
11e90: e594008c ldr r0, [r4, #140] ; 0x8c 11e94: ebfff8b8 bl 1017c <rtems_bdbuf_release_modified>
if (sc != RTEMS_SUCCESSFUL)
11e98: e3500000 cmp r0, #0
11e9c: 1a000034 bne 11f74 <fat_buf_release+0x128>
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.modified = 0;
if (sec_of_fat && !fs_info->vol.mirror)
11ea0: 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;
11ea4: e5c40088 strb r0, [r4, #136] ; 0x88
if (sec_of_fat && !fs_info->vol.mirror)
11ea8: 0a000037 beq 11f8c <fat_buf_release+0x140>
11eac: e5d43054 ldrb r3, [r4, #84] ; 0x54 11eb0: e3530000 cmp r3, #0
11eb4: 1a000034 bne 11f8c <fat_buf_release+0x140>
{
uint8_t i;
for (i = 1; i < fs_info->vol.fats; i++)
11eb8: e5d4300d ldrb r3, [r4, #13] 11ebc: e3530001 cmp r3, #1
11ec0: 9a000031 bls 11f8c <fat_buf_release+0x140>
11ec4: e3a05001 mov r5, #1 11ec8: ea000013 b 11f1c <fat_buf_release+0xd0>
{
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
}
else
{
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd);
11ecc: e1a0200d mov r2, sp 11ed0: e5940064 ldr r0, [r4, #100] ; 0x64 11ed4: ebfff7fe bl fed4 <rtems_bdbuf_read>
}
if ( sc != RTEMS_SUCCESSFUL)
11ed8: e3500000 cmp r0, #0
11edc: 1a00003e bne 11fdc <fat_buf_release+0x190>
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps);
11ee0: e59d3000 ldr r3, [sp] 11ee4: e593001c ldr r0, [r3, #28] 11ee8: e5941090 ldr r1, [r4, #144] ; 0x90 11eec: e1d420b0 ldrh r2, [r4] 11ef0: e0800006 add r0, r0, r6 11ef4: eb002115 bl 1a350 <memcpy>
sc = rtems_bdbuf_release_modified(bd);
11ef8: e59d0000 ldr r0, [sp] 11efc: ebfff89e bl 1017c <rtems_bdbuf_release_modified>
if (sec_of_fat && !fs_info->vol.mirror)
{
uint8_t i;
for (i = 1; i < fs_info->vol.fats; i++)
11f00: e2855001 add r5, r5, #1
}
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(bd);
if ( sc != RTEMS_SUCCESSFUL)
11f04: e3500000 cmp r0, #0
if (sec_of_fat && !fs_info->vol.mirror)
{
uint8_t i;
for (i = 1; i < fs_info->vol.fats; i++)
11f08: e20550ff and r5, r5, #255 ; 0xff
}
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(bd);
if ( sc != RTEMS_SUCCESSFUL)
11f0c: 1a000032 bne 11fdc <fat_buf_release+0x190>
if (sec_of_fat && !fs_info->vol.mirror)
{
uint8_t i;
for (i = 1; i < fs_info->vol.fats; i++)
11f10: e5d4300d ldrb r3, [r4, #13] 11f14: e1530005 cmp r3, r5
11f18: 9a00001b bls 11f8c <fat_buf_release+0x140>
{
rtems_bdbuf_buffer *bd;
sec_num = fs_info->c.blk_num + fs_info->vol.fat_length * i,
11f1c: e5943084 ldr r3, [r4, #132] ; 0x84 11f20: e594601c ldr r6, [r4, #28] 11f24: 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);
11f28: e5d4200c ldrb r2, [r4, #12] 11f2c: e5d43002 ldrb r3, [r4, #2] 11f30: e0632002 rsb r2, r3, r2 11f34: 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 -
11f38: 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
11f3c: e1b06316 lsls r6, r6, r3
11f40: 1affffe1 bne 11ecc <fat_buf_release+0x80>
&& fs_info->vol.bps == fs_info->vol.bytes_per_block)
11f44: e1d420b0 ldrh r2, [r4] 11f48: e1d430ba ldrh r3, [r4, #10] 11f4c: e1520003 cmp r2, r3
11f50: 1affffdd bne 11ecc <fat_buf_release+0x80>
{
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);
11f54: e5940064 ldr r0, [r4, #100] ; 0x64 11f58: e1a0200d mov r2, sp 11f5c: ebfff79e bl fddc <rtems_bdbuf_get> 11f60: eaffffdc b 11ed8 <fat_buf_release+0x8c>
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
11f64: e594008c ldr r0, [r4, #140] ; 0x8c 11f68: ebfff852 bl 100b8 <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL)
11f6c: e3500000 cmp r0, #0
11f70: 0a000005 beq 11f8c <fat_buf_release+0x140>
rtems_set_errno_and_return_minus_one(EIO);
11f74: eb001e4e bl 198b4 <__errno> <== NOT EXECUTED 11f78: e3a03005 mov r3, #5 <== NOT EXECUTED 11f7c: e5803000 str r3, [r0] <== NOT EXECUTED 11f80: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
fs_info->c.state = FAT_CACHE_EMPTY;
return RC_OK;
}
11f84: e28dd004 add sp, sp, #4
11f88: e8bd8070 pop {r4, r5, r6, pc}
{
sc = rtems_bdbuf_release(fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
}
fs_info->c.state = FAT_CACHE_EMPTY;
11f8c: e3a00000 mov r0, #0 11f90: e5c40089 strb r0, [r4, #137] ; 0x89 11f94: eafffffa b 11f84 <fat_buf_release+0x138>
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)
11f98: e5d43054 ldrb r3, [r4, #84] ; 0x54 11f9c: e3530000 cmp r3, #0
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
11fa0: e5d4100c ldrb r1, [r4, #12] 11fa4: e5d43002 ldrb r3, [r4, #2]
return RC_OK;
if (fs_info->c.modified)
{
uint32_t sec_num = fs_info->c.blk_num;
bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
11fa8: 13a05001 movne 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)
11fac: 1affffb7 bne 11e90 <fat_buf_release+0x44>
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);
11fb0: e0631001 rsb r1, r3, r1 11fb4: e1a00132 lsr r0, 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 -
11fb8: e0421110 sub r1, r2, r0, lsl r1
memcpy(fs_info->sec_buf,
fs_info->c.buf->buffer + blk_ofs,
11fbc: e594208c ldr r2, [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,
11fc0: e592201c ldr r2, [r2, #28] 11fc4: e5940090 ldr r0, [r4, #144] ; 0x90 11fc8: e0821311 add r1, r2, r1, lsl r3 11fcc: e1d420b0 ldrh r2, [r4] 11fd0: eb0020de bl 1a350 <memcpy>
return RC_OK;
if (fs_info->c.modified)
{
uint32_t sec_num = fs_info->c.blk_num;
bool sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&
11fd4: e3a05001 mov r5, #1 11fd8: eaffffac b 11e90 <fat_buf_release+0x44>
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(bd);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
11fdc: eb001e34 bl 198b4 <__errno> <== NOT EXECUTED 11fe0: e3a0300c mov r3, #12 <== NOT EXECUTED 11fe4: e5803000 str r3, [r0] <== NOT EXECUTED 11fe8: e3e00000 mvn r0, #0 <== NOT EXECUTED 11fec: eaffffe4 b 11f84 <fat_buf_release+0x138> <== NOT EXECUTED
000121e4 <fat_cluster_set>:
fat_fs_info_t *fs_info,
const uint32_t start_cln,
const uint32_t offset,
const uint32_t count,
const uint8_t pattern)
{
121e4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
ssize_t rc = RC_OK; uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
121e8: e1d070b6 ldrh r7, [r0, #6] 121ec: e0627007 rsb r7, r2, r7
fat_fs_info_t *fs_info,
const uint32_t start_cln,
const uint32_t offset,
const uint32_t count,
const uint8_t pattern)
{
121f0: e24dd004 sub sp, sp, #4
ssize_t rc = RC_OK; uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
121f4: e1530007 cmp r3, r7 121f8: 31a07003 movcc r7, r3
fat_cluster_num_to_block_num (const fat_fs_info_t *fs_info,
uint32_t cln)
{
uint32_t blk;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
121fc: e3510000 cmp r1, #0
fat_fs_info_t *fs_info,
const uint32_t start_cln,
const uint32_t offset,
const uint32_t count,
const uint8_t pattern)
{
12200: e1a04000 mov r4, r0 12204: e5ddb028 ldrb fp, [sp, #40] ; 0x28
fat_cluster_num_to_block_num (const fat_fs_info_t *fs_info,
uint32_t cln)
{
uint32_t blk;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
12208: 1a000002 bne 12218 <fat_cluster_set+0x34>
1220c: e5d0300e ldrb r3, [r0, #14] <== NOT EXECUTED 12210: e3130003 tst r3, #3 <== NOT EXECUTED 12214: 1a000040 bne 1231c <fat_cluster_set+0x138> <== NOT EXECUTED
blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
else
{
cln -= FAT_RSRVD_CLN;
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
12218: e5d4800c ldrb r8, [r4, #12] 1221c: e5d43008 ldrb r3, [r4, #8]
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
else
{
cln -= FAT_RSRVD_CLN;
12220: e2411002 sub r1, r1, #2
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
12224: e0683003 rsb r3, r8, r3 12228: e1a01311 lsl r1, r1, 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);
1222c: e5d4a002 ldrb sl, [r4, #2] 12230: e5943034 ldr r3, [r4, #52] ; 0x34 12234: e06aa008 rsb sl, sl, r8
blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
12238: e081aa33 add sl, r1, r3, lsr sl
const uint8_t pattern)
{
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
uint32_t blocks_in_offset = offset >> fs_info->vol.bytes_per_block_log2;
1223c: e1a03832 lsr r3, r2, r8
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2); ssize_t bytes_written = 0;
12240: e3a09000 mov r9, #0
{
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
uint32_t blocks_in_offset = offset >> fs_info->vol.bytes_per_block_log2;
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
12244: e0428813 sub r8, r2, r3, lsl r8
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
12248: e083a00a add sl, r3, sl
const uint32_t start_cln,
const uint32_t offset,
const uint32_t count,
const uint8_t pattern)
{
ssize_t rc = RC_OK;
1224c: e1a03009 mov r3, r9
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
12250: ea000010 b 12298 <fat_cluster_set+0xb4>
uint8_t *blk_buf;
uint32_t sec_num = fat_block_num_to_sector_num(fs_info, start_blk);
if (0 < bytes_to_write)
{
if (bytes_to_write == fs_info->vol.bytes_per_block)
12254: e1530005 cmp r3, r5
static inline uint32_t
fat_block_num_to_sector_num (const fat_fs_info_t *fs_info,
const uint32_t block_number)
{
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
12258: e0621001 rsb r1, r2, r1
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
1225c: e1a00004 mov r0, r4 12260: 03a02002 moveq r2, #2
}
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
12264: 13a02001 movne r2, #1 12268: e1a0111a lsl r1, sl, r1 1226c: e1a0300d mov r3, sp 12270: ebffff5e bl 11ff0 <fat_buf_access>
if (RC_OK == rc)
12274: e3500000 cmp r0, #0
12278: 0a000019 beq 122e4 <fat_cluster_set+0x100>
fs_info,
cur_blk,
ofs_blk,
c,
pattern);
if (c != ret)
1227c: e1500006 cmp r0, r6
rc = -1;
else
{
bytes_to_write -= ret;
12280: 00607007 rsbeq r7, r0, r7
bytes_written += ret;
12284: 00899000 addeq r9, r9, r0
++cur_blk;
12288: 028aa001 addeq sl, sl, #1 1228c: 03a03000 moveq r3, #0
cur_blk,
ofs_blk,
c,
pattern);
if (c != ret)
rc = -1;
12290: 13e03000 mvnne r3, #0
else
{
bytes_to_write -= ret;
bytes_written += ret;
++cur_blk;
12294: e3a08000 mov r8, #0
ssize_t bytes_written = 0;
ssize_t ret;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
12298: e2832001 add r2, r3, #1 1229c: e3570000 cmp r7, #0 122a0: 03a02000 moveq r2, #0 122a4: 12022001 andne r2, r2, #1 122a8: e3520000 cmp r2, #0
122ac: 0a000015 beq 12308 <fat_cluster_set+0x124>
&& (0 < bytes_to_write))
{
uint32_t c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
122b0: e1d430ba ldrh r3, [r4, #10] 122b4: e0685003 rsb r5, r8, r3 122b8: e1550007 cmp r5, r7 122bc: 31a06005 movcc r6, r5 122c0: 21a06007 movcs r6, r7
const uint32_t offset,
const uint32_t count,
const uint8_t pattern)
{
int rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
122c4: e1560005 cmp r6, r5 122c8: 31a05006 movcc r5, r6
uint8_t *blk_buf;
uint32_t sec_num = fat_block_num_to_sector_num(fs_info, start_blk);
if (0 < bytes_to_write)
122cc: e3550000 cmp r5, #0
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
122d0: e5d42002 ldrb r2, [r4, #2] 122d4: e5d4100c ldrb r1, [r4, #12]
int rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
uint8_t *blk_buf;
uint32_t sec_num = fat_block_num_to_sector_num(fs_info, start_blk);
if (0 < bytes_to_write)
122d8: 1affffdd bne 12254 <fat_cluster_set+0x70>
}
}
if (RC_OK != rc)
return rc;
else
return bytes_to_write;
122dc: e1a00005 mov r0, r5 <== NOT EXECUTED 122e0: eaffffe5 b 1227c <fat_cluster_set+0x98> <== NOT EXECUTED
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
if (RC_OK == rc)
{
memset(blk_buf + offset, pattern, bytes_to_write);
122e4: e59d0000 ldr r0, [sp] 122e8: e1a0100b mov r1, fp 122ec: e0800008 add r0, r0, r8 122f0: e1a02005 mov r2, r5 122f4: eb00204b bl 1a428 <memset>
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
122f8: e3a03001 mov r3, #1 122fc: e5c43088 strb r3, [r4, #136] ; 0x88
}
}
if (RC_OK != rc)
return rc;
else
return bytes_to_write;
12300: e1a00005 mov r0, r5 12304: eaffffdc b 1227c <fat_cluster_set+0x98>
bytes_written += ret;
++cur_blk;
}
ofs_blk = 0;
}
if (RC_OK != rc)
12308: e3530000 cmp r3, #0
return rc;
else
return bytes_written;
}
1230c: 01a00009 moveq r0, r9
12310: 13e00000 mvnne r0, #0
12314: e28dd004 add sp, sp, #4
12318: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
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);
1231c: e5d0800c ldrb r8, [r0, #12] <== NOT EXECUTED 12320: e5d03002 ldrb r3, [r0, #2] <== NOT EXECUTED 12324: e590a020 ldr sl, [r0, #32] <== NOT EXECUTED 12328: e0633008 rsb r3, r3, r8 <== NOT EXECUTED 1232c: e1a0a33a lsr sl, sl, r3 <== NOT EXECUTED 12330: eaffffc1 b 1223c <fat_cluster_set+0x58> <== NOT EXECUTED
00012334 <fat_cluster_write>:
const uint32_t start_cln,
const uint32_t offset,
const uint32_t count,
const void *buff,
const bool overwrite_cluster)
{
12334: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
12338: e1d070b6 ldrh r7, [r0, #6] 1233c: e0627007 rsb r7, r2, r7
const uint32_t start_cln,
const uint32_t offset,
const uint32_t count,
const void *buff,
const bool overwrite_cluster)
{
12340: e24dd004 sub sp, sp, #4
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
12344: e1530007 cmp r3, r7 12348: 31a07003 movcc r7, r3
fat_cluster_num_to_block_num (const fat_fs_info_t *fs_info,
uint32_t cln)
{
uint32_t blk;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
1234c: e3510000 cmp r1, #0
const uint32_t start_cln,
const uint32_t offset,
const uint32_t count,
const void *buff,
const bool overwrite_cluster)
{
12350: e1a04000 mov r4, r0 12354: e5ddb02c ldrb fp, [sp, #44] ; 0x2c
fat_cluster_num_to_block_num (const fat_fs_info_t *fs_info,
uint32_t cln)
{
uint32_t blk;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
12358: 1a000002 bne 12368 <fat_cluster_write+0x34>
1235c: e5d0300e ldrb r3, [r0, #14] 12360: e3130003 tst r3, #3
12364: 1a000048 bne 1248c <fat_cluster_write+0x158>
blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
else
{
cln -= FAT_RSRVD_CLN;
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
12368: e5d4800c ldrb r8, [r4, #12] 1236c: e5d43008 ldrb r3, [r4, #8]
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
blk = fat_sector_num_to_block_num(fs_info, fs_info->vol.rdir_loc);
else
{
cln -= FAT_RSRVD_CLN;
12370: e2411002 sub r1, r1, #2
blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
12374: e0683003 rsb r3, r8, r3 12378: e1a01311 lsl r1, r1, r3 1237c: e5d4a002 ldrb sl, [r4, #2] 12380: e5943034 ldr r3, [r4, #52] ; 0x34 12384: e06aa008 rsb sl, sl, r8
blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
12388: e081aa33 add sl, r1, r3, lsr sl
const bool overwrite_cluster)
{
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
uint32_t blocks_in_offset = (offset >> fs_info->vol.bytes_per_block_log2);
1238c: e1a03832 lsr r3, r2, r8
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
ssize_t bytes_written = 0;
12390: e3a09000 mov r9, #0
{
ssize_t rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bpc - offset));
uint32_t cur_blk = fat_cluster_num_to_block_num(fs_info, start_cln);
uint32_t blocks_in_offset = (offset >> fs_info->vol.bytes_per_block_log2);
uint32_t ofs_blk = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
12394: e0428813 sub r8, r2, r3, lsl r8
ssize_t bytes_written = 0;
uint8_t *buffer = (uint8_t*)buff;
ssize_t ret;
uint32_t c;
cur_blk += blocks_in_offset;
12398: e083a00a add sl, r3, sl
const uint32_t offset,
const uint32_t count,
const void *buff,
const bool overwrite_cluster)
{
ssize_t rc = RC_OK;
1239c: e1a03009 mov r3, r9
ssize_t ret;
uint32_t c;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
123a0: ea000012 b 123f0 <fat_cluster_write+0xbc>
static inline uint32_t
fat_block_num_to_sector_num (const fat_fs_info_t *fs_info,
const uint32_t block_number)
{
return block_number << (fs_info->vol.bytes_per_block_log2 - fs_info->vol.sec_log2);
123a4: e0621001 rsb r1, r2, r1
uint8_t *blk_buf;
uint32_t sec_num = fat_block_num_to_sector_num(fs_info, start_blk);
if (0 < bytes_to_write)
{
if ( overwrite_block
123a8: e35b0000 cmp fp, #0
|| (bytes_to_write == fs_info->vol.bytes_per_block))
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
123ac: e1a00004 mov r0, r4 123b0: e1a0111a lsl r1, sl, r1
uint8_t *blk_buf;
uint32_t sec_num = fat_block_num_to_sector_num(fs_info, start_blk);
if (0 < bytes_to_write)
{
if ( overwrite_block
123b4: 1a000020 bne 1243c <fat_cluster_write+0x108>
|| (bytes_to_write == fs_info->vol.bytes_per_block))
123b8: e1530006 cmp r3, r6
123bc: 0a00001e beq 1243c <fat_cluster_write+0x108>
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
}
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
123c0: e3a02001 mov r2, #1 123c4: e1a0300d mov r3, sp 123c8: ebffff08 bl 11ff0 <fat_buf_access>
if (RC_OK == rc)
123cc: e3500000 cmp r0, #0
123d0: 0a00001e beq 12450 <fat_cluster_write+0x11c>
cur_blk,
ofs_blk,
c,
&buffer[bytes_written],
overwrite_cluster);
if (c != ret)
123d4: e1500005 cmp r0, r5
rc = -1;
else
{
bytes_to_write -= ret;
123d8: 00607007 rsbeq r7, r0, r7
bytes_written += ret;
123dc: 00899000 addeq r9, r9, r0
++cur_blk;
123e0: 028aa001 addeq sl, sl, #1 123e4: 03a03000 moveq r3, #0
ofs_blk,
c,
&buffer[bytes_written],
overwrite_cluster);
if (c != ret)
rc = -1;
123e8: 13e03000 mvnne r3, #0
else
{
bytes_to_write -= ret;
bytes_written += ret;
++cur_blk;
123ec: e3a08000 mov r8, #0
ssize_t ret;
uint32_t c;
cur_blk += blocks_in_offset;
while ( (RC_OK == rc)
123f0: e2832001 add r2, r3, #1 123f4: e3570000 cmp r7, #0 123f8: 03a02000 moveq r2, #0 123fc: 12022001 andne r2, r2, #1 12400: e3520000 cmp r2, #0
12404: 0a00001b beq 12478 <fat_cluster_write+0x144>
&& (0 < bytes_to_write))
{
c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
12408: e1d430ba ldrh r3, [r4, #10] 1240c: e0686003 rsb r6, r8, r3 12410: e1560007 cmp r6, r7 12414: 31a05006 movcc r5, r6 12418: 21a05007 movcs r5, r7
const uint32_t count,
const void *buf,
const bool overwrite_block)
{
int rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
1241c: e1550006 cmp r5, r6 12420: 31a06005 movcc r6, r5
uint8_t *blk_buf;
uint32_t sec_num = fat_block_num_to_sector_num(fs_info, start_blk);
if (0 < bytes_to_write)
12424: e3560000 cmp r6, #0
uint32_t ino
)
{
return (ino >= fs_info->uino_base);
}
12428: e5d42002 ldrb r2, [r4, #2] 1242c: e5d4100c ldrb r1, [r4, #12]
int rc = RC_OK;
uint32_t bytes_to_write = MIN(count, (fs_info->vol.bytes_per_block - offset));
uint8_t *blk_buf;
uint32_t sec_num = fat_block_num_to_sector_num(fs_info, start_blk);
if (0 < bytes_to_write)
12430: 1affffdb bne 123a4 <fat_cluster_write+0x70>
}
}
if (RC_OK != rc)
return rc;
else
return bytes_to_write;
12434: e1a00006 mov r0, r6 <== NOT EXECUTED 12438: eaffffe5 b 123d4 <fat_cluster_write+0xa0> <== NOT EXECUTED
if (0 < bytes_to_write)
{
if ( overwrite_block
|| (bytes_to_write == fs_info->vol.bytes_per_block))
{
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
1243c: e3a02002 mov r2, #2 12440: e1a0300d mov r3, sp 12444: ebfffee9 bl 11ff0 <fat_buf_access>
}
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
if (RC_OK == rc)
12448: e3500000 cmp r0, #0
1244c: 1affffe0 bne 123d4 <fat_cluster_write+0xa0>
{
memcpy(blk_buf + offset, buf, bytes_to_write);
12450: e59d3028 ldr r3, [sp, #40] ; 0x28 12454: e59d0000 ldr r0, [sp] 12458: e0831009 add r1, r3, r9 1245c: e0800008 add r0, r0, r8 12460: e1a02006 mov r2, r6 12464: eb001fb9 bl 1a350 <memcpy>
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
12468: e3a03001 mov r3, #1 1246c: e5c43088 strb r3, [r4, #136] ; 0x88
}
}
if (RC_OK != rc)
return rc;
else
return bytes_to_write;
12470: e1a00006 mov r0, r6 12474: eaffffd6 b 123d4 <fat_cluster_write+0xa0>
bytes_written += ret;
++cur_blk;
}
ofs_blk = 0;
}
if (RC_OK != rc)
12478: e3530000 cmp r3, #0
return rc;
else
return bytes_written;
}
1247c: 01a00009 moveq r0, r9
12480: 13e00000 mvnne r0, #0
12484: e28dd004 add sp, sp, #4
12488: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
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);
1248c: e5d0800c ldrb r8, [r0, #12] 12490: e5d03002 ldrb r3, [r0, #2] 12494: e590a020 ldr sl, [r0, #32] 12498: e0633008 rsb r3, r3, r8 1249c: e1a0a33a lsr sl, sl, r3 124a0: eaffffb9 b 1238c <fat_cluster_write+0x58>
0001172c <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)
1172c: e5913008 ldr r3, [r1, #8] 11730: e3530001 cmp r3, #1
{
fat_fd->links_num--;
11734: 82433001 subhi r3, r3, #1
int
fat_file_close(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
11738: e92d4070 push {r4, r5, r6, lr}
1173c: e1a05000 mov r5, r0
11740: 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)
{
fat_fd->links_num--;
11744: 85813008 strhi r3, [r1, #8]
return rc;
11748: 83a00000 movhi r0, #0
/*
* 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)
1174c: 88bd8070 pophi {r4, r5, r6, pc}
return rc;
}
key = fat_construct_key(fs_info, &fat_fd->dir_pos.sname);
if (fat_fd->flags & FAT_FILE_REMOVED)
11750: e5d16030 ldrb r6, [r1, #48] ; 0x30 11754: e2166001 ands r6, r6, #1
11758: 0a00000d beq 11794 <fat_file_close+0x68>
{
rc = fat_file_truncate(fs_info, fat_fd, 0);
1175c: e3a02000 mov r2, #0 11760: ebffffb0 bl 11628 <fat_file_truncate>
if ( rc != RC_OK )
11764: e3500000 cmp r0, #0
11768: 18bd8070 popne {r4, r5, r6, pc}
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
1176c: e1a00004 mov r0, r4 11770: eb000cd6 bl 14ad0 <_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) )
11774: e1a00005 mov r0, r5 11778: e594100c ldr r1, [r4, #12] 1177c: eb0005da bl 12eec <fat_ino_is_unique> 11780: e3500000 cmp r0, #0
11784: 1a00000d bne 117c0 <fat_file_close+0x94>
fat_fd->links_num = 0;
}
else
{
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
free(fat_fd);
11788: e1a00004 mov r0, r4 1178c: ebffcaf2 bl 435c <free> 11790: ea000004 b 117a8 <fat_file_close+0x7c>
free(fat_fd);
}
else
{
if (fat_ino_is_unique(fs_info, fat_fd->ino))
11794: e591100c ldr r1, [r1, #12] 11798: eb0005d3 bl 12eec <fat_ino_is_unique> 1179c: e3500000 cmp r0, #0
{
fat_fd->links_num = 0;
117a0: 15846008 strne r6, [r4, #8]
free(fat_fd);
}
else
{
if (fat_ino_is_unique(fs_info, fat_fd->ino))
117a4: 0a000002 beq 117b4 <fat_file_close+0x88>
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
117a8: e1a00005 mov r0, r5
return rc;
}
117ac: e8bd4070 pop {r4, r5, r6, lr}
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
117b0: ea0001a5 b 11e4c <fat_buf_release> 117b4: e1a00004 mov r0, r4 117b8: eb000cc4 bl 14ad0 <_Chain_Extract> 117bc: eafffff1 b 11788 <fat_file_close+0x5c>
return rc;
_hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);
if ( fat_ino_is_unique(fs_info, fat_fd->ino) )
fat_free_unique_ino(fs_info, fat_fd->ino);
117c0: e1a00005 mov r0, r5 <== NOT EXECUTED 117c4: e594100c ldr r1, [r4, #12] <== NOT EXECUTED 117c8: eb0005be bl 12ec8 <fat_free_unique_ino> <== NOT EXECUTED 117cc: eaffffed b 11788 <fat_file_close+0x5c> <== NOT EXECUTED
00011894 <fat_file_extend>:
fat_file_fd_t *fat_fd,
bool zero_fill,
uint32_t new_length,
uint32_t *a_length
)
{
11894: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
11898: e24dd01c sub sp, sp, #28
uint32_t last_cl = 0;
uint32_t bytes_remain = 0;
uint32_t cls_added;
ssize_t bytes_written;
*a_length = new_length;
1189c: e59dc040 ldr ip, [sp, #64] ; 0x40 118a0: e58c3000 str r3, [ip]
fat_file_fd_t *fat_fd,
bool zero_fill,
uint32_t new_length,
uint32_t *a_length
)
{
118a4: e1a04003 mov r4, r3
uint32_t cls_added;
ssize_t bytes_written;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
118a8: e5913018 ldr r3, [r1, #24]
uint32_t new_length,
uint32_t *a_length
)
{
int rc = RC_OK;
uint32_t chain = 0;
118ac: e3a07000 mov r7, #0
uint32_t cls_added;
ssize_t bytes_written;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
118b0: e1540003 cmp r4, r3
fat_file_fd_t *fat_fd,
bool zero_fill,
uint32_t new_length,
uint32_t *a_length
)
{
118b4: e1a05001 mov r5, r1 118b8: e1a06000 mov r6, r0 118bc: e202a0ff and sl, r2, #255 ; 0xff
int rc = RC_OK;
uint32_t chain = 0;
118c0: e58d7008 str r7, [sp, #8]
uint32_t bytes2add = 0;
uint32_t cls2add = 0;
uint32_t old_last_cl;
uint32_t last_cl = 0;
118c4: e58d7010 str r7, [sp, #16]
uint32_t cls_added;
ssize_t bytes_written;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
118c8: 9a000012 bls 11918 <fat_file_extend+0x84>
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
118cc: e5912020 ldr r2, [r1, #32] 118d0: e3520001 cmp r2, #1
118d4: 0a00003e beq 119d4 <fat_file_extend+0x140>
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
118d8: e1d680b6 ldrh r8, [r6, #6]
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
118dc: e2482001 sub r2, r8, #1 118e0: e002b003 and fp, 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 -
118e4: e06b8008 rsb r8, fp, r8
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
118e8: e0639004 rsb r9, r3, r4
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 -
118ec: 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)
118f0: e1580009 cmp r8, r9
bytes2add -= bytes_remain;
118f4: 30689009 rsbcc r9, r8, r9
else
bytes2add = 0;
118f8: 23a09000 movcs r9, #0
if (zero_fill && bytes_remain > 0) {
118fc: e35a0000 cmp sl, #0
11900: 0a000001 beq 1190c <fat_file_extend+0x78>
11904: e3580000 cmp r8, #0
11908: 1a00003c bne 11a00 <fat_file_extend+0x16c>
/*
* 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)
1190c: e3590000 cmp r9, #0
return RC_OK;
11910: 01a07009 moveq r7, r9
/*
* 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)
11914: 1a000002 bne 11924 <fat_file_extend+0x90>
*a_length = new_length;
fat_fd->fat_file_size = new_length;
return RC_OK;
}
11918: e1a00007 mov r0, r7
1191c: e28dd01c add sp, sp, #28
11920: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
11924: e5d63008 ldrb r3, [r6, #8] 11928: e249b001 sub fp, r9, #1 1192c: e1a0b33b lsr fp, fp, r3 11930: e28bb001 add fp, fp, #1
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
11934: e28dc010 add ip, sp, #16 11938: e1a00006 mov r0, r6 1193c: e28d1008 add r1, sp, #8 11940: e1a0200b mov r2, fp 11944: e28d3014 add r3, sp, #20 11948: e58dc000 str ip, [sp] 1194c: e58da004 str sl, [sp, #4] 11950: eb001a07 bl 18174 <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)
11954: e2507000 subs r7, r0, #0
11958: 1affffee bne 11918 <fat_file_extend+0x84>
return rc;
/* this means that no space left on device */
if ((cls_added == 0) && (bytes_remain == 0))
1195c: e59d2014 ldr r2, [sp, #20] 11960: e1988002 orrs r8, r8, r2
11964: 0a000020 beq 119ec <fat_file_extend+0x158>
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
11968: e15b0002 cmp fp, r2
1196c: 0a000006 beq 1198c <fat_file_extend+0xf8>
{
new_length -= bytes2add & (fs_info->vol.bpc - 1);
11970: e1d630b6 ldrh r3, [r6, #6] <== NOT EXECUTED 11974: e2433001 sub r3, r3, #1 <== NOT EXECUTED 11978: e0099003 and r9, r9, r3 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
1197c: e5d63008 ldrb r3, [r6, #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);
11980: e0694004 rsb r4, r9, r4 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
11984: e062b00b rsb fp, r2, fp <== NOT EXECUTED 11988: e044431b sub r4, r4, fp, lsl r3 <== NOT EXECUTED
}
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
1198c: e5953018 ldr r3, [r5, #24] 11990: e3530000 cmp r3, #0
11994: 1a00002b bne 11a48 <fat_file_extend+0x1b4>
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
11998: e59d1008 ldr r1, [sp, #8]
fat_fd->map.file_cln = 0;
1199c: e5853034 str 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;
119a0: e585101c str r1, [r5, #28] 119a4: e5851038 str r1, [r5, #56] ; 0x38
}
fat_buf_release(fs_info);
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
119a8: e3520000 cmp r2, #0
119ac: 0a000004 beq 119c4 <fat_file_extend+0x130>
{
fat_fd->map.last_cln = last_cl;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
119b0: e5953010 ldr r3, [r5, #16] 119b4: e3530000 cmp r3, #0
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
{
fat_fd->map.last_cln = last_cl;
119b8: e59d3010 ldr r3, [sp, #16] 119bc: e585303c str r3, [r5, #60] ; 0x3c
if (fat_fd->fat_file_type == FAT_DIRECTORY)
119c0: 0a00002d beq 11a7c <fat_file_extend+0x1e8>
return rc;
}
}
}
*a_length = new_length;
119c4: e59dc040 ldr ip, [sp, #64] ; 0x40 119c8: e58c4000 str r4, [ip]
fat_fd->fat_file_size = new_length;
119cc: e5854018 str r4, [r5, #24]
return RC_OK;
119d0: eaffffd0 b 11918 <fat_file_extend+0x84>
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
119d4: e5912024 ldr r2, [r1, #36] ; 0x24 119d8: e1520007 cmp r2, r7
119dc: 1affffbd bne 118d8 <fat_file_extend+0x44>
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
119e0: 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)) &&
119e4: e3120003 tst r2, #3
119e8: 0affffba beq 118d8 <fat_file_extend+0x44>
if (rc != RC_OK)
return rc;
/* this means that no space left on device */
if ((cls_added == 0) && (bytes_remain == 0))
rtems_set_errno_and_return_minus_one(ENOSPC);
119ec: eb001fb0 bl 198b4 <__errno> 119f0: e3a0301c mov r3, #28 119f4: e5803000 str r3, [r0] 119f8: e3e07000 mvn r7, #0 119fc: eaffffc5 b 11918 <fat_file_extend+0x84>
else
bytes2add = 0;
if (zero_fill && bytes_remain > 0) {
uint32_t start = fat_fd->fat_file_size;
uint32_t cl_start = start >> fs_info->vol.bpc_log2;
11a00: e5d62008 ldrb r2, [r6, #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);
11a04: e1a00006 mov r0, r6 11a08: e1a02233 lsr r2, r3, r2 11a0c: e1a01005 mov r1, r5 11a10: e28d3018 add r3, sp, #24 11a14: ebfffdbd bl 11110 <fat_file_lseek>
if (rc != RC_OK)
11a18: e2507000 subs r7, r0, #0
11a1c: 1affffbd bne 11918 <fat_file_extend+0x84>
return rc;
bytes_written = fat_cluster_set (fs_info, cur_cln, ofs, bytes_remain, 0);
11a20: e1a00006 mov r0, r6 11a24: e59d1018 ldr r1, [sp, #24] 11a28: e1a0200b mov r2, fp 11a2c: e1a03008 mov r3, r8 11a30: e58d7000 str r7, [sp] 11a34: eb0001ea bl 121e4 <fat_cluster_set>
if (bytes_remain != bytes_written)
11a38: e1500008 cmp r0, r8
return -1;
11a3c: 13e07000 mvnne r7, #0
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
bytes_written = fat_cluster_set (fs_info, cur_cln, ofs, bytes_remain, 0);
if (bytes_remain != bytes_written)
11a40: 0affffb1 beq 1190c <fat_file_extend+0x78>
11a44: eaffffb3 b 11918 <fat_file_extend+0x84> <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln = chain;
fat_fd->map.file_cln = 0;
}
else
{
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
11a48: e595103c ldr r1, [r5, #60] ; 0x3c 11a4c: e3710001 cmn r1, #1
{
old_last_cl = fat_fd->map.last_cln;
11a50: 158d100c strne r1, [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)
11a54: 0a000012 beq 11aa4 <fat_file_extend+0x210>
fat_free_fat_clusters_chain(fs_info, chain);
return rc;
}
}
rc = fat_set_fat_cluster(fs_info, old_last_cl, chain);
11a58: e1a00006 mov r0, r6 11a5c: e59d2008 ldr r2, [sp, #8] 11a60: eb001907 bl 17e84 <fat_set_fat_cluster>
if ( rc != RC_OK )
11a64: e2508000 subs r8, r0, #0
{
fat_free_fat_clusters_chain(fs_info, chain);
11a68: e1a00006 mov r0, r6
return rc;
}
}
rc = fat_set_fat_cluster(fs_info, old_last_cl, chain);
if ( rc != RC_OK )
11a6c: 1a000008 bne 11a94 <fat_file_extend+0x200>
{
fat_free_fat_clusters_chain(fs_info, chain);
return rc;
}
fat_buf_release(fs_info);
11a70: eb0000f5 bl 11e4c <fat_buf_release> 11a74: e59d2014 ldr r2, [sp, #20] 11a78: eaffffca b 119a8 <fat_file_extend+0x114>
if (cls_added != 0)
{
fat_fd->map.last_cln = last_cl;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
{
rc = fat_init_clusters_chain(fs_info, chain);
11a7c: e1a00006 mov r0, r6 11a80: e59d1008 ldr r1, [sp, #8] 11a84: eb0004b5 bl 12d60 <fat_init_clusters_chain>
if ( rc != RC_OK )
11a88: e2508000 subs r8, r0, #0
11a8c: 0affffcc beq 119c4 <fat_file_extend+0x130>
{
fat_free_fat_clusters_chain(fs_info, chain);
11a90: e1a00006 mov r0, r6 <== NOT EXECUTED 11a94: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 11a98: eb001981 bl 180a4 <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
11a9c: e1a07008 mov r7, r8 <== NOT EXECUTED 11aa0: eaffff9c b 11918 <fat_file_extend+0x84> <== NOT EXECUTED
{
old_last_cl = fat_fd->map.last_cln;
}
else
{
rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM,
11aa4: e1a01005 mov r1, r5 <== NOT EXECUTED 11aa8: e28dc00c add ip, sp, #12 <== NOT EXECUTED 11aac: e1a00006 mov r0, r6 <== NOT EXECUTED 11ab0: e3a02001 mov r2, #1 <== NOT EXECUTED 11ab4: e2433001 sub r3, r3, #1 <== NOT EXECUTED 11ab8: e58dc000 str ip, [sp] <== NOT EXECUTED 11abc: ebffff43 bl 117d0 <fat_file_ioctl> <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
11ac0: e2508000 subs r8, r0, #0 <== NOT EXECUTED
{
fat_free_fat_clusters_chain(fs_info, chain);
return rc;
11ac4: 059d100c ldreq r1, [sp, #12] <== NOT EXECUTED
}
else
{
rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM,
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
11ac8: 0affffe2 beq 11a58 <fat_file_extend+0x1c4> <== NOT EXECUTED
if (fat_fd->fat_file_type == FAT_DIRECTORY)
{
rc = fat_init_clusters_chain(fs_info, chain);
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(fs_info, chain);
11acc: e1a00006 mov r0, r6 <== NOT EXECUTED 11ad0: eaffffef b 11a94 <fat_file_extend+0x200> <== NOT EXECUTED
000117d0 <fat_file_ioctl>:
fat_file_ioctl(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
117d0: e92d000c push {r2, r3}
117d4: e92d4010 push {r4, lr}
117d8: e24dd008 sub sp, sp, #8
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
117dc: e59d2010 ldr r2, [sp, #16]
uint32_t cl_start = 0;
uint32_t pos = 0;
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
117e0: e28d3014 add r3, sp, #20
switch (cmd)
117e4: e3520001 cmp r2, #1
fat_file_fd_t *fat_fd,
int cmd,
...)
{
int rc = RC_OK;
uint32_t cur_cln = 0;
117e8: e3a02000 mov r2, #0
uint32_t cl_start = 0;
uint32_t pos = 0;
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
117ec: e88d000c stm sp, {r2, r3}
switch (cmd)
117f0: 0a000007 beq 11814 <fat_file_ioctl+0x44>
*ret = cur_cln;
break;
default:
errno = EINVAL;
117f4: eb00202e bl 198b4 <__errno> <== NOT EXECUTED 117f8: e3a03016 mov r3, #22 <== NOT EXECUTED 117fc: e5803000 str r3, [r0] <== NOT EXECUTED
rc = -1;
11800: e3e00000 mvn r0, #0 <== NOT EXECUTED
break;
}
va_end(ap);
return rc;
}
11804: e28dd008 add sp, sp, #8
11808: e8bd4010 pop {r4, lr}
1180c: e28dd008 add sp, sp, #8
11810: e12fff1e bx lr
va_start(ap, cmd);
switch (cmd)
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
11814: e1a0c003 mov ip, r3 11818: e49c2008 ldr r2, [ip], #8
ret = va_arg(ap, uint32_t *);
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
1181c: e5914018 ldr r4, [r1, #24] 11820: e1520004 cmp r2, r4
switch (cmd)
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
ret = va_arg(ap, uint32_t *);
11824: e58dc004 str ip, [sp, #4] 11828: e59d4018 ldr r4, [sp, #24]
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
1182c: 2a000013 bcs 11880 <fat_file_ioctl+0xb0>
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
11830: e5913020 ldr r3, [r1, #32] 11834: e3530001 cmp r3, #1
11838: 0a000007 beq 1185c <fat_file_ioctl+0x8c>
*ret = 0;
rc = RC_OK;
break;
}
cl_start = pos >> fs_info->vol.bpc_log2;
1183c: e5d03008 ldrb r3, [r0, #8]
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
11840: e1a02332 lsr r2, r2, r3 11844: e1a0300d mov r3, sp 11848: ebfffe30 bl 11110 <fat_file_lseek>
if ( rc != RC_OK )
1184c: e3500000 cmp r0, #0
break;
*ret = cur_cln;
11850: 059d3000 ldreq r3, [sp] 11854: 05843000 streq r3, [r4]
break;
11858: eaffffe9 b 11804 <fat_file_ioctl+0x34>
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)) &&
1185c: e5913024 ldr r3, [r1, #36] ; 0x24 11860: e3530000 cmp r3, #0
11864: 1afffff4 bne 1183c <fat_file_ioctl+0x6c>
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
11868: 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)) &&
1186c: e31c0003 tst ip, #3
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
/* cluster 0 (zero) reserved for root dir */
*ret = 0;
11870: 15843000 strne r3, [r4]
rc = RC_OK;
11874: 11a00003 movne r0, r3
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)) &&
11878: 1affffe1 bne 11804 <fat_file_ioctl+0x34>
1187c: eaffffee b 1183c <fat_file_ioctl+0x6c>
ret = va_arg(ap, uint32_t *);
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
11880: eb00200b bl 198b4 <__errno> <== NOT EXECUTED 11884: e3a03005 mov r3, #5 <== NOT EXECUTED 11888: e5803000 str r3, [r0] <== NOT EXECUTED 1188c: e3e00000 mvn r0, #0 <== NOT EXECUTED 11890: eaffffdb b 11804 <fat_file_ioctl+0x34> <== NOT EXECUTED
00011110 <fat_file_lseek>:
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
11110: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
11114: e591a034 ldr sl, [r1, #52] ; 0x34 11118: e15a0002 cmp sl, r2
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
1111c: e24dd004 sub sp, sp, #4 11120: e1a05001 mov r5, r1 11124: e1a06002 mov r6, r2 11128: e1a04000 mov r4, r0 1112c: e1a07003 mov r7, r3
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
11130: 0a00001e beq 111b0 <fat_file_lseek+0xa0>
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
11134: 35911038 ldrcc r1, [r1, #56] ; 0x38
count = file_cln - fat_fd->map.file_cln;
}
else
{
cur_cln = fat_fd->cln;
11138: 2595101c ldrcs r1, [r5, #28]
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
count = file_cln - fat_fd->map.file_cln;
1113c: 306aa002 rsbcc sl, sl, r2
}
else
{
cur_cln = fat_fd->cln;
11140: 21a0a002 movcs sl, r2
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
11144: 358d1000 strcc r1, [sp]
count = file_cln - fat_fd->map.file_cln;
}
else
{
cur_cln = fat_fd->cln;
11148: 258d1000 strcs r1, [sp]
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
1114c: e35a0000 cmp sl, #0
11150: 0a000010 beq 11198 <fat_file_lseek+0x88>
11154: e3a08000 mov r8, #0 11158: ea000002 b 11168 <fat_file_lseek+0x58> 1115c: e158000a cmp r8, sl 11160: e59d1000 ldr r1, [sp]
11164: 0a00000b beq 11198 <fat_file_lseek+0x88>
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
11168: e1a00004 mov r0, r4 1116c: e1a0200d mov r2, sp 11170: eb001aed bl 17d2c <fat_get_fat_cluster>
if ( rc != RC_OK )
11174: e3500000 cmp r0, #0
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
11178: e2888001 add r8, r8, #1
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
if ( rc != RC_OK )
1117c: 0afffff6 beq 1115c <fat_file_lseek+0x4c>
return rc;
11180: e1a02000 mov r2, r0 <== NOT EXECUTED 11184: e1a03fc0 asr r3, r0, #31 <== NOT EXECUTED
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
}
11188: e1a00002 mov r0, r2
1118c: e1a01003 mov r1, r3
11190: e28dd004 add sp, sp, #4
11194: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
if ( rc != RC_OK )
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
11198: e5856034 str r6, [r5, #52] ; 0x34
fat_fd->map.disk_cln = cur_cln;
1119c: e5851038 str r1, [r5, #56] ; 0x38
*disk_cln = cur_cln;
}
return RC_OK;
111a0: e3a02000 mov r2, #0
/* update cache */
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
111a4: e5871000 str r1, [r7]
}
return RC_OK;
111a8: e3a03000 mov r3, #0 111ac: eafffff5 b 11188 <fat_file_lseek+0x78>
)
{
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
*disk_cln = fat_fd->map.disk_cln;
111b0: e5911038 ldr r1, [r1, #56] ; 0x38
fat_fd->map.file_cln = file_cln;
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
111b4: e3a02000 mov r2, #0 111b8: e3a03000 mov r3, #0
)
{
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
*disk_cln = fat_fd->map.disk_cln;
111bc: e5871000 str r1, [r7] 111c0: eafffff0 b 11188 <fat_file_lseek+0x78>
00011cf4 <fat_file_mark_removed>:
void
fat_file_mark_removed(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
11cf4: e92d4070 push {r4, r5, r6, lr}
11cf8: e5916020 ldr r6, [r1, #32]
fat_cluster_num_to_sector512_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
11cfc: e3560001 cmp r6, #1 11d00: e1a04001 mov r4, r1 11d04: e1a05000 mov r5, r0
11d08: 0a000007 beq 11d2c <fat_file_mark_removed+0x38>
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)) )
11d0c: e3560000 cmp r6, #0
11d10: 0a000017 beq 11d74 <fat_file_mark_removed+0x80>
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
11d14: e5d53005 ldrb r3, [r5, #5] <== NOT EXECUTED 11d18: e5952034 ldr r2, [r5, #52] ; 0x34 <== NOT EXECUTED 11d1c: e2466002 sub r6, r6, #2 <== NOT EXECUTED 11d20: e0826316 add r6, r2, r6, lsl r3 <== NOT EXECUTED
)
{
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
11d24: e5d53003 ldrb r3, [r5, #3] 11d28: e1a06316 lsl r6, r6, r3
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
11d2c: e5943024 ldr r3, [r4, #36] ; 0x24
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
11d30: e1a022a3 lsr r2, r3, #5
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
11d34: e08664a3 add r6, r6, r3, lsr #9
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
11d38: e202200f and r2, r2, #15
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
11d3c: e0826206 add r6, r2, r6, lsl #4 11d40: e1a00004 mov r0, r4
*/
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);
11d44: e2066001 and r6, r6, #1 11d48: eb000b60 bl 14ad0 <_Chain_Extract> 11d4c: e5953070 ldr r3, [r5, #112] ; 0x70 11d50: e1a02086 lsl r2, r6, #1 11d54: e0826006 add r6, r2, r6
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
11d58: e0830106 add r0, r3, r6, lsl #2 11d5c: e1a01004 mov r1, r4 11d60: ebffdd5a bl 92d0 <_Chain_Append>
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
_hash_insert(fs_info->rhash, key, fat_fd->ino, fat_fd);
fat_fd->flags |= FAT_FILE_REMOVED;
11d64: e5d43030 ldrb r3, [r4, #48] ; 0x30 11d68: e3833001 orr r3, r3, #1 11d6c: e5c43030 strb r3, [r4, #48] ; 0x30
}
11d70: e8bd8070 pop {r4, r5, r6, pc}
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)) )
11d74: e5d0300e ldrb r3, [r0, #14] 11d78: e3130003 tst r3, #3
return fs_info->vol.rdir_loc;
11d7c: 15906020 ldrne r6, [r0, #32]
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)) )
11d80: 1affffe7 bne 11d24 <fat_file_mark_removed+0x30>
11d84: eaffffe2 b 11d14 <fat_file_mark_removed+0x20> <== NOT EXECUTED
000111c4 <fat_file_open>:
fat_file_open(
fat_fs_info_t *fs_info,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
111c4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
111c8: e5915000 ldr r5, [r1]
fat_cluster_num_to_sector512_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
111cc: e3550001 cmp r5, #1 111d0: e1a08001 mov r8, r1 111d4: e1a04000 mov r4, r0 111d8: e1a0a002 mov sl, r2
111dc: 0a000007 beq 11200 <fat_file_open+0x3c>
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)) )
111e0: e3550000 cmp r5, #0
111e4: 0a000075 beq 113c0 <fat_file_open+0x1fc>
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
111e8: e5d42005 ldrb r2, [r4, #5] 111ec: e5943034 ldr r3, [r4, #52] ; 0x34 111f0: e2455002 sub r5, r5, #2 111f4: e0835215 add r5, r3, r5, lsl r2
)
{
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
111f8: e5d43003 ldrb r3, [r4, #3] 111fc: e1a05315 lsl r5, r5, r3
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
11200: e5983004 ldr r3, [r8, #4]
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
11204: e1a022a3 lsr r2, r3, #5
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
11208: e08554a3 add r5, r5, r3, lsr #9
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
1120c: e202200f and r2, r2, #15
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
11210: e0825205 add r5, r2, r5, lsl #4
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
11214: e2052001 and r2, r5, #1
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
11218: e1a07082 lsl r7, r2, #1 1121c: e594306c ldr r3, [r4, #108] ; 0x6c 11220: e0877002 add r7, r7, r2 11224: e1a07107 lsl r7, r7, #2 11228: e083c007 add ip, r3, r7
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
1122c: e7933007 ldr r3, [r3, r7]
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 ));
11230: e28cc004 add ip, ip, #4
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
11234: e153000c cmp r3, ip
11238: 0a000018 beq 112a0 <fat_file_open+0xdc>
1123c: e5932020 ldr r2, [r3, #32]
fat_cluster_num_to_sector512_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
11240: e3520001 cmp r2, #1
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
11244: e2420002 sub r0, r2, #2
fat_cluster_num_to_sector512_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
11248: 0a00000a beq 11278 <fat_file_open+0xb4>
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)) )
1124c: e3520000 cmp r2, #0
11250: 1a000003 bne 11264 <fat_file_open+0xa0>
11254: e5d4200e ldrb r2, [r4, #14] 11258: e3120003 tst r2, #3
return fs_info->vol.rdir_loc;
1125c: 15942020 ldrne r2, [r4, #32]
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)) )
11260: 1a000002 bne 11270 <fat_file_open+0xac>
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
11264: e5d41005 ldrb r1, [r4, #5] 11268: e5942034 ldr r2, [r4, #52] ; 0x34 1126c: e0822110 add r2, r2, r0, lsl r1
)
{
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
11270: e5d41003 ldrb r1, [r4, #3] 11274: e1a02112 lsl r2, r2, r1
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
11278: e5931024 ldr r1, [r3, #36] ; 0x24
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
1127c: e1a002a1 lsr r0, r1, #5 11280: e200000f and r0, r0, #15
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
11284: e08214a1 add r1, r2, r1, lsr #9 11288: e0801201 add r1, r0, r1, lsl #4
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(fs_info, &ffd->dir_pos.sname);
if ( (key1) == ck)
1128c: e1550001 cmp r5, r1
11290: 0a000044 beq 113a8 <fat_file_open+0x1e4>
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
11294: e5933000 ldr r3, [r3]
)
{
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) ; )
11298: e153000c cmp r3, ip
1129c: 1affffe6 bne 1123c <fat_file_open+0x78>
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
112a0: e5943070 ldr r3, [r4, #112] ; 0x70 112a4: e083c007 add ip, r3, r7
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
112a8: e7933007 ldr r3, [r3, r7]
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 ));
112ac: e28cc004 add ip, ip, #4
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
112b0: e15c0003 cmp ip, r3
112b4: 1a000003 bne 112c8 <fat_file_open+0x104>
112b8: ea000045 b 113d4 <fat_file_open+0x210>
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
112bc: e5933000 ldr r3, [r3] <== NOT EXECUTED
)
{
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) ; )
112c0: e15c0003 cmp ip, r3 <== NOT EXECUTED 112c4: 0a000042 beq 113d4 <fat_file_open+0x210> <== NOT EXECUTED 112c8: e5932020 ldr r2, [r3, #32] <== NOT EXECUTED
fat_cluster_num_to_sector512_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if (cln == 1)
112cc: e3520001 cmp r2, #1 <== NOT EXECUTED 112d0: 0a00000b beq 11304 <fat_file_open+0x140> <== 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)) )
112d4: e3520000 cmp r2, #0 <== NOT EXECUTED 112d8: 1a000003 bne 112ec <fat_file_open+0x128> <== NOT EXECUTED 112dc: e5d4100e ldrb r1, [r4, #14] <== NOT EXECUTED 112e0: e3110003 tst r1, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
112e4: 15942020 ldrne r2, [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)) )
112e8: 1a000003 bne 112fc <fat_file_open+0x138> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
112ec: e5d41005 ldrb r1, [r4, #5] <== NOT EXECUTED 112f0: e5940034 ldr r0, [r4, #52] ; 0x34 <== NOT EXECUTED 112f4: e2422002 sub r2, r2, #2 <== NOT EXECUTED 112f8: e0802112 add r2, r0, r2, lsl r1 <== NOT EXECUTED
)
{
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(fs_info, cln) <<
112fc: e5d40003 ldrb r0, [r4, #3] <== NOT EXECUTED 11300: e1a02012 lsl r2, r2, r0 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
11304: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED
((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );
11308: e1a002a1 lsr r0, r1, #5 <== NOT EXECUTED 1130c: e200000f and r0, r0, #15 <== NOT EXECUTED
static inline uint32_t
fat_construct_key(
const fat_fs_info_t *fs_info,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(fs_info, pos->cln) +
11310: e08214a1 add r1, r2, r1, lsr #9 <== NOT EXECUTED 11314: e0801201 add r1, r0, r1, lsl #4 <== NOT EXECUTED
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(fs_info, &ffd->dir_pos.sname);
if ( (key1) == ck)
11318: e1550001 cmp r5, r1 <== NOT EXECUTED 1131c: 1affffe6 bne 112bc <fat_file_open+0xf8> <== NOT EXECUTED
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
11320: e3550000 cmp r5, #0 <== NOT EXECUTED 11324: 0a000038 beq 1140c <fat_file_open+0x248> <== NOT EXECUTED 11328: e593200c ldr r2, [r3, #12] <== NOT EXECUTED 1132c: e1550002 cmp r5, r2 <== NOT EXECUTED 11330: 1affffe1 bne 112bc <fat_file_open+0xf8> <== NOT EXECUTED
{
*ret = (void *)the_node;
return 0;
11334: e3a0b000 mov fp, #0 <== NOT EXECUTED
}
/* 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));
11338: e3a00044 mov r0, #68 ; 0x44 1133c: ebffcd48 bl 4864 <malloc>
if ( lfat_fd == NULL )
11340: 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));
11344: e1a06000 mov r6, r0 11348: e58a0000 str r0, [sl]
if ( lfat_fd == NULL )
1134c: 0a000030 beq 11414 <fat_file_open+0x250>
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
11350: e3a01000 mov r1, #0 11354: e3a02044 mov r2, #68 ; 0x44 11358: eb002432 bl 1a428 <memset>
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
1135c: e5d6c030 ldrb ip, [r6, #48] ; 0x30
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
11360: e898000f ldm r8, {r0, r1, r2, r3}
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;
11364: e3cce001 bic lr, ip, #1
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
11368: e3e09000 mvn r9, #0
lfat_fd->dir_pos = *dir_pos;
1136c: e2868020 add r8, r6, #32
if ( rc != RC_OK )
11370: e35b0000 cmp fp, #0
if ( lfat_fd == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
11374: e3a0c001 mov ip, #1 11378: e586c008 str ip, [r6, #8]
lfat_fd->flags &= ~FAT_FILE_REMOVED;
1137c: e5c6e030 strb lr, [r6, #48] ; 0x30
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
11380: e586903c str r9, [r6, #60] ; 0x3c
lfat_fd->dir_pos = *dir_pos;
11384: e888000f stm r8, {r0, r1, r2, r3}
if ( rc != RC_OK )
lfat_fd->ino = key;
11388: 1586500c strne r5, [r6, #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 )
1138c: 0a000012 beq 113dc <fat_file_open+0x218>
*/
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);
11390: e594006c ldr r0, [r4, #108] ; 0x6c
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
11394: e1a01006 mov r1, r6 11398: e0800007 add r0, r0, r7 1139c: ebffdfcb bl 92d0 <_Chain_Append>
/*
* other fields of fat-file descriptor will be initialized on upper
* level
*/
return RC_OK;
113a0: e3a00000 mov r0, #0
}
113a4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
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;
lfat_fd->links_num++;
113a8: e5932008 ldr r2, [r3, #8] 113ac: 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;
113b0: e58a3000 str r3, [sl]
lfat_fd->links_num++;
return rc;
113b4: e3a00000 mov r0, #0
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;
lfat_fd->links_num++;
113b8: e5832008 str r2, [r3, #8]
return rc;
113bc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
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)) )
113c0: e5d0300e ldrb r3, [r0, #14] 113c4: e3130003 tst r3, #3
return fs_info->vol.rdir_loc;
113c8: 15905020 ldrne r5, [r0, #32]
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)) )
113cc: 1affff89 bne 111f8 <fat_file_open+0x34>
113d0: eaffff84 b 111e8 <fat_file_open+0x24> <== NOT EXECUTED
return 0;
}
}
the_node = the_node->next;
}
return -1;
113d4: e3e0b000 mvn fp, #0 113d8: eaffffd6 b 11338 <fat_file_open+0x174>
if ( rc != RC_OK )
lfat_fd->ino = key;
else
{
lfat_fd->ino = fat_get_unique_ino(fs_info);
113dc: e1a00004 mov r0, r4 <== NOT EXECUTED 113e0: eb000681 bl 12dec <fat_get_unique_ino> <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
113e4: e3500000 cmp r0, #0 <== NOT EXECUTED
if ( rc != RC_OK )
lfat_fd->ino = key;
else
{
lfat_fd->ino = fat_get_unique_ino(fs_info);
113e8: e586000c str r0, [r6, #12] <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
113ec: 1affffe7 bne 11390 <fat_file_open+0x1cc> <== NOT EXECUTED
{
free((*fat_fd));
113f0: e59a0000 ldr r0, [sl] <== NOT EXECUTED 113f4: ebffcbd8 bl 435c <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 );
113f8: eb00212d bl 198b4 <__errno> <== NOT EXECUTED
113fc: e3a0300c mov r3, #12 <== NOT EXECUTED
11400: e5803000 str r3, [r0] <== NOT EXECUTED
11404: e1a00009 mov r0, r9 <== NOT EXECUTED
11408: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if ( (key1) == ck)
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
{
*ret = (void *)the_node;
return 0;
1140c: e1a0b005 mov fp, r5 <== NOT EXECUTED 11410: eaffffc8 b 11338 <fat_file_open+0x174> <== NOT EXECUTED
/* 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));
if ( lfat_fd == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
11414: eb002126 bl 198b4 <__errno> <== NOT EXECUTED
11418: e3a0300c mov r3, #12 <== NOT EXECUTED
1141c: e5803000 str r3, [r0] <== NOT EXECUTED
11420: e3e00000 mvn r0, #0 <== NOT EXECUTED
11424: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0001143c <fat_file_read>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
1143c: e92d4ff0 push {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;
11440: e3a07000 mov r7, #0
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
11444: e24dd00c sub sp, sp, #12
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)
11448: e2535000 subs r5, r3, #0
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
1144c: e1a04000 mov r4, r0 11450: e1a0a001 mov sl, r1 11454: e1a06002 mov r6, r2 11458: e59d9030 ldr r9, [sp, #48] ; 0x30
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
1145c: e58d7008 str r7, [sp, #8]
uint32_t byte = 0;
uint32_t c = 0;
/* it couldn't be removed - otherwise cache update will be broken */
if (count == 0)
return cmpltd;
11460: 01a00005 moveq r0, 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)
11464: 0a000044 beq 1157c <fat_file_read+0x140>
/*
* >= because start is offset and computed from 0 and file_size
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
11468: e5913018 ldr r3, [r1, #24] 1146c: e1530002 cmp r3, r2
11470: 9a000043 bls 11584 <fat_file_read+0x148>
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
11474: e1550003 cmp r5, r3
11478: 9a000043 bls 1158c <fat_file_read+0x150>
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
1147c: e0665003 rsb r5, r6, r3
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
11480: e59a3020 ldr r3, [sl, #32] 11484: e3530001 cmp r3, #1
11488: 0a000043 beq 1159c <fat_file_read+0x160>
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
1148c: e5d4b008 ldrb fp, [r4, #8] 11490: e1a0bb36 lsr fp, r6, fp
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
11494: e1a00004 mov r0, r4 11498: e1a0100a mov r1, sl 1149c: e1a0200b mov r2, fp 114a0: e28d3008 add r3, sp, #8
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
114a4: e1d480b6 ldrh r8, [r4, #6]
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
114a8: ebffff18 bl 11110 <fat_file_lseek>
if (rc != RC_OK)
114ac: e2507000 subs r7, r0, #0
114b0: 1a000033 bne 11584 <fat_file_read+0x148>
return rc;
while (count > 0)
114b4: e3550000 cmp r5, #0
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
114b8: e2488001 sub r8, r8, #1 114bc: e0068008 and r8, r6, r8
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
114c0: 01a00005 moveq r0, r5
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
114c4: e58d8004 str r8, [sp, #4]
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
114c8: 01a07000 moveq r7, r0 114cc: 01a08000 moveq r8, r0
114d0: 0a00004a beq 11600 <fat_file_read+0x1c4>
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
114d4: e5d48002 ldrb r8, [r4, #2] 114d8: e1d420b0 ldrh r2, [r4]
return rc;
while (count > 0)
114dc: e59dc004 ldr ip, [sp, #4] 114e0: ea000003 b 114f4 <fat_file_read+0xb8> 114e4: e0555006 subs r5, r5, r6
114e8: 0a000043 beq 115fc <fat_file_read+0x1c0>
114ec: e5d48002 ldrb r8, [r4, #2] 114f0: e1d420b0 ldrh r2, [r4]
{
c = MIN(count, (fs_info->vol.bpc - ofs));
114f4: e1d460b6 ldrh r6, [r4, #6]
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
114f8: e59d1008 ldr r1, [sp, #8]
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
114fc: e06c6006 rsb r6, ip, r6 11500: e1560005 cmp r6, r5 11504: 21a06005 movcs r6, r5 11508: e3510000 cmp r1, #0
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
1150c: e2411002 sub r1, r1, #2
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)) )
11510: 1a000003 bne 11524 <fat_file_read+0xe8>
11514: e5d4300e ldrb r3, [r4, #14] <== NOT EXECUTED 11518: e3130003 tst r3, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
1151c: 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)) )
11520: 1a000002 bne 11530 <fat_file_read+0xf4> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
11524: e5d40005 ldrb r0, [r4, #5] 11528: e5943034 ldr r3, [r4, #52] ; 0x34 1152c: e0831011 add r1, r3, r1, lsl r0
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);
11530: e2422001 sub r2, r2, #1
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
11534: e089e007 add lr, r9, r7 11538: e002200c and r2, r2, ip 1153c: e1a03006 mov r3, r6 11540: e1a00004 mov r0, r4 11544: e081183c add r1, r1, ip, lsr r8 11548: e58de000 str lr, [sp] 1154c: eb0002d2 bl 1209c <_fat_block_read>
if ( ret < 0 )
11550: e3500000 cmp r0, #0
return -1;
count -= c;
cmpltd += c;
11554: e0877006 add r7, r7, r6
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
11558: e28d2008 add r2, sp, #8 1155c: e1a00004 mov r0, r4
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);
if ( ret < 0 )
11560: ba00002e blt 11620 <fat_file_read+0x1e4>
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
11564: e59d8008 ldr r8, [sp, #8]
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
11568: e1a01008 mov r1, r8 1156c: eb0019ee bl 17d2c <fat_get_fat_cluster>
if ( rc != RC_OK )
11570: e250c000 subs ip, r0, #0
11574: 0affffda beq 114e4 <fat_file_read+0xa8>
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
11578: e1a0000c mov r0, ip <== 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;
}
1157c: e28dd00c add sp, sp, #12
11580: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
11584: e1a00007 mov r0, r7 11588: eafffffb b 1157c <fat_file_read+0x140>
*/
if ( start >= fat_fd->fat_file_size )
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
(start > fat_fd->fat_file_size - count))
1158c: 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) ||
11590: e1560002 cmp r6, r2
11594: 9affffb9 bls 11480 <fat_file_read+0x44>
11598: eaffffb7 b 1147c <fat_file_read+0x40>
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
1159c: e59a3024 ldr r3, [sl, #36] ; 0x24 115a0: e3530000 cmp r3, #0
115a4: 1affffb8 bne 1148c <fat_file_read+0x50>
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
115a8: 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)) &&
115ac: e3130003 tst r3, #3
115b0: 0affffb5 beq 1148c <fat_file_read+0x50>
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
115b4: e59a301c ldr r3, [sl, #28]
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)) )
115b8: e3530000 cmp r3, #0
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
115bc: 15d41005 ldrbne r1, [r4, #5] 115c0: 15942034 ldrne r2, [r4, #52] ; 0x34 115c4: 12433002 subne r3, r3, #2 115c8: 10821113 addne r1, r2, r3, lsl r1
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
115cc: 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);
115d0: e5d43002 ldrb r3, [r4, #2]
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
115d4: 05941020 ldreq r1, [r4, #32]
byte = start & (fs_info->vol.bps - 1);
115d8: e2422001 sub r2, r2, #1
ret = _fat_block_read(fs_info, sec, byte, count, buf);
115dc: e0811336 add r1, r1, r6, lsr r3 115e0: e1a00004 mov r0, r4 115e4: e0062002 and r2, r6, r2 115e8: e1a03005 mov r3, r5 115ec: e58d9000 str r9, [sp] 115f0: eb0002a9 bl 1209c <_fat_block_read>
if ( ret < 0 )
return -1;
115f4: e1800fc0 orr r0, r0, r0, asr #31 115f8: eaffffdf b 1157c <fat_file_read+0x140>
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
if ( rc != RC_OK )
return rc;
ofs = 0;
115fc: e1a00007 mov r0, r7
}
/* 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);
11600: e59d2004 ldr r2, [sp, #4] 11604: e5d43008 ldrb r3, [r4, #8] 11608: e2426001 sub r6, r2, #1 1160c: e0867007 add r7, r6, r7
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
11610: e08bb337 add fp, fp, r7, lsr r3
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
11614: e58a8038 str r8, [sl, #56] ; 0x38
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
11618: e58ab034 str fp, [sl, #52] ; 0x34
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
1161c: eaffffd6 b 1157c <fat_file_read+0x140>
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;
11620: e3e00000 mvn r0, #0 <== NOT EXECUTED 11624: eaffffd4 b 1157c <fat_file_read+0x140> <== NOT EXECUTED
00011d88 <fat_file_size>:
int
fat_file_size(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
11d88: e92d4070 push {r4, r5, r6, lr}
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
11d8c: e5913020 ldr r3, [r1, #32]
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
11d90: e591601c ldr r6, [r1, #28]
int
fat_file_size(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
11d94: e24dd004 sub sp, sp, #4
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
11d98: e3530001 cmp r3, #1
int
fat_file_size(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
11d9c: e1a05001 mov r5, r1 11da0: e1a04000 mov r4, r0
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
11da4: e58d6000 str r6, [sp]
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
11da8: 0a00001e beq 11e28 <fat_file_size+0xa0>
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
11dac: e5942010 ldr r2, [r4, #16] 11db0: e5941014 ldr r1, [r4, #20] 11db4: e0062002 and r2, r6, r2
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
return rc;
}
fat_fd->fat_file_size = 0;
11db8: e3a03000 mov r3, #0
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
11dbc: e1510002 cmp r1, r2
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
return rc;
}
fat_fd->fat_file_size = 0;
11dc0: e5853018 str r3, [r5, #24]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
11dc4: 8a00000b bhi 11df8 <fat_file_size+0x70>
11dc8: ea000012 b 11e18 <fat_file_size+0x90> <== NOT EXECUTED
11dcc: e5940010 ldr r0, [r4, #16] 11dd0: e59d3000 ldr r3, [sp]
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
11dd4: e1d420b6 ldrh r2, [r4, #6] 11dd8: e595c018 ldr ip, [r5, #24]
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
11ddc: e5941014 ldr r1, [r4, #20] 11de0: e0030000 and r0, r3, r0
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
11de4: e08c2002 add r2, ip, r2
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
11de8: e1500001 cmp r0, r1
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
11dec: e5852018 str r2, [r5, #24]
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
11df0: 2a000009 bcs 11e1c <fat_file_size+0x94>
11df4: e1a06003 mov r6, r3 <== NOT EXECUTED
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
11df8: e1a01006 mov r1, r6 11dfc: e1a00004 mov r0, r4 11e00: e1a0200d mov r2, sp 11e04: eb0017c8 bl 17d2c <fat_get_fat_cluster>
if ( rc != RC_OK )
11e08: e3500000 cmp r0, #0
11e0c: 0affffee beq 11dcc <fat_file_size+0x44>
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
return rc;
}
11e10: e28dd004 add sp, sp, #4
11e14: e8bd8070 pop {r4, r5, r6, pc}
fat_file_fd_t *fat_fd
)
{
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
11e18: e1a06003 mov r6, r3 <== NOT EXECUTED
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
11e1c: e585603c str r6, [r5, #60] ; 0x3c
return rc;
11e20: e3a00000 mov r0, #0 11e24: eafffff9 b 11e10 <fat_file_size+0x88>
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
11e28: e5910024 ldr r0, [r1, #36] ; 0x24 11e2c: e3500000 cmp r0, #0
11e30: 1affffdd bne 11dac <fat_file_size+0x24>
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
11e34: e5d4300e ldrb r3, [r4, #14]
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
11e38: e3130003 tst r3, #3
11e3c: 0affffda beq 11dac <fat_file_size+0x24>
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
11e40: e594302c ldr r3, [r4, #44] ; 0x2c <== NOT EXECUTED 11e44: e5813018 str r3, [r1, #24] <== NOT EXECUTED
return rc;
11e48: eafffff0 b 11e10 <fat_file_size+0x88> <== NOT EXECUTED
00011628 <fat_file_truncate>:
fat_file_truncate(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
11628: e92d40f0 push {r4, r5, r6, r7, lr}
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
1162c: e5913018 ldr r3, [r1, #24]
fat_file_truncate(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
11630: e24dd008 sub sp, sp, #8
int rc = RC_OK;
uint32_t cur_cln = 0;
11634: e3a0c000 mov ip, #0
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
11638: e3e06000 mvn r6, #0
if ( new_length >= fat_fd->fat_file_size )
1163c: e1530002 cmp r3, r2
fat_file_truncate(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
11640: e1a05001 mov r5, r1 11644: e1a04000 mov r4, r0
int rc = RC_OK;
uint32_t cur_cln = 0;
11648: e58dc000 str ip, [sp]
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
1164c: e58d6004 str r6, [sp, #4]
if ( new_length >= fat_fd->fat_file_size )
11650: 9a000029 bls 116fc <fat_file_truncate+0xd4>
return rc;
assert(fat_fd->fat_file_size);
11654: e153000c cmp r3, ip
11658: 0a00002a beq 11708 <fat_file_truncate+0xe0>
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
1165c: e1d060b6 ldrh r6, [r0, #6] 11660: e5d07008 ldrb r7, [r0, #8] 11664: e2466001 sub r6, r6, #1 11668: e0866002 add r6, r6, r2 1166c: e1a06736 lsr r6, r6, r7
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
11670: e1530716 cmp r3, r6, lsl r7
11674: 9a000020 bls 116fc <fat_file_truncate+0xd4>
return RC_OK;
if (cl_start != 0)
11678: e3560000 cmp r6, #0
1167c: 0a000004 beq 11694 <fat_file_truncate+0x6c>
{
rc = fat_file_lseek(fs_info, fat_fd, cl_start - 1, &new_last_cln);
11680: e2462001 sub r2, r6, #1 11684: e28d3004 add r3, sp, #4 11688: ebfffea0 bl 11110 <fat_file_lseek>
if (rc != RC_OK)
1168c: e3500000 cmp r0, #0
11690: 1a00001a bne 11700 <fat_file_truncate+0xd8>
return rc;
}
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
11694: e1a00004 mov r0, r4 11698: e1a01005 mov r1, r5 1169c: e1a02006 mov r2, r6 116a0: e1a0300d mov r3, sp 116a4: ebfffe99 bl 11110 <fat_file_lseek>
if (rc != RC_OK)
116a8: e3500000 cmp r0, #0
116ac: 1a000013 bne 11700 <fat_file_truncate+0xd8>
return rc;
rc = fat_free_fat_clusters_chain(fs_info, cur_cln);
116b0: e1a00004 mov r0, r4 116b4: e59d1000 ldr r1, [sp] 116b8: eb001a79 bl 180a4 <fat_free_fat_clusters_chain>
if (rc != RC_OK)
116bc: e3500000 cmp r0, #0
116c0: 1a00000e bne 11700 <fat_file_truncate+0xd8>
return rc;
if (cl_start != 0)
116c4: e3560000 cmp r6, #0
116c8: 0a00000c beq 11700 <fat_file_truncate+0xd8>
{
rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
116cc: e1a00004 mov r0, r4 116d0: e59d1004 ldr r1, [sp, #4] 116d4: e3e02000 mvn r2, #0 116d8: eb0019e9 bl 17e84 <fat_set_fat_cluster>
if ( rc != RC_OK )
116dc: e3500000 cmp r0, #0
116e0: 1a000006 bne 11700 <fat_file_truncate+0xd8>
return rc;
fat_fd->map.file_cln = cl_start - 1;
fat_fd->map.disk_cln = new_last_cln;
116e4: e59d3004 ldr r3, [sp, #4]
if (cl_start != 0)
{
rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
if ( rc != RC_OK )
return rc;
fat_fd->map.file_cln = cl_start - 1;
116e8: e2466001 sub r6, r6, #1 116ec: e5856034 str r6, [r5, #52] ; 0x34
fat_fd->map.disk_cln = new_last_cln;
116f0: e5853038 str r3, [r5, #56] ; 0x38
fat_fd->map.last_cln = new_last_cln;
116f4: e585303c str r3, [r5, #60] ; 0x3c 116f8: ea000000 b 11700 <fat_file_truncate+0xd8>
assert(fat_fd->fat_file_size);
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
return RC_OK;
116fc: e1a0000c mov r0, ip
fat_fd->map.file_cln = cl_start - 1;
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
}
return RC_OK;
}
11700: e28dd008 add sp, sp, #8
11704: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( new_length >= fat_fd->fat_file_size )
return rc;
assert(fat_fd->fat_file_size);
11708: e59f000c ldr r0, [pc, #12] ; 1171c <fat_file_truncate+0xf4><== NOT EXECUTED 1170c: e59f100c ldr r1, [pc, #12] ; 11720 <fat_file_truncate+0xf8><== NOT EXECUTED 11710: e59f200c ldr r2, [pc, #12] ; 11724 <fat_file_truncate+0xfc><== NOT EXECUTED 11714: e59f300c ldr r3, [pc, #12] ; 11728 <fat_file_truncate+0x100><== NOT EXECUTED 11718: eb00081d bl 13794 <__assert_func> <== NOT EXECUTED
00011ad4 <fat_file_write>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
11ad4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
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 )
11ad8: e3530000 cmp r3, #0
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
11adc: e24dd020 sub sp, sp, #32 11ae0: e1a07002 mov r7, r2
int rc = RC_OK;
ssize_t ret;
uint32_t cmpltd = 0;
uint32_t byte;
uint32_t c = 0;
11ae4: e3a02000 mov r2, #0
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
11ae8: e1a06000 mov r6, r0
int rc = RC_OK;
ssize_t ret;
uint32_t cmpltd = 0;
uint32_t byte;
uint32_t c = 0;
11aec: e58d2018 str r2, [sp, #24]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
11af0: e1a05001 mov r5, 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;
11af4: e5912018 ldr r2, [r1, #24]
uint32_t file_cln_initial = fat_fd->map.file_cln;
11af8: e5919034 ldr r9, [r1, #52] ; 0x34
uint32_t cln;
if ( count == 0 )
return cmpltd;
11afc: 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 )
11b00: 0a000056 beq 11c60 <fat_file_write+0x18c>
return cmpltd;
if (start >= fat_fd->size_limit)
11b04: e5914014 ldr r4, [r1, #20] 11b08: e1570004 cmp r7, r4
11b0c: 2a00004f bcs 11c50 <fat_file_write+0x17c>
rtems_set_errno_and_return_minus_one(EFBIG);
if (count > fat_fd->size_limit - start)
11b10: e0674004 rsb r4, r7, r4
if ( count == 0 )
return cmpltd;
if (start >= fat_fd->size_limit)
rtems_set_errno_and_return_minus_one(EFBIG);
11b14: e1540003 cmp r4, r3 11b18: 21a04003 movcs r4, 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);
11b1c: e084a007 add sl, r4, r7 11b20: e1520007 cmp r2, r7 11b24: 23a02000 movcs r2, #0 11b28: 33a02001 movcc r2, #1 11b2c: e28dc018 add ip, sp, #24 11b30: e1a0300a mov r3, sl 11b34: e58dc000 str ip, [sp] 11b38: ebffff55 bl 11894 <fat_file_extend>
if (RC_OK == rc)
11b3c: e3500000 cmp r0, #0
11b40: 1a000046 bne 11c60 <fat_file_write+0x18c>
{
/*
* check whether there was enough room on device to locate
* file of 'start + count' bytes
*/
if (c != (start + count))
11b44: e59d3018 ldr r3, [sp, #24] 11b48: e15a0003 cmp sl, r3
count = c - start;
11b4c: 10674003 rsbne r4, r7, 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));
11b50: e5953020 ldr r3, [r5, #32] 11b54: e3530001 cmp r3, #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))
11b58: e5d6300e ldrb r3, [r6, #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));
11b5c: 0a000050 beq 11ca4 <fat_file_write+0x1d0>
{
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;
11b60: e5d6a008 ldrb sl, [r6, #8] 11b64: e1a03a37 lsr r3, r7, sl
const uint8_t *buf,
const uint32_t file_cln_initial)
{
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
11b68: e28de020 add lr, sp, #32
uint32_t save_cln = 0; /* FIXME: This might be incorrect, cf. below */
uint32_t start_cln = start >> fs_info->vol.bpc_log2;
11b6c: e58d3010 str r3, [sp, #16]
const uint8_t *buf,
const uint32_t file_cln_initial)
{
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
11b70: e3a03000 mov r3, #0 11b74: e52e3004 str r3, [lr, #-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);
11b78: e1a00006 mov r0, r6 11b7c: e1a01005 mov r1, r5 11b80: e59d2010 ldr r2, [sp, #16] 11b84: e1a0300e mov r3, lr
const uint8_t *buf,
const uint32_t file_cln_initial)
{
int rc = RC_OK;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
11b88: e58de008 str lr, [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);
11b8c: ebfffd5f bl 11110 <fat_file_lseek>
if (RC_OK == rc)
11b90: e3500000 cmp r0, #0
11b94: 1a00003e bne 11c94 <fat_file_write+0x1c0>
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);
11b98: e59d1010 ldr r1, [sp, #16] 11b9c: e0477a11 sub r7, r7, r1, lsl sl
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;
11ba0: e595301c ldr r3, [r5, #28] 11ba4: e59da01c ldr sl, [sp, #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);
11ba8: e58d7014 str r7, [sp, #20]
const uint32_t file_cln_initial)
{
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 */
11bac: e58d000c str r0, [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;
11bb0: e063a00a rsb sl, r3, sl
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;
11bb4: 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;
11bb8: e1a08000 mov r8, r0
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)
11bbc: e2943000 adds r3, r4, #0 11bc0: 13a03001 movne r3, #1 11bc4: e3500000 cmp r0, #0 11bc8: 13a03000 movne r3, #0 11bcc: e3530000 cmp r3, #0
11bd0: 0a000024 beq 11c68 <fat_file_write+0x194>
&& (bytes_to_write > 0))
{
c = MIN(bytes_to_write, (fs_info->vol.bpc - ofs_cln));
11bd4: e1d630b6 ldrh r3, [r6, #6] 11bd8: e0673003 rsb r3, r7, r3
if (file_cln_initial < file_cln_cnt)
overwrite_cluster = true;
ret = fat_cluster_write(fs_info,
11bdc: e59d1044 ldr r1, [sp, #68] ; 0x44
{
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));
11be0: e1530004 cmp r3, r4 11be4: 21a03004 movcs r3, r4
if (file_cln_initial < file_cln_cnt)
11be8: e159000a cmp r9, sl 11bec: 33a0b001 movcc fp, #1
overwrite_cluster = true;
ret = fat_cluster_write(fs_info,
11bf0: e081c008 add ip, r1, r8
&& (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;
11bf4: e1a0e00b mov lr, fp
ret = fat_cluster_write(fs_info,
11bf8: e1a02007 mov r2, r7
11bfc: e59d101c ldr r1, [sp, #28]
11c00: e1a00006 mov r0, r6
11c04: e88d5000 stm sp, {ip, lr}
11c08: eb0001c9 bl 12334 <fat_cluster_write>
cur_cln,
ofs_cln,
c,
&buf[cmpltd],
overwrite_cluster);
if (0 > ret)
11c0c: e3500000 cmp r0, #0 11c10: b3e00000 mvnlt r0, #0
11c14: baffffe8 blt 11bbc <fat_file_write+0xe8>
if (RC_OK == rc)
{
++file_cln_cnt;
bytes_to_write -= ret;
cmpltd += ret;
save_cln = cur_cln;
11c18: e59d201c ldr r2, [sp, #28]
if (0 < bytes_to_write)
11c1c: e0544000 subs r4, r4, r0
if (RC_OK == rc)
{
++file_cln_cnt;
bytes_to_write -= ret;
cmpltd += ret;
11c20: e0888000 add r8, r8, r0
save_cln = cur_cln;
11c24: e58d200c str r2, [sp, #12]
if (0 > ret)
rc = -1;
if (RC_OK == rc)
{
++file_cln_cnt;
11c28: e28aa001 add sl, sl, #1
bytes_to_write -= ret;
cmpltd += ret;
save_cln = cur_cln;
if (0 < bytes_to_write)
11c2c: 01a00004 moveq r0, r4
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
ofs_cln = 0;
11c30: 01a07004 moveq r7, r4
{
++file_cln_cnt;
bytes_to_write -= ret;
cmpltd += ret;
save_cln = cur_cln;
if (0 < bytes_to_write)
11c34: 0affffe0 beq 11bbc <fat_file_write+0xe8>
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
11c38: e1a01002 mov r1, r2 11c3c: e1a00006 mov r0, r6 11c40: e59d2008 ldr r2, [sp, #8] 11c44: eb001838 bl 17d2c <fat_get_fat_cluster>
ofs_cln = 0;
11c48: e3a07000 mov r7, #0 11c4c: eaffffda b 11bbc <fat_file_write+0xe8>
if ( count == 0 )
return cmpltd;
if (start >= fat_fd->size_limit)
rtems_set_errno_and_return_minus_one(EFBIG);
11c50: eb001f17 bl 198b4 <__errno> <== NOT EXECUTED 11c54: e3a0301b mov r3, #27 <== NOT EXECUTED 11c58: e5803000 str r3, [r0] <== NOT EXECUTED 11c5c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
if (RC_OK != rc)
return rc;
else
return cmpltd;
}
11c60: e28dd020 add sp, sp, #32
11c64: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
}
/* 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);
11c68: e59d1014 ldr r1, [sp, #20] 11c6c: e5d62008 ldrb r2, [r6, #8] 11c70: e2413001 sub r3, r1, #1
}
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
11c74: e59d1010 ldr r1, [sp, #16]
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
11c78: e0833008 add r3, r3, r8
}
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
11c7c: e0813233 add r3, r1, r3, lsr r2
((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
11c80: e59d200c ldr r2, [sp, #12]
}
if (RC_OK != rc)
return rc;
else
return cmpltd;
11c84: e3500000 cmp r0, #0
/* 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);
fat_fd->map.disk_cln = save_cln;
11c88: e5852038 str r2, [r5, #56] ; 0x38
}
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = start_cln +
11c8c: e5853034 str r3, [r5, #52] ; 0x34
}
if (RC_OK != rc)
return rc;
else
return cmpltd;
11c90: 01a00008 moveq r0, r8
fat_fd,
start,
count,
buf,
file_cln_initial);
if (0 > ret)
11c94: e3500000 cmp r0, #0
11c98: aafffff0 bge 11c60 <fat_file_write+0x18c>
rc = -1;
11c9c: e3e00000 mvn r0, #0 <== NOT EXECUTED 11ca0: eaffffee b 11c60 <fat_file_write+0x18c> <== NOT EXECUTED
*/
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));
11ca4: e595c024 ldr ip, [r5, #36] ; 0x24 11ca8: e35c0000 cmp ip, #0
11cac: 1affffab bne 11b60 <fat_file_write+0x8c>
11cb0: e3130003 tst r3, #3
11cb4: 0affffa9 beq 11b60 <fat_file_write+0x8c>
/* 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);
11cb8: e1d620b6 ldrh r2, [r6, #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;
11cbc: e595301c ldr r3, [r5, #28]
cln += (start >> fs_info->vol.bpc_log2);
11cc0: e5d61008 ldrb r1, [r6, #8]
byte = start & (fs_info->vol.bpc -1);
ret = fat_cluster_write(fs_info,
11cc4: e59de044 ldr lr, [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);
11cc8: e2422001 sub r2, r2, #1
ret = fat_cluster_write(fs_info,
11ccc: e0831137 add r1, r3, r7, lsr r1 11cd0: e1a00006 mov r0, r6 11cd4: e0072002 and r2, r7, r2 11cd8: e1a03004 mov r3, r4 11cdc: e58de000 str lr, [sp] 11ce0: e58dc004 str ip, [sp, #4] 11ce4: eb000192 bl 12334 <fat_cluster_write>
cln,
byte,
count,
buf,
false);
if (0 > ret)
11ce8: e3500000 cmp r0, #0
11cec: aaffffdb bge 11c60 <fat_file_write+0x18c>
11cf0: eaffffe9 b 11c9c <fat_file_write+0x1c8> <== NOT EXECUTED
000180a4 <fat_free_fat_clusters_chain>:
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
180a4: e92d41f0 push {r4, r5, r6, r7, r8, lr}
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)
180a8: e5903010 ldr r3, [r0, #16] 180ac: e5902014 ldr r2, [r0, #20] 180b0: e0013003 and r3, r1, r3
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
180b4: e24dd004 sub sp, sp, #4
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
180b8: e3a06000 mov r6, #0
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
180bc: e1530002 cmp r3, r2
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
180c0: e1a04000 mov r4, r0 180c4: e1a08001 mov r8, r1
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
180c8: e58d6000 str r6, [sp]
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
180cc: 2a00001c bcs 18144 <fat_free_fat_clusters_chain+0xa0>
180d0: e1a05001 mov r5, r1 180d4: e1a07006 mov r7, r6 180d8: ea000009 b 18104 <fat_free_fat_clusters_chain+0x60>
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
180dc: ebffff68 bl 17e84 <fat_set_fat_cluster>
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)
180e0: e2842010 add r2, r4, #16
180e4: e892000c ldm r2, {r2, r3}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
if ( rc != RC_OK )
rc1 = rc;
freed_cls_cnt++;
cur_cln = next_cln;
180e8: e59d5000 ldr r5, [sp]
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
if ( rc != RC_OK )
180ec: e3500000 cmp r0, #0
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)
180f0: e0052002 and r2, r5, r2
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
if ( rc != RC_OK )
180f4: 11a07000 movne r7, r0
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)
180f8: e1520003 cmp r2, r3
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
if ( rc != RC_OK )
rc1 = rc;
freed_cls_cnt++;
180fc: e2866001 add r6, r6, #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)
18100: 2a000010 bcs 18148 <fat_free_fat_clusters_chain+0xa4>
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
18104: e1a01005 mov r1, r5 18108: e1a0200d mov r2, sp 1810c: e1a00004 mov r0, r4 18110: ebffff05 bl 17d2c <fat_get_fat_cluster>
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
18114: e1a01005 mov r1, r5
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
if ( rc != RC_OK )
18118: e2505000 subs r5, r0, #0
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
1811c: e1a02005 mov r2, r5 18120: e1a00004 mov r0, r4
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
if ( rc != RC_OK )
18124: 0affffec beq 180dc <fat_free_fat_clusters_chain+0x38>
{
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
18128: e5943044 ldr r3, [r4, #68] ; 0x44 <== NOT EXECUTED 1812c: e3730001 cmn r3, #1 <== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
18130: 10863003 addne r3, r6, r3 <== NOT EXECUTED 18134: 15843044 strne r3, [r4, #68] ; 0x44 <== NOT EXECUTED
fat_buf_release(fs_info);
18138: e1a00004 mov r0, r4 <== NOT EXECUTED 1813c: ebffe742 bl 11e4c <fat_buf_release> <== NOT EXECUTED
return rc;
18140: ea000008 b 18168 <fat_free_fat_clusters_chain+0xc4> <== NOT EXECUTED
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
18144: e1a07006 mov r7, r6 <== NOT EXECUTED
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
18148: e5943044 ldr r3, [r4, #68] ; 0x44 1814c: e3730001 cmn r3, #1
fs_info->vol.free_cls += freed_cls_cnt;
18150: 10863003 addne r3, r6, r3
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
18154: e584804c str r8, [r4, #76] ; 0x4c
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
fs_info->vol.free_cls += freed_cls_cnt;
18158: 15843044 strne r3, [r4, #68] ; 0x44
fat_buf_release(fs_info);
1815c: e1a00004 mov r0, r4 18160: ebffe739 bl 11e4c <fat_buf_release> 18164: e1a05007 mov r5, r7
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
18168: e1a00005 mov r0, r5
1816c: e28dd004 add sp, sp, #4
18170: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
00012ec8 <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);
12ec8: e5902080 ldr r2, [r0, #128] ; 0x80 <== NOT EXECUTED 12ecc: e5903074 ldr r3, [r0, #116] ; 0x74 <== NOT EXECUTED 12ed0: e0622001 rsb r2, r2, r1 <== NOT EXECUTED 12ed4: e7d301a2 ldrb r0, [r3, r2, lsr #3] <== NOT EXECUTED 12ed8: e2021007 and r1, r2, #7 <== NOT EXECUTED 12edc: e3a0c001 mov ip, #1 <== NOT EXECUTED 12ee0: e1c0111c bic r1, r0, ip, lsl r1 <== NOT EXECUTED 12ee4: e7c311a2 strb r1, [r3, r2, lsr #3] <== NOT EXECUTED
}
12ee8: e12fff1e bx lr <== NOT EXECUTED
00017d2c <fat_get_fat_cluster>:
fat_get_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t *ret_val
)
{
17d2c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
uint8_t *sec_buf;
uint32_t sec = 0;
uint32_t ofs = 0;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
17d30: e3510001 cmp r1, #1
fat_get_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t *ret_val
)
{
17d34: e24dd004 sub sp, sp, #4 17d38: e1a05001 mov r5, r1 17d3c: e1a04000 mov r4, r0 17d40: e1a09002 mov r9, 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)) )
17d44: 9a00001d bls 17dc0 <fat_get_fat_cluster+0x94>
17d48: e5903038 ldr r3, [r0, #56] ; 0x38 17d4c: e2833001 add r3, r3, #1 17d50: e1510003 cmp r1, r3
17d54: 8a000019 bhi 17dc0 <fat_get_fat_cluster+0x94>
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
17d58: e5d0300e ldrb r3, [r0, #14] 17d5c: e3130001 tst r3, #1 17d60: e5d0a002 ldrb sl, [r0, #2]
17d64: 1a00001c bne 17ddc <fat_get_fat_cluster+0xb0>
17d68: e3130002 tst r3, #2 17d6c: e5903058 ldr r3, [r0, #88] ; 0x58 17d70: 11a08081 lslne r8, r1, #1 17d74: 01a08101 lsleq r8, r1, #2 17d78: e083aa38 add sl, r3, r8, lsr sl
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
17d7c: e1a00004 mov r0, r4 17d80: e1a0100a mov r1, sl 17d84: e3a02001 mov r2, #1 17d88: 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);
17d8c: e1d470b0 ldrh r7, [r4]
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
17d90: ebffe896 bl 11ff0 <fat_buf_access>
if (rc != RC_OK)
17d94: e2506000 subs r6, r0, #0
17d98: 1a00000c bne 17dd0 <fat_get_fat_cluster+0xa4>
return rc;
switch ( fs_info->vol.type )
17d9c: e5d4200e ldrb r2, [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);
17da0: 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 )
17da4: 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);
17da8: e0088007 and r8, r8, 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 )
17dac: 0a00000e beq 17dec <fat_get_fat_cluster+0xc0>
17db0: e3520004 cmp r2, #4
17db4: 0a000021 beq 17e40 <fat_get_fat_cluster+0x114>
17db8: e3520001 cmp r2, #1
17dbc: 0a00000e beq 17dfc <fat_get_fat_cluster+0xd0>
*ret_val = *((uint32_t *)(sec_buf + ofs));
*ret_val = CF_LE_L(*ret_val);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
17dc0: eb0006bb bl 198b4 <__errno> <== NOT EXECUTED 17dc4: e3a03005 mov r3, #5 <== NOT EXECUTED 17dc8: e5803000 str r3, [r0] <== NOT EXECUTED 17dcc: e3e06000 mvn r6, #0 <== NOT EXECUTED
break;
}
return RC_OK;
}
17dd0: e1a00006 mov r0, r6
17dd4: e28dd004 add sp, sp, #4
17dd8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
/* 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) +
17ddc: e5903058 ldr r3, [r0, #88] ; 0x58 17de0: e08180a1 add r8, r1, r1, lsr #1 17de4: e083aa38 add sl, r3, r8, lsr sl 17de8: eaffffe3 b 17d7c <fat_get_fat_cluster+0x50>
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(sec_buf + ofs));
17dec: e59d3000 ldr r3, [sp] 17df0: e19330b8 ldrh r3, [r3, r8] 17df4: e5893000 str r3, [r9]
*ret_val = CF_LE_W(*ret_val);
break;
17df8: eafffff4 b 17dd0 <fat_get_fat_cluster+0xa4>
/*
* 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) )
17dfc: e1d400b0 ldrh r0, [r4]
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*(sec_buf + ofs));
17e00: e59d1000 ldr r1, [sp]
if ( ofs == (fs_info->vol.bps - 1) )
17e04: e2400001 sub r0, r0, #1
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*(sec_buf + ofs));
17e08: e7d13008 ldrb r3, [r1, r8]
if ( ofs == (fs_info->vol.bps - 1) )
17e0c: e1500008 cmp r0, r8
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*(sec_buf + ofs));
17e10: e5893000 str r3, [r9]
if ( ofs == (fs_info->vol.bps - 1) )
17e14: 0a00000d beq 17e50 <fat_get_fat_cluster+0x124>
*ret_val |= *sec_buf << 8;
}
else
{
*ret_val |= *(sec_buf + ofs + 1) << 8;
17e18: e0818008 add r8, r1, r8 17e1c: e5d82001 ldrb r2, [r8, #1] 17e20: e1833402 orr r3, r3, r2, lsl #8 17e24: e5893000 str r3, [r9]
}
if ( FAT_CLUSTER_IS_ODD(cln) )
17e28: e3150001 tst r5, #1
*ret_val = (*ret_val) >> FAT12_SHIFT;
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
17e2c: 01a03a03 lsleq r3, r3, #20
{
*ret_val |= *(sec_buf + ofs + 1) << 8;
}
if ( FAT_CLUSTER_IS_ODD(cln) )
*ret_val = (*ret_val) >> FAT12_SHIFT;
17e30: 11a03223 lsrne r3, r3, #4
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
17e34: 01a03a23 lsreq r3, r3, #20 17e38: e5893000 str r3, [r9] 17e3c: eaffffe3 b 17dd0 <fat_get_fat_cluster+0xa4>
*ret_val = *((uint16_t *)(sec_buf + ofs));
*ret_val = CF_LE_W(*ret_val);
break;
case FAT_FAT32:
*ret_val = *((uint32_t *)(sec_buf + ofs));
17e40: e59d3000 ldr r3, [sp] 17e44: e7933008 ldr r3, [r3, r8] 17e48: e5893000 str r3, [r9]
*ret_val = CF_LE_L(*ret_val);
break;
17e4c: eaffffdf b 17dd0 <fat_get_fat_cluster+0xa4>
* align problems for some architectures
*/
*ret_val = (*(sec_buf + ofs));
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
17e50: e1a00004 mov r0, r4 <== NOT EXECUTED 17e54: e28a1001 add r1, sl, #1 <== NOT EXECUTED 17e58: e1a0300d mov r3, sp <== NOT EXECUTED 17e5c: ebffe863 bl 11ff0 <fat_buf_access> <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
17e60: e3500000 cmp r0, #0 <== NOT EXECUTED 17e64: 11a06000 movne r6, r0 <== NOT EXECUTED 17e68: 1affffd8 bne 17dd0 <fat_get_fat_cluster+0xa4> <== NOT EXECUTED
return rc;
*ret_val |= *sec_buf << 8;
17e6c: e59d2000 ldr r2, [sp] <== NOT EXECUTED 17e70: e5993000 ldr r3, [r9] <== NOT EXECUTED 17e74: e5d22000 ldrb r2, [r2] <== NOT EXECUTED 17e78: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED 17e7c: e5893000 str r3, [r9] <== NOT EXECUTED 17e80: eaffffe8 b 17e28 <fat_get_fat_cluster+0xfc> <== NOT EXECUTED
00012dec <fat_get_unique_ino>:
resrc_unsuff = true;
}
else
resrc_unsuff = true;
}
return 0;
12dec: e590107c ldr r1, [r0, #124] ; 0x7c <== NOT EXECUTED
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(fat_fs_info_t *fs_info)
{
12df0: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
12df4: e1a04000 mov r4, r0 <== NOT EXECUTED
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
12df8: e3a05000 mov r5, #0 <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
12dfc: e3510000 cmp r1, #0 <== NOT EXECUTED 12e00: 0a000018 beq 12e68 <fat_get_unique_ino+0x7c> <== NOT EXECUTED
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
12e04: e2840074 add r0, r4, #116 ; 0x74 <== NOT EXECUTED
12e08: e8900009 ldm r0, {r0, r3} <== NOT EXECUTED
12e0c: e7d0c1a3 ldrb ip, [r0, r3, lsr #3] <== NOT EXECUTED
12e10: e2036007 and r6, r3, #7 <== NOT EXECUTED
12e14: e1a0265c asr r2, ip, r6 <== NOT EXECUTED
12e18: e3120001 tst r2, #1 <== NOT EXECUTED
12e1c: e08071a3 add r7, r0, r3, lsr #3 <== NOT EXECUTED
12e20: 0a000018 beq 12e88 <fat_get_unique_ino+0x9c> <== NOT EXECUTED
12e24: e3a02000 mov r2, #0 <== NOT EXECUTED
12e28: ea000006 b 12e48 <fat_get_unique_ino+0x5c> <== NOT EXECUTED
12e2c: e5943078 ldr r3, [r4, #120] ; 0x78 <== NOT EXECUTED
12e30: e7d0c1a3 ldrb ip, [r0, r3, lsr #3] <== NOT EXECUTED
12e34: e2036007 and r6, r3, #7 <== NOT EXECUTED
12e38: e1a0765c asr r7, ip, r6 <== NOT EXECUTED
12e3c: e3170001 tst r7, #1 <== NOT EXECUTED
12e40: e08071a3 add r7, r0, r3, lsr #3 <== NOT EXECUTED
12e44: 0a00000f beq 12e88 <fat_get_unique_ino+0x9c> <== NOT EXECUTED
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
return (fs_info->uino_base + fs_info->index);
}
fs_info->index++;
12e48: e2833001 add r3, r3, #1 <== NOT EXECUTED
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
12e4c: e1530001 cmp r3, r1 <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
12e50: e2822001 add r2, r2, #1 <== NOT EXECUTED
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
return (fs_info->uino_base + fs_info->index);
}
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
12e54: 31a0c003 movcc ip, r3 <== NOT EXECUTED 12e58: 21a0c005 movcs ip, r5 <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
12e5c: e1520001 cmp r2, r1 <== NOT EXECUTED
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
return (fs_info->uino_base + fs_info->index);
}
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
12e60: e584c078 str ip, [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++)
12e64: 1afffff0 bne 12e2c <fat_get_unique_ino+0x40> <== 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))
12e68: e5942080 ldr r2, [r4, #128] ; 0x80 <== NOT EXECUTED 12e6c: e3e0320f mvn r3, #-268435456 ; 0xf0000000 <== NOT EXECUTED 12e70: e1a01081 lsl r1, r1, #1 <== NOT EXECUTED 12e74: e0623003 rsb r3, r2, r3 <== NOT EXECUTED 12e78: e1510003 cmp r1, r3 <== NOT EXECUTED 12e7c: 3a000008 bcc 12ea4 <fat_get_unique_ino+0xb8> <== NOT EXECUTED
resrc_unsuff = true;
}
else
resrc_unsuff = true;
}
return 0;
12e80: e3a00000 mov r0, #0 <== NOT EXECUTED
}
12e84: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
{
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
12e88: e3a03001 mov r3, #1 <== NOT EXECUTED 12e8c: e18cc613 orr ip, ip, r3, lsl r6 <== NOT EXECUTED 12e90: e5c7c000 strb ip, [r7] <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
12e94: e5940078 ldr r0, [r4, #120] ; 0x78 <== NOT EXECUTED
12e98: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED
12e9c: e0800003 add r0, r0, r3 <== NOT EXECUTED
12ea0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
fs_info->index = 0;
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
{
fs_info->uino_pool_size <<= 1;
12ea4: e584107c str r1, [r4, #124] ; 0x7c <== NOT EXECUTED
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
12ea8: e5940074 ldr r0, [r4, #116] ; 0x74 <== NOT EXECUTED 12eac: ebffc918 bl 5314 <realloc> <== NOT EXECUTED
if (fs_info->uino != NULL)
12eb0: 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);
12eb4: e5840074 str r0, [r4, #116] ; 0x74 <== NOT EXECUTED
if (fs_info->uino != NULL)
12eb8: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
12ebc: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED 12ec0: e5841078 str r1, [r4, #120] ; 0x78 <== NOT EXECUTED 12ec4: eaffffcc b 12dfc <fat_get_unique_ino+0x10> <== NOT EXECUTED
00012d60 <fat_init_clusters_chain>:
int
fat_init_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t start_cln
)
{
12d60: e92d40f0 push {r4, r5, r6, r7, lr}
12d64: e24dd008 sub sp, sp, #8
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cur_cln = start_cln;
12d68: e28d5008 add r5, sp, #8
int
fat_init_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t start_cln
)
{
12d6c: e1a03001 mov r3, r1 12d70: e1a04000 mov r4, r0
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cur_cln = start_cln;
12d74: e5251004 str r1, [r5, #-4]!
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);
12d78: e3a06000 mov r6, #0
{
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)
12d7c: ea000000 b 12d84 <fat_init_clusters_chain+0x24>
{
return -1;
}
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
if ( rc != RC_OK )
12d80: e59d3004 ldr r3, [sp, #4]
{
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)
12d84: e2847010 add r7, r4, #16
12d88: e8971080 ldm r7, {r7, ip}
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
12d8c: e1a01003 mov r1, r3
{
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)
12d90: e0033007 and r3, r3, r7 12d94: e153000c cmp r3, ip
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
12d98: e3a02000 mov r2, #0 12d9c: e1a00004 mov r0, r4
{
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)
12da0: 2a00000d bcs 12ddc <fat_init_clusters_chain+0x7c>
{
ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
12da4: e1d430b6 ldrh r3, [r4, #6] 12da8: e58d6000 str r6, [sp] 12dac: ebfffd0c bl 121e4 <fat_cluster_set>
if ( ret != fs_info->vol.bpc )
12db0: e1d430b6 ldrh r3, [r4, #6] 12db4: e1530000 cmp r3, r0
{
return -1;
}
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
12db8: e1a02005 mov r2, r5 12dbc: e1a00004 mov r0, r4
uint32_t cur_cln = start_cln;
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 )
12dc0: 1a000007 bne 12de4 <fat_init_clusters_chain+0x84>
{
return -1;
}
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
12dc4: e59d1004 ldr r1, [sp, #4] 12dc8: eb0013d7 bl 17d2c <fat_get_fat_cluster>
if ( rc != RC_OK )
12dcc: e3500000 cmp r0, #0
12dd0: 0affffea beq 12d80 <fat_init_clusters_chain+0x20>
}
}
return rc;
}
12dd4: e28dd008 add sp, sp, #8
12dd8: e8bd80f0 pop {r4, r5, r6, r7, pc}
return rc;
}
}
return rc;
12ddc: e1a00002 mov r0, r2 12de0: eafffffb b 12dd4 <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;
12de4: e3e00000 mvn r0, #0 <== NOT EXECUTED 12de8: eafffff9 b 12dd4 <fat_init_clusters_chain+0x74> <== NOT EXECUTED
000124a4 <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)
{
124a4: 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;
124a8: 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)
{
124ac: e24dd0ac sub sp, sp, #172 ; 0xac 124b0: 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);
124b4: e1a00001 mov r0, r1 124b8: 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;
124bc: e58d30a8 str r3, [sp, #168] ; 0xa8
vol->fd = open(device, O_RDWR);
124c0: ebffcb02 bl 50d0 <open>
if (vol->fd < 0)
124c4: 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);
124c8: e5840060 str r0, [r4, #96] ; 0x60
if (vol->fd < 0)
124cc: ba00018b blt 12b00 <fat_init_volume_info+0x65c>
{
rtems_set_errno_and_return_minus_one(ENXIO);
}
rc = fstat(vol->fd, &stat_buf);
124d0: e28d1054 add r1, sp, #84 ; 0x54 124d4: ebffc7c9 bl 4400 <fstat>
if (rc != 0)
124d8: e3500000 cmp r0, #0
124dc: 1a000195 bne 12b38 <fat_init_volume_info+0x694>
close(vol->fd);
rtems_set_errno_and_return_minus_one(ENXIO);
}
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
124e0: e59d3060 ldr r3, [sp, #96] ; 0x60 124e4: e2033a0f and r3, r3, #61440 ; 0xf000 124e8: e3530a06 cmp r3, #24576 ; 0x6000
{
close(vol->fd);
124ec: 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))
124f0: 1a000181 bne 12afc <fat_init_volume_info+0x658>
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
124f4: e59f16d8 ldr r1, [pc, #1752] ; 12bd4 <fat_init_volume_info+0x730> 124f8: e2842064 add r2, r4, #100 ; 0x64 124fc: eb000574 bl 13ad4 <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) {
12500: e2501000 subs r1, r0, #0
12504: 1a00017b bne 12af8 <fat_init_volume_info+0x654>
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);
12508: e5940064 ldr r0, [r4, #100] ; 0x64 1250c: e28d20a8 add r2, sp, #168 ; 0xa8 12510: ebfff66f bl fed4 <rtems_bdbuf_read>
if (sc != RTEMS_SUCCESSFUL)
12514: e3500000 cmp r0, #0
12518: 1a00017f bne 12b1c <fat_init_volume_info+0x678>
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
1251c: e59d00a8 ldr r0, [sp, #168] ; 0xa8 12520: e590301c ldr r3, [r0, #28] 12524: e5d3200f ldrb r2, [r3, #15] 12528: e58d2014 str r2, [sp, #20] 1252c: e5d32013 ldrb r2, [r3, #19] 12530: e58d2004 str r2, [sp, #4] 12534: e5d32014 ldrb r2, [r3, #20] 12538: e58d2008 str r2, [sp, #8] 1253c: e5d32016 ldrb r2, [r3, #22] 12540: e58d200c str r2, [sp, #12] 12544: e5d32020 ldrb r2, [r3, #32] 12548: e58d2024 str r2, [sp, #36] ; 0x24 1254c: e5d32021 ldrb r2, [r3, #33] ; 0x21 12550: e58d2028 str r2, [sp, #40] ; 0x28 12554: e5d32022 ldrb r2, [r3, #34] ; 0x22 12558: e58d202c str r2, [sp, #44] ; 0x2c 1255c: e5d32023 ldrb r2, [r3, #35] ; 0x23 12560: e58d2030 str r2, [sp, #48] ; 0x30 12564: e5d32024 ldrb r2, [r3, #36] ; 0x24 12568: e58d2034 str r2, [sp, #52] ; 0x34 1256c: e5d32025 ldrb r2, [r3, #37] ; 0x25 12570: e58d2018 str r2, [sp, #24] 12574: e5d32026 ldrb r2, [r3, #38] ; 0x26 12578: e5d3100c ldrb r1, [r3, #12] 1257c: e58d201c str r2, [sp, #28] 12580: e5d32027 ldrb r2, [r3, #39] ; 0x27 12584: e5d3500b ldrb r5, [r3, #11] 12588: e58d1010 str r1, [sp, #16] 1258c: e5d3600d ldrb r6, [r3, #13] 12590: e5d3900e ldrb r9, [r3, #14] 12594: e5d38010 ldrb r8, [r3, #16] 12598: e5d3b011 ldrb fp, [r3, #17] 1259c: e5d3a012 ldrb sl, [r3, #18] 125a0: e5d37017 ldrb r7, [r3, #23] 125a4: e58d2020 str r2, [sp, #32] 125a8: e5d32028 ldrb r2, [r3, #40] ; 0x28 125ac: e58d2038 str r2, [sp, #56] ; 0x38 125b0: e5d3202c ldrb r2, [r3, #44] ; 0x2c 125b4: e58d204c str r2, [sp, #76] ; 0x4c 125b8: e5d3202d ldrb r2, [r3, #45] ; 0x2d 125bc: e58d2050 str r2, [sp, #80] ; 0x50 125c0: e5d3202e ldrb r2, [r3, #46] ; 0x2e 125c4: e58d2044 str r2, [sp, #68] ; 0x44 125c8: e5d3202f ldrb r2, [r3, #47] ; 0x2f 125cc: e58d2048 str r2, [sp, #72] ; 0x48 125d0: e5d32030 ldrb r2, [r3, #48] ; 0x30 125d4: e5d33031 ldrb r3, [r3, #49] ; 0x31 125d8: e58d203c str r2, [sp, #60] ; 0x3c 125dc: e58d3040 str r3, [sp, #64] ; 0x40
sc = rtems_bdbuf_release( block);
125e0: ebfff6b4 bl 100b8 <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL)
125e4: e3500000 cmp r0, #0
125e8: 1a00014b bne 12b1c <fat_init_volume_info+0x678>
close(vol->fd);
rtems_set_errno_and_return_minus_one( EIO );
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
125ec: e59d1010 ldr r1, [sp, #16] 125f0: e1853401 orr r3, r5, r1, lsl #8 125f4: e1a03803 lsl r3, r3, #16 125f8: e1a01823 lsr r1, r3, #16
if ( (vol->bps != 512) &&
125fc: e3510b01 cmp r1, #1024 ; 0x400 12600: 13510c02 cmpne r1, #512 ; 0x200 12604: 03a02000 moveq r2, #0 12608: 13a02001 movne r2, #1
close(vol->fd);
rtems_set_errno_and_return_minus_one( EIO );
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
1260c: e1c410b0 strh r1, [r4]
if ( (vol->bps != 512) &&
12610: 0a0000d3 beq 12964 <fat_init_volume_info+0x4c0>
(vol->bps != 1024) &&
12614: e3510b02 cmp r1, #2048 ; 0x800 <== NOT EXECUTED 12618: 0a000001 beq 12624 <fat_init_volume_info+0x180> <== NOT EXECUTED
(vol->bps != 2048) &&
1261c: e3510a01 cmp r1, #4096 ; 0x1000 <== NOT EXECUTED 12620: 1a00012d bne 12adc <fat_init_volume_info+0x638> <== 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;
12624: e1a034a1 lsr r3, r1, #9 <== NOT EXECUTED
* 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)
{
12628: e3a02001 mov r2, #1 <== NOT EXECUTED 1262c: ea000000 b 12634 <fat_init_volume_info+0x190> <== 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;
12630: e1a02000 mov r2, r0 <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
12634: e1a030c3 asr r3, r3, #1 <== NOT EXECUTED 12638: e2820001 add r0, 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;
1263c: e3130001 tst r3, #1 <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
12640: e20000ff and r0, r0, #255 ; 0xff <== 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;
12644: 0afffff9 beq 12630 <fat_init_volume_info+0x18c> <== NOT EXECUTED 12648: e5c42003 strb r2, [r4, #3] <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
1264c: e3a05000 mov r5, #0 12650: e3110001 tst r1, #1 12654: e5c45002 strb r5, [r4, #2] 12658: 01a03001 moveq r3, r1 1265c: 03a05001 moveq r5, #1
12660: 0a000001 beq 1266c <fat_init_volume_info+0x1c8>
12664: ea000006 b 12684 <fat_init_volume_info+0x1e0> <== NOT EXECUTED
12668: e1a05002 mov r5, r2
i >>= 1, vol->sec_log2++);
1266c: e1a030c3 asr r3, r3, #1 12670: e2852001 add r2, r5, #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;
12674: e3130001 tst r3, #1
i >>= 1, vol->sec_log2++);
12678: e20220ff and r2, r2, #255 ; 0xff
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;
1267c: 0afffff9 beq 12668 <fat_init_volume_info+0x1c4>
12680: e5c45002 strb r5, [r4, #2]
i >>= 1, vol->sec_log2++);
vol->bytes_per_block = vol->bps;
vol->bytes_per_block_log2 = vol->sec_log2;
vol->sectors_per_block = 1;
12684: 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)
12688: e3560000 cmp r6, #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;
1268c: e1c410ba strh r1, [r4, #10]
vol->bytes_per_block_log2 = vol->sec_log2;
12690: e5c4500c strb r5, [r4, #12]
vol->sectors_per_block = 1;
12694: e5c42009 strb r2, [r4, #9]
vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
12698: e5c46004 strb r6, [r4, #4]
/*
* "sectors per cluster" of zero is invalid
* (and would hang the following loop)
*/
if (vol->spc == 0)
1269c: 0a00010e beq 12adc <fat_init_volume_info+0x638>
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
126a0: e3a00000 mov r0, #0 126a4: e3160001 tst r6, #1 126a8: e5c40005 strb r0, [r4, #5] 126ac: e1a03006 mov r3, r6 126b0: 11a02000 movne r2, r0
126b4: 0a000001 beq 126c0 <fat_init_volume_info+0x21c>
126b8: ea000006 b 126d8 <fat_init_volume_info+0x234> 126bc: e1a02000 mov r2, r0
i >>= 1, vol->spc_log2++);
126c0: e1a030c3 asr r3, r3, #1 126c4: e2820001 add r0, r2, #1
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
126c8: e3130001 tst r3, #1
i >>= 1, vol->spc_log2++);
126cc: e20000ff and r0, r0, #255 ; 0xff
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
126d0: 0afffff9 beq 126bc <fat_init_volume_info+0x218>
126d4: e5c42005 strb r2, [r4, #5]
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)
126d8: e1a03211 lsl r3, r1, r2 126dc: e1a03803 lsl r3, r3, #16 126e0: e1a03823 lsr r3, r3, #16 126e4: e3530902 cmp r3, #32768 ; 0x8000 126e8: e1c430b6 strh r3, [r4, #6]
126ec: 8a0000fa bhi 12adc <fat_init_volume_info+0x638>
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
126f0: e3a02000 mov r2, #0 126f4: e3130001 tst r3, #1 126f8: e5c42008 strb r2, [r4, #8] 126fc: 03a02001 moveq r2, #1
12700: 0a000001 beq 1270c <fat_init_volume_info+0x268>
12704: ea000006 b 12724 <fat_init_volume_info+0x280> <== NOT EXECUTED
12708: e1a02000 mov r2, r0
i >>= 1, vol->bpc_log2++);
1270c: e1a030c3 asr r3, r3, #1 12710: e2820001 add r0, r2, #1
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
12714: e3130001 tst r3, #1
i >>= 1, vol->bpc_log2++);
12718: e20000ff and r0, r0, #255 ; 0xff
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
1271c: 0afffff9 beq 12708 <fat_init_volume_info+0x264>
12720: e5c42008 strb r2, [r4, #8]
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);
12724: e59d2014 ldr r2, [sp, #20]
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)) /
12728: e2410001 sub r0, r1, #1
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);
1272c: e1899402 orr r9, r9, r2, lsl #8
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
12730: e18ba40a orr sl, fp, sl, 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);
12734: e5c4800d strb r8, [r4, #13]
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
12738: e1c491b8 strh r9, [r4, #24]
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
1273c: e1c4a2b4 strh sl, [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)) /
12740: e080028a add r0, r0, sl, lsl #5 12744: eb005261 bl 270d0 <__aeabi_idiv>
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
12748: e1a05510 lsl r5, r0, r5
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
1274c: e59d300c ldr r3, [sp, #12] 12750: e1937407 orrs r7, r3, r7, 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);
12754: 059d201c ldreq r2, [sp, #28] 12758: 01a03802 lsleq r3, r2, #16 1275c: 059d2018 ldreq r2, [sp, #24] 12760: 01833402 orreq r3, r3, r2, lsl #8 12764: 059d2034 ldreq r2, [sp, #52] ; 0x34 12768: 01833002 orreq r3, r3, r2 1276c: 059d2020 ldreq r2, [sp, #32] 12770: 01837c02 orreq r7, r3, r2, lsl #24 12774: e584701c str r7, [r4, #28]
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
12778: e0279798 mla r7, r8, r7, r9
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)
1277c: e59d2004 ldr r2, [sp, #4] 12780: e59d1008 ldr r1, [sp, #8] 12784: e1923401 orrs r3, r2, r1, 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);
12788: 059d202c ldreq r2, [sp, #44] ; 0x2c 1278c: 01a03802 lsleq r3, r2, #16 12790: 059d2028 ldreq r2, [sp, #40] ; 0x28 12794: 01833402 orreq r3, r3, r2, lsl #8 12798: 059d2024 ldreq r2, [sp, #36] ; 0x24 1279c: 01833002 orreq r3, r3, r2 127a0: 059d2030 ldreq r2, [sp, #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)) /
127a4: e5840028 str r0, [r4, #40] ; 0x28
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
127a8: 01833c02 orreq r3, r3, r2, lsl #24
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 +
127ac: e0870000 add r0, r7, r0 127b0: e5840034 str r0, [r4, #52] ; 0x34
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
127b4: e5843030 str r3, [r4, #48] ; 0x30
data_secs = vol->tot_secs - vol->data_fsec;
vol->data_cls = data_secs / vol->spc;
127b8: e0600003 rsb r0, r0, r3
/* 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;
127bc: e584502c str r5, [r4, #44] ; 0x2c
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;
127c0: e5847020 str r7, [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;
127c4: e1a01006 mov r1, r6 127c8: ebffbd5c bl 1d40 <__aeabi_uidiv>
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
127cc: e59f3404 ldr r3, [pc, #1028] ; 12bd8 <fat_init_volume_info+0x734> 127d0: 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;
127d4: e5840038 str r0, [r4, #56] ; 0x38
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
127d8: 8a000066 bhi 12978 <fat_init_volume_info+0x4d4>
{
vol->type = FAT_FAT12;
127dc: e3a03001 mov r3, #1 127e0: e5c4300e strb r3, [r4, #14]
vol->mask = FAT_FAT12_MASK;
127e4: e59f33f0 ldr r3, [pc, #1008] ; 12bdc <fat_init_volume_info+0x738> 127e8: e5843010 str r3, [r4, #16]
vol->eoc_val = FAT_FAT12_EOC;
127ec: e2433007 sub r3, r3, #7 127f0: e5843014 str r3, [r4, #20]
}
}
}
else
{
vol->rdir_cl = 0;
127f4: e3a03000 mov r3, #0
vol->mirror = 0;
vol->afat = 0;
vol->free_cls = FAT_UNDEFINED_VALUE;
127f8: e3e02000 mvn r2, #0
}
}
}
else
{
vol->rdir_cl = 0;
127fc: e584303c str r3, [r4, #60] ; 0x3c
vol->mirror = 0;
12800: e5c43054 strb r3, [r4, #84] ; 0x54
vol->afat = 0;
12804: e5c4305c strb r3, [r4, #92] ; 0x5c
vol->free_cls = FAT_UNDEFINED_VALUE;
12808: e5842044 str r2, [r4, #68] ; 0x44
vol->next_cl = FAT_UNDEFINED_VALUE;
1280c: e584204c str r2, [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);
12810: e1a00004 mov r0, r4 12814: ebfffd8c bl 11e4c <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;
12818: e594101c ldr r1, [r4, #28] 1281c: e5d4305c ldrb r3, [r4, #92] ; 0x5c 12820: e1d421b8 ldrh r2, [r4, #24] 12824: e0232391 mla r3, r1, r3, r2
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
12828: 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;
1282c: e5843058 str r3, [r4, #88] ; 0x58
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
12830: e3a0100c mov r1, #12 12834: ebffc60d bl 4070 <calloc>
if ( fs_info->vhash == NULL )
12838: 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));
1283c: e1a03000 mov r3, r0 12840: e584006c str r0, [r4, #108] ; 0x6c
if ( fs_info->vhash == NULL )
12844: 0a0000c9 beq 12b70 <fat_init_volume_info+0x6cc>
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 );
12848: e280e004 add lr, r0, #4
head->next = tail;
head->previous = NULL;
1284c: 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 );
12850: e280200c add r2, r0, #12 12854: e280c010 add ip, r0, #16
head->next = tail;
12858: e583e000 str lr, [r3]
head->previous = NULL;
1285c: e5835004 str r5, [r3, #4]
tail->previous = head;
12860: e5833008 str r3, [r3, #8]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
12864: e583c00c str ip, [r3, #12]
head->previous = NULL;
12868: e5835010 str r5, [r3, #16]
tail->previous = head;
1286c: e5832014 str r2, [r3, #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));
12870: e3a00002 mov r0, #2 12874: e3a0100c mov r1, #12 12878: ebffc5fc bl 4070 <calloc>
if ( fs_info->rhash == NULL )
1287c: 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));
12880: e1a03000 mov r3, r0 12884: e5840070 str r0, [r4, #112] ; 0x70
if ( fs_info->rhash == NULL )
12888: 0a0000bf beq 12b8c <fat_init_volume_info+0x6e8>
}
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;
1288c: e5d42003 ldrb r2, [r4, #3] 12890: e5941030 ldr r1, [r4, #48] ; 0x30 12894: e1a01211 lsl r1, r1, r2
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;
12898: e3a00c01 mov r0, #256 ; 0x100
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
1289c: e1a01201 lsl r1, r1, #4
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 );
128a0: e283e004 add lr, r3, #4 128a4: e283200c add r2, r3, #12 128a8: e283c010 add ip, r3, #16 128ac: e5841080 str r1, [r4, #128] ; 0x80
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;
128b0: e584007c str r0, [r4, #124] ; 0x7c
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
128b4: e5845078 str r5, [r4, #120] ; 0x78
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
128b8: e3a01001 mov r1, #1
head->next = tail;
128bc: e583e000 str lr, [r3]
head->previous = NULL;
128c0: e5835004 str r5, [r3, #4]
tail->previous = head;
128c4: e5833008 str r3, [r3, #8]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
128c8: e583c00c str ip, [r3, #12]
head->previous = NULL;
128cc: e5835010 str r5, [r3, #16]
tail->previous = head;
128d0: e5832014 str r2, [r3, #20] 128d4: ebffc5e5 bl 4070 <calloc>
if ( fs_info->uino == NULL )
128d8: 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));
128dc: e5840074 str r0, [r4, #116] ; 0x74
if ( fs_info->uino == NULL )
128e0: 0a000097 beq 12b44 <fat_init_volume_info+0x6a0>
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));
128e4: e1d400b0 ldrh r0, [r4] 128e8: e3a01001 mov r1, #1 128ec: ebffc5df bl 4070 <calloc>
if (fs_info->sec_buf == NULL)
128f0: 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));
128f4: e5840090 str r0, [r4, #144] ; 0x90
if (fs_info->sec_buf == NULL)
128f8: 0a0000a7 beq 12b9c <fat_init_volume_info+0x6f8>
return bytes_written;
}
static bool is_cluster_aligned(const fat_vol_t *vol, uint32_t sec_num)
{
return (sec_num & (vol->spc - 1)) == 0;
128fc: e5d43004 ldrb r3, [r4, #4] 12900: e5942034 ldr r2, [r4, #52] ; 0x34 12904: 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)
12908: e0130002 ands r0, r3, r2
vol->bytes_per_block_log2 = vol->bpc_log2;
vol->sectors_per_block = vol->spc;
}
}
return RC_OK;
1290c: 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)
12910: 1a000011 bne 1295c <fat_init_volume_info+0x4b8>
&& (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
12914: e5d4100e ldrb r1, [r4, #14] 12918: e3510004 cmp r1, #4
1291c: 0a000002 beq 1292c <fat_init_volume_info+0x488>
return bytes_written;
}
static bool is_cluster_aligned(const fat_vol_t *vol, uint32_t sec_num)
{
return (sec_num & (vol->spc - 1)) == 0;
12920: 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)))
12924: e1130002 tst r3, r2
12928: 1a00000b bne 1295c <fat_init_volume_info+0x4b8>
{
sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true);
1292c: e1d410b6 ldrh r1, [r4, #6] 12930: e3a02001 mov r2, #1 12934: e5940064 ldr r0, [r4, #100] ; 0x64 12938: ebfff70c bl 10570 <rtems_bdbuf_set_block_size>
if (sc == RTEMS_SUCCESSFUL)
1293c: e3500000 cmp r0, #0
{
vol->bytes_per_block = vol->bpc;
12940: 01d410b6 ldrheq r1, [r4, #6]
vol->bytes_per_block_log2 = vol->bpc_log2;
12944: 05d42008 ldrbeq r2, [r4, #8]
vol->sectors_per_block = vol->spc;
12948: 05d43004 ldrbeq r3, [r4, #4]
&& (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
{
sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true);
if (sc == RTEMS_SUCCESSFUL)
{
vol->bytes_per_block = vol->bpc;
1294c: 01c410ba strheq r1, [r4, #10]
vol->bytes_per_block_log2 = vol->bpc_log2;
12950: 05c4200c strbeq r2, [r4, #12]
vol->sectors_per_block = vol->spc;
12954: 05c43009 strbeq r3, [r4, #9]
}
}
return RC_OK;
12958: 13a00000 movne r0, #0
}
1295c: e28dd0ac add sp, sp, #172 ; 0xac
12960: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
(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;
12964: e1a03ca3 lsr r3, r3, #25 12968: e3130001 tst r3, #1 1296c: e5c42003 strb r2, [r4, #3]
12970: 0affff2c beq 12628 <fat_init_volume_info+0x184>
12974: eaffff34 b 1264c <fat_init_volume_info+0x1a8>
vol->mask = FAT_FAT12_MASK;
vol->eoc_val = FAT_FAT12_EOC;
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
12978: e59f3260 ldr r3, [pc, #608] ; 12be0 <fat_init_volume_info+0x73c> 1297c: e1500003 cmp r0, r3
12980: 9a00004c bls 12ab8 <fat_init_volume_info+0x614>
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
12984: e59d3044 ldr r3, [sp, #68] ; 0x44
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
12988: e59d1038 ldr r1, [sp, #56] ; 0x38
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
1298c: e1a02803 lsl r2, r3, #16 12990: e59d3050 ldr r3, [sp, #80] ; 0x50 12994: e1822403 orr r2, r2, r3, lsl #8
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
12998: e2013080 and r3, r1, #128 ; 0x80
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
1299c: e59d104c ldr r1, [sp, #76] ; 0x4c 129a0: e1822001 orr r2, r2, r1 129a4: e59d1048 ldr r1, [sp, #72] ; 0x48 129a8: e1822c01 orr r2, r2, r1, lsl #24
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
129ac: e3a01004 mov r1, #4 129b0: e5c4100e strb r1, [r4, #14]
vol->mask = FAT_FAT32_MASK;
129b4: e3e0120f mvn r1, #-268435456 ; 0xf0000000 129b8: e5841010 str r1, [r4, #16]
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;
if (vol->mirror)
129bc: e3530000 cmp r3, #0
}
else
{
vol->type = FAT_FAT32;
vol->mask = FAT_FAT32_MASK;
vol->eoc_val = FAT_FAT32_EOC;
129c0: e3e0127f mvn r1, #-268435449 ; 0xf0000007 129c4: e5841014 str r1, [r4, #20]
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
129c8: e584203c str r2, [r4, #60] ; 0x3c
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
129cc: e5c43054 strb r3, [r4, #84] ; 0x54
if (vol->mirror)
129d0: 0a00004f beq 12b14 <fat_init_volume_info+0x670>
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
129d4: e59d2038 ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED 129d8: e202300f and r3, r2, #15 <== NOT EXECUTED 129dc: e5c4305c strb r3, [r4, #92] ; 0x5c <== NOT EXECUTED
else
vol->afat = 0;
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
129e0: e59d303c ldr r3, [sp, #60] ; 0x3c 129e4: e59d2040 ldr r2, [sp, #64] ; 0x40 129e8: e1831402 orr r1, r3, r2, lsl #8
if( vol->info_sec == 0 )
129ec: 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);
129f0: e1c414b0 strh r1, [r4, #64] ; 0x40
if( vol->info_sec == 0 )
129f4: 0a000038 beq 12adc <fat_init_volume_info+0x638>
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);
129f8: 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,
129fc: e1a00004 mov r0, r4 12a00: e3a02000 mov r2, #0 12a04: e3a03004 mov r3, #4 12a08: e58d5000 str r5, [sp] 12a0c: ebfffda2 bl 1209c <_fat_block_read>
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
12a10: e3500000 cmp r0, #0
12a14: ba00006a blt 12bc4 <fat_init_volume_info+0x720>
{
close(vol->fd);
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
12a18: e5dd309e ldrb r3, [sp, #158] ; 0x9e 12a1c: e5dd209d ldrb r2, [sp, #157] ; 0x9d 12a20: e1a03803 lsl r3, r3, #16 12a24: e5dd109c ldrb r1, [sp, #156] ; 0x9c 12a28: e1833402 orr r3, r3, r2, lsl #8 12a2c: e5dd209f ldrb r2, [sp, #159] ; 0x9f 12a30: e1833001 orr r3, r3, r1 12a34: e1832c02 orr r2, r3, r2, lsl #24 12a38: e59f31a4 ldr r3, [pc, #420] ; 12be4 <fat_init_volume_info+0x740> 12a3c: e1520003 cmp r2, r3
12a40: 1a000023 bne 12ad4 <fat_init_volume_info+0x630>
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
12a44: e1d414b0 ldrh r1, [r4, #64] ; 0x40 12a48: e1a00004 mov r0, r4 12a4c: e3a02f79 mov r2, #484 ; 0x1e4 12a50: e3a0300c mov r3, #12 12a54: e58d5000 str r5, [sp] 12a58: ebfffd8f bl 1209c <_fat_block_read>
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
12a5c: e3500000 cmp r0, #0
12a60: ba000055 blt 12bbc <fat_init_volume_info+0x718>
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
12a64: e5dd20a2 ldrb r2, [sp, #162] ; 0xa2
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
12a68: e5dd30a6 ldrb r3, [sp, #166] ; 0xa6
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
12a6c: e5dd00a1 ldrb r0, [sp, #161] ; 0xa1
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
12a70: e5dd10a5 ldrb r1, [sp, #165] ; 0xa5
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
12a74: e1a02802 lsl r2, r2, #16 12a78: e5dde0a0 ldrb lr, [sp, #160] ; 0xa0
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
12a7c: e1a03803 lsl r3, r3, #16 12a80: e5ddc0a4 ldrb ip, [sp, #164] ; 0xa4
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
12a84: e1822400 orr r2, r2, r0, lsl #8
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
12a88: e1833401 orr r3, r3, r1, lsl #8
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
12a8c: e5dd00a3 ldrb r0, [sp, #163] ; 0xa3
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
12a90: e5dd10a7 ldrb r1, [sp, #167] ; 0xa7
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
12a94: e182200e orr r2, r2, lr
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
12a98: e183300c orr r3, r3, ip
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
12a9c: e1822c00 orr r2, r2, r0, lsl #24
vol->free_cls = vol->free_cls_in_fs_info;
vol->next_cl_in_fs_info =
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
12aa0: e1833c01 orr r3, r3, r1, lsl #24
_fat_block_release(fs_info);
close(vol->fd);
return -1;
}
vol->free_cls_in_fs_info =
12aa4: e5842048 str r2, [r4, #72] ; 0x48
FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->free_cls = vol->free_cls_in_fs_info;
12aa8: e5842044 str r2, [r4, #68] ; 0x44
vol->next_cl_in_fs_info =
12aac: e5843050 str r3, [r4, #80] ; 0x50
FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
vol->next_cl = vol->next_cl_in_fs_info;
12ab0: e584304c str r3, [r4, #76] ; 0x4c 12ab4: eaffff55 b 12810 <fat_init_volume_info+0x36c>
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
{
vol->type = FAT_FAT16;
12ab8: e3a03002 mov r3, #2 12abc: e5c4300e strb r3, [r4, #14]
vol->mask = FAT_FAT16_MASK;
12ac0: e59f3120 ldr r3, [pc, #288] ; 12be8 <fat_init_volume_info+0x744> 12ac4: e5843010 str r3, [r4, #16]
vol->eoc_val = FAT_FAT16_EOC;
12ac8: e2433007 sub r3, r3, #7 12acc: e5843014 str r3, [r4, #20] 12ad0: eaffff47 b 127f4 <fat_init_volume_info+0x350>
* 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);
12ad4: e1a00004 mov r0, r4 <== NOT EXECUTED 12ad8: ebfffcdb bl 11e4c <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);
12adc: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 12ae0: ebffc574 bl 40b8 <close> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
12ae4: eb001b72 bl 198b4 <__errno> <== NOT EXECUTED 12ae8: e3a03016 mov r3, #22 <== NOT EXECUTED 12aec: e5803000 str r3, [r0] <== NOT EXECUTED 12af0: e3e00000 mvn r0, #0 <== NOT EXECUTED 12af4: eaffff98 b 1295c <fat_init_volume_info+0x4b8> <== NOT EXECUTED
}
/* 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) {
close(vol->fd);
12af8: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 12afc: ebffc56d bl 40b8 <close> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENXIO);
12b00: eb001b6b bl 198b4 <__errno> <== NOT EXECUTED 12b04: e3a03006 mov r3, #6 <== NOT EXECUTED 12b08: e5803000 str r3, [r0] <== NOT EXECUTED 12b0c: e3e00000 mvn r0, #0 <== NOT EXECUTED 12b10: eaffff91 b 1295c <fat_init_volume_info+0x4b8> <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
if (vol->mirror)
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
else
vol->afat = 0;
12b14: e5c4305c strb r3, [r4, #92] ; 0x5c 12b18: eaffffb0 b 129e0 <fat_init_volume_info+0x53c>
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
sc = rtems_bdbuf_release( block);
if (sc != RTEMS_SUCCESSFUL)
{
close(vol->fd);
12b1c: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 12b20: ebffc564 bl 40b8 <close> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
12b24: eb001b62 bl 198b4 <__errno> <== NOT EXECUTED 12b28: e3a03005 mov r3, #5 <== NOT EXECUTED 12b2c: e5803000 str r3, [r0] <== NOT EXECUTED 12b30: e3e00000 mvn r0, #0 <== NOT EXECUTED 12b34: eaffff88 b 1295c <fat_init_volume_info+0x4b8> <== NOT EXECUTED
}
rc = fstat(vol->fd, &stat_buf);
if (rc != 0)
{
close(vol->fd);
12b38: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 12b3c: ebffc55d bl 40b8 <close> <== NOT EXECUTED 12b40: eaffffee b 12b00 <fat_init_volume_info+0x65c> <== 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);
12b44: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 12b48: ebffc55a bl 40b8 <close> <== NOT EXECUTED
free(fs_info->vhash);
12b4c: e594006c ldr r0, [r4, #108] ; 0x6c <== NOT EXECUTED 12b50: ebffc601 bl 435c <free> <== NOT EXECUTED
free(fs_info->rhash);
12b54: e5940070 ldr r0, [r4, #112] ; 0x70 <== NOT EXECUTED
if (fs_info->sec_buf == NULL)
{
close(vol->fd);
free(fs_info->vhash);
free(fs_info->rhash);
free(fs_info->uino);
12b58: ebffc5ff bl 435c <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
12b5c: eb001b54 bl 198b4 <__errno> <== NOT EXECUTED 12b60: e3a0300c mov r3, #12 <== NOT EXECUTED 12b64: e5803000 str r3, [r0] <== NOT EXECUTED 12b68: e3e00000 mvn r0, #0 <== NOT EXECUTED 12b6c: eaffff7a b 1295c <fat_init_volume_info+0x4b8> <== 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);
12b70: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 12b74: ebffc54f bl 40b8 <close> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
12b78: eb001b4d bl 198b4 <__errno> <== NOT EXECUTED 12b7c: e3a0300c mov r3, #12 <== NOT EXECUTED 12b80: e5803000 str r3, [r0] <== NOT EXECUTED 12b84: e3e00000 mvn r0, #0 <== NOT EXECUTED 12b88: eaffff73 b 1295c <fat_init_volume_info+0x4b8> <== 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);
12b8c: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 12b90: ebffc548 bl 40b8 <close> <== NOT EXECUTED
free(fs_info->vhash);
12b94: e594006c ldr r0, [r4, #108] ; 0x6c <== NOT EXECUTED 12b98: eaffffee b 12b58 <fat_init_volume_info+0x6b4> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
if (fs_info->sec_buf == NULL)
{
close(vol->fd);
12b9c: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 12ba0: ebffc544 bl 40b8 <close> <== NOT EXECUTED
free(fs_info->vhash);
12ba4: e594006c ldr r0, [r4, #108] ; 0x6c <== NOT EXECUTED 12ba8: ebffc5eb bl 435c <free> <== NOT EXECUTED
free(fs_info->rhash);
12bac: e5940070 ldr r0, [r4, #112] ; 0x70 <== NOT EXECUTED 12bb0: ebffc5e9 bl 435c <free> <== NOT EXECUTED
free(fs_info->uino);
12bb4: e5940074 ldr r0, [r4, #116] ; 0x74 <== NOT EXECUTED 12bb8: eaffffe6 b 12b58 <fat_init_volume_info+0x6b4> <== NOT EXECUTED
* 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);
12bbc: e1a00004 mov r0, r4 <== NOT EXECUTED 12bc0: ebfffca1 bl 11e4c <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);
12bc4: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 12bc8: ebffc53a bl 40b8 <close> <== NOT EXECUTED
return -1;
12bcc: e3e00000 mvn r0, #0 <== NOT EXECUTED 12bd0: eaffff61 b 1295c <fat_init_volume_info+0x4b8> <== NOT EXECUTED
00018174 <fat_scan_fat_for_free_clusters>:
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl,
bool zero_fill
)
{
18174: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
18178: e24dd014 sub sp, sp, #20
1817c: e5ddc03c ldrb ip, [sp, #60] ; 0x3c
int rc = RC_OK;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
18180: e3a09000 mov r9, #0
uint32_t i = 2;
ssize_t bytes_written;
*cls_added = 0;
if (count == 0)
18184: e252b000 subs fp, r2, #0
{
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;
18188: e5908038 ldr r8, [r0, #56] ; 0x38
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl,
bool zero_fill
)
{
1818c: e1a06000 mov r6, r0 18190: e1a07003 mov r7, r3 18194: e58d100c str r1, [sp, #12] 18198: e58dc008 str ip, [sp, #8]
int rc = RC_OK;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
1819c: e58d9010 str r9, [sp, #16]
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
uint32_t i = 2;
ssize_t bytes_written;
*cls_added = 0;
181a0: e5839000 str r9, [r3]
if (count == 0)
return rc;
181a4: 01a0a00b moveq sl, fp
uint32_t i = 2;
ssize_t bytes_written;
*cls_added = 0;
if (count == 0)
181a8: 0a000042 beq 182b8 <fat_scan_fat_for_free_clusters+0x144>
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
181ac: e590404c ldr r4, [r0, #76] ; 0x4c
{
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;
181b0: e2888002 add r8, r8, #2
uint32_t *last_cl,
bool zero_fill
)
{
int rc = RC_OK;
uint32_t cl4find = 2;
181b4: e3740001 cmn r4, #1 181b8: 03a04002 moveq r4, #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)
181bc: e3580002 cmp r8, #2
181c0: 9a00004a bls 182f0 <fat_scan_fat_for_free_clusters+0x17c>
181c4: e3a05002 mov r5, #2 181c8: ea000016 b 18228 <fat_scan_fat_for_free_clusters+0xb4>
* by separate 'if' statement because otherwise undo function
* wouldn't work properly
*/
if (*cls_added == 0)
{
*chain = cl4find;
181cc: e59dc00c ldr ip, [sp, #12]
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
181d0: e1a00006 mov r0, r6
* by separate 'if' statement because otherwise undo function
* wouldn't work properly
*/
if (*cls_added == 0)
{
*chain = cl4find;
181d4: e58c4000 str r4, [ip]
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
181d8: e1a01004 mov r1, r4 181dc: e3e02000 mvn r2, #0 181e0: ebffff27 bl 17e84 <fat_set_fat_cluster>
if ( rc != RC_OK )
181e4: e3500000 cmp r0, #0
181e8: 1a00005f bne 1836c <fat_scan_fat_for_free_clusters+0x1f8>
rc = fat_set_fat_cluster(fs_info, save_cln, cl4find);
if ( rc != RC_OK )
goto cleanup;
}
if (zero_fill)
181ec: e59dc008 ldr ip, [sp, #8] 181f0: e35c0000 cmp ip, #0
181f4: 1a000032 bne 182c4 <fat_scan_fat_for_free_clusters+0x150>
goto cleanup;
}
}
save_cln = cl4find;
(*cls_added)++;
181f8: e5973000 ldr r3, [r7] 181fc: e2833001 add r3, r3, #1
/* have we satisfied request ? */
if (*cls_added == count)
18200: e15b0003 cmp fp, r3
goto cleanup;
}
}
save_cln = cl4find;
(*cls_added)++;
18204: e5873000 str r3, [r7]
/* have we satisfied request ? */
if (*cls_added == count)
18208: 0a00004c beq 18340 <fat_scan_fat_for_free_clusters+0x1cc>
1820c: e1a09004 mov r9, r4
fat_buf_release(fs_info);
return rc;
}
}
i++;
cl4find++;
18210: e2844001 add r4, r4, #1
if (cl4find >= data_cls_val)
cl4find = 2;
18214: e1580004 cmp r8, r4
*last_cl = save_cln;
fat_buf_release(fs_info);
return rc;
}
}
i++;
18218: e2855001 add r5, r5, #1
cl4find++;
if (cl4find >= data_cls_val)
cl4find = 2;
1821c: 93a04002 movls r4, #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)
18220: e1580005 cmp r8, r5
18224: 9a000031 bls 182f0 <fat_scan_fat_for_free_clusters+0x17c>
{
rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);
18228: e1a00006 mov r0, r6 1822c: e1a01004 mov r1, r4 18230: e28d2010 add r2, sp, #16 18234: ebfffebc bl 17d2c <fat_get_fat_cluster>
if ( rc != RC_OK )
18238: e250a000 subs sl, r0, #0
1823c: 1a000037 bne 18320 <fat_scan_fat_for_free_clusters+0x1ac>
if (*cls_added != 0)
fat_free_fat_clusters_chain(fs_info, (*chain));
return rc;
}
if (next_cln == FAT_GENFAT_FREE)
18240: e59d3010 ldr r3, [sp, #16] 18244: e3530000 cmp r3, #0
18248: 1afffff0 bne 18210 <fat_scan_fat_for_free_clusters+0x9c>
/*
* 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)
1824c: e5973000 ldr r3, [r7] 18250: e3530000 cmp r3, #0
18254: 0affffdc beq 181cc <fat_scan_fat_for_free_clusters+0x58>
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
18258: e1a00006 mov r0, r6 1825c: e1a01004 mov r1, r4 18260: e3e02000 mvn r2, #0 18264: ebffff06 bl 17e84 <fat_set_fat_cluster>
if ( rc != RC_OK )
18268: e3500000 cmp r0, #0
1826c: 1a000040 bne 18374 <fat_scan_fat_for_free_clusters+0x200>
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
return rc;
}
rc = fat_set_fat_cluster(fs_info, save_cln, cl4find);
18270: e1a00006 mov r0, r6 18274: e1a01009 mov r1, r9 18278: e1a02004 mov r2, r4 1827c: ebffff00 bl 17e84 <fat_set_fat_cluster>
if ( rc != RC_OK )
18280: e3500000 cmp r0, #0
18284: 0affffd8 beq 181ec <fat_scan_fat_for_free_clusters+0x78>
18288: e1a09000 mov r9, r0 <== NOT EXECUTED
return RC_OK;
cleanup:
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
1828c: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 18290: e1a00006 mov r0, r6 <== NOT EXECUTED 18294: e59c1000 ldr r1, [ip] <== NOT EXECUTED 18298: ebffff81 bl 180a4 <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);
1829c: e1a01004 mov r1, r4 <== NOT EXECUTED 182a0: e3a02000 mov r2, #0 <== NOT EXECUTED 182a4: e1a00006 mov r0, r6 <== NOT EXECUTED 182a8: ebfffef5 bl 17e84 <fat_set_fat_cluster> <== NOT EXECUTED
fat_buf_release(fs_info);
182ac: e1a00006 mov r0, r6 <== NOT EXECUTED 182b0: ebffe6e5 bl 11e4c <fat_buf_release> <== NOT EXECUTED
return rc;
182b4: e1a0a009 mov sl, r9 <== NOT EXECUTED
}
182b8: e1a0000a mov r0, sl
182bc: e28dd014 add sp, sp, #20
182c0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
goto cleanup;
}
if (zero_fill)
{
bytes_written = fat_cluster_set (fs_info, cl4find, 0, fs_info->vol.bpc, 0);
182c4: e1d630b6 ldrh r3, [r6, #6] 182c8: e3a02000 mov r2, #0 182cc: e1a00006 mov r0, r6 182d0: e1a01004 mov r1, r4 182d4: e58d2000 str r2, [sp] 182d8: ebffe7c1 bl 121e4 <fat_cluster_set>
if (fs_info->vol.bpc != bytes_written)
182dc: e1d630b6 ldrh r3, [r6, #6] 182e0: e1530000 cmp r3, r0
182e4: 0affffc3 beq 181f8 <fat_scan_fat_for_free_clusters+0x84>
{
rc = -1;
182e8: e3e09000 mvn r9, #0 <== NOT EXECUTED 182ec: eaffffe6 b 1828c <fat_scan_fat_for_free_clusters+0x118> <== NOT EXECUTED
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
182f0: e5963044 ldr r3, [r6, #68] ; 0x44 <== NOT EXECUTED
cl4find++;
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
182f4: e586904c str r9, [r6, #76] ; 0x4c <== NOT EXECUTED
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
182f8: e3730001 cmn r3, #1 <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
182fc: 15972000 ldrne r2, [r7] <== NOT EXECUTED
*last_cl = save_cln;
18300: e59dc038 ldr ip, [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);
18304: 10623003 rsbne r3, r2, r3 <== NOT EXECUTED 18308: 15863044 strne r3, [r6, #68] ; 0x44 <== NOT EXECUTED
*last_cl = save_cln;
fat_buf_release(fs_info);
1830c: e1a00006 mov r0, r6 <== 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;
18310: e58c9000 str r9, [ip] <== NOT EXECUTED
fat_buf_release(fs_info);
18314: ebffe6cc bl 11e4c <fat_buf_release> <== NOT EXECUTED
return RC_OK;
18318: e3a0a000 mov sl, #0 <== NOT EXECUTED 1831c: eaffffe5 b 182b8 <fat_scan_fat_for_free_clusters+0x144> <== NOT EXECUTED
while (i < data_cls_val)
{
rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);
if ( rc != RC_OK )
{
if (*cls_added != 0)
18320: e5973000 ldr r3, [r7] <== NOT EXECUTED 18324: e3530000 cmp r3, #0 <== NOT EXECUTED 18328: 0affffe2 beq 182b8 <fat_scan_fat_for_free_clusters+0x144> <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
1832c: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 18330: e1a00006 mov r0, r6 <== NOT EXECUTED 18334: e59c1000 ldr r1, [ip] <== NOT EXECUTED 18338: ebffff59 bl 180a4 <fat_free_fat_clusters_chain> <== NOT EXECUTED 1833c: eaffffdd b 182b8 <fat_scan_fat_for_free_clusters+0x144> <== NOT EXECUTED
/* have we satisfied request ? */
if (*cls_added == count)
{
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
18340: e5963044 ldr r3, [r6, #68] ; 0x44
(*cls_added)++;
/* have we satisfied request ? */
if (*cls_added == count)
{
fs_info->vol.next_cl = save_cln;
18344: e586404c str r4, [r6, #76] ; 0x4c
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
18348: e3730001 cmn r3, #1
fs_info->vol.free_cls -= (*cls_added);
1834c: 15972000 ldrne r2, [r7]
*last_cl = save_cln;
18350: e59dc038 ldr ip, [sp, #56] ; 0x38
/* have we satisfied request ? */
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);
18354: 10623003 rsbne r3, r2, r3 18358: 15863044 strne r3, [r6, #68] ; 0x44
*last_cl = save_cln;
fat_buf_release(fs_info);
1835c: e1a00006 mov r0, r6
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;
18360: e58c4000 str r4, [ip]
fat_buf_release(fs_info);
18364: ebffe6b8 bl 11e4c <fat_buf_release>
return rc;
18368: eaffffd2 b 182b8 <fat_scan_fat_for_free_clusters+0x144>
* wouldn't work properly
*/
if (*cls_added == 0)
{
*chain = cl4find;
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
1836c: e1a0a000 mov sl, r0 <== NOT EXECUTED 18370: eaffffd0 b 182b8 <fat_scan_fat_for_free_clusters+0x144> <== NOT EXECUTED
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
if ( rc != RC_OK )
{
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
18374: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 18378: e1a03000 mov r3, r0 <== NOT EXECUTED 1837c: e59c1000 ldr r1, [ip] <== NOT EXECUTED 18380: e1a00006 mov r0, r6 <== NOT EXECUTED 18384: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 18388: ebffff45 bl 180a4 <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);
1838c: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 18390: e1a0a003 mov sl, r3 <== NOT EXECUTED
if ( rc != RC_OK )
{
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
return rc;
18394: eaffffc7 b 182b8 <fat_scan_fat_for_free_clusters+0x144> <== NOT EXECUTED
00012130 <fat_sector_write>:
fat_fs_info_t *fs_info,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
12130: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
12134: e2536000 subs r6, r3, #0
fat_fs_info_t *fs_info,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
12138: e24dd004 sub sp, sp, #4 1213c: e1a05000 mov r5, r0
int rc = RC_OK;
ssize_t cmpltd = 0;
12140: 01a07006 moveq r7, r6
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
12144: 0a000023 beq 121d8 <fat_sector_write+0xa8>
12148: e1a09002 mov r9, r2 1214c: e1a08001 mov r8, r1 12150: e3a07000 mov r7, #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);
12154: e3a0b001 mov fp, #1 12158: ea000008 b 12180 <fat_sector_write+0x50>
if (rc != RC_OK)
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
1215c: e59d0000 ldr r0, [sp] 12160: e0800009 add r0, r0, r9 12164: eb002079 bl 1a350 <memcpy>
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
12168: e0566004 subs r6, r6, r4
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
1216c: e5c5b088 strb fp, [r5, #136] ; 0x88
memcpy((sec_buf + ofs), (buff + cmpltd), c);
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
12170: e0847007 add r7, r4, r7
sec_num++;
12174: e2888001 add r8, r8, #1
uint32_t sec_num = start;
uint32_t ofs = offset;
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
12178: 0a000016 beq 121d8 <fat_sector_write+0xa8>
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
sec_num++;
ofs = 0;
1217c: e1a0900a mov r9, sl <== NOT EXECUTED
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
{
c = MIN(count, (fs_info->vol.bps - ofs));
12180: e1d540b0 ldrh r4, [r5]
if (c == fs_info->vol.bytes_per_block)
12184: e1d530ba ldrh r3, [r5, #10]
uint8_t *sec_buf;
uint32_t c = 0;
while(count > 0)
{
c = MIN(count, (fs_info->vol.bps - ofs));
12188: e0694004 rsb r4, r9, r4 1218c: e1540006 cmp r4, r6 12190: 21a04006 movcs r4, r6
if (c == fs_info->vol.bytes_per_block)
12194: e1530004 cmp r3, r4
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
12198: 01a01008 moveq r1, r8 1219c: 03a02002 moveq r2, #2 121a0: 01a0300d moveq r3, sp
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
121a4: 11a01008 movne r1, r8 121a8: 13a02001 movne r2, #1 121ac: 11a0300d movne r3, sp
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);
121b0: 01a00005 moveq r0, r5
else
rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
121b4: 11a00005 movne r0, r5 121b8: ebffff8c bl 11ff0 <fat_buf_access>
if (rc != RC_OK)
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
121bc: e59d3028 ldr r3, [sp, #40] ; 0x28
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)
121c0: 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);
121c4: e1a0a000 mov sl, r0
if (rc != RC_OK)
return -1;
memcpy((sec_buf + ofs), (buff + cmpltd), c);
121c8: e0831007 add r1, r3, r7 121cc: e1a02004 mov r2, r4
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)
121d0: 0affffe1 beq 1215c <fat_sector_write+0x2c>
return -1;
121d4: e3e07000 mvn r7, #0 <== NOT EXECUTED
cmpltd +=c;
sec_num++;
ofs = 0;
}
return cmpltd;
}
121d8: e1a00007 mov r0, r7
121dc: e28dd004 add sp, sp, #4
121e0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00017e84 <fat_set_fat_cluster>:
fat_set_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t in_val
)
{
17e84: e92d47f0 push {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;
17e88: e3a03000 mov r3, #0
fat_set_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t in_val
)
{
17e8c: e24dd004 sub sp, sp, #4
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
uint8_t *sec_buf = NULL;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
17e90: e3510001 cmp r1, #1
fat_set_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t in_val
)
{
17e94: e1a05001 mov r5, r1 17e98: e1a04000 mov r4, r0 17e9c: 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;
17ea0: e58d3000 str r3, [sp]
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
17ea4: 9a00001d bls 17f20 <fat_set_fat_cluster+0x9c>
17ea8: e5903038 ldr r3, [r0, #56] ; 0x38 17eac: e2833001 add r3, r3, #1 17eb0: e1510003 cmp r1, r3
17eb4: 8a000019 bhi 17f20 <fat_set_fat_cluster+0x9c>
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
17eb8: e5d0300e ldrb r3, [r0, #14] 17ebc: e3130001 tst r3, #1 17ec0: e5d0a002 ldrb sl, [r0, #2]
17ec4: 1a00001b bne 17f38 <fat_set_fat_cluster+0xb4>
17ec8: e3130002 tst r3, #2 17ecc: e5903058 ldr r3, [r0, #88] ; 0x58 17ed0: 11a06081 lslne r6, r1, #1 17ed4: 01a06101 lsleq r6, r1, #2 17ed8: e083aa36 add sl, r3, r6, lsr sl
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
17edc: e1a00004 mov r0, r4 17ee0: e1a0100a mov r1, sl 17ee4: e3a02001 mov r2, #1 17ee8: 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);
17eec: e1d470b0 ldrh r7, [r4]
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);
17ef0: ebffe83e bl 11ff0 <fat_buf_access>
if (rc != RC_OK)
17ef4: e3500000 cmp r0, #0
17ef8: 1a00000c bne 17f30 <fat_set_fat_cluster+0xac>
return rc;
switch ( fs_info->vol.type )
17efc: e5d4800e ldrb r8, [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);
17f00: 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 )
17f04: e3580002 cmp r8, #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);
17f08: 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 )
17f0c: 0a00000d beq 17f48 <fat_set_fat_cluster+0xc4>
17f10: e3580004 cmp r8, #4
17f14: 0a000028 beq 17fbc <fat_set_fat_cluster+0x138>
17f18: e3580001 cmp r8, #1
17f1c: 0a00000e beq 17f5c <fat_set_fat_cluster+0xd8>
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
17f20: eb000663 bl 198b4 <__errno> <== NOT EXECUTED 17f24: e3a03005 mov r3, #5 <== NOT EXECUTED 17f28: e5803000 str r3, [r0] <== NOT EXECUTED 17f2c: e3e00000 mvn r0, #0 <== NOT EXECUTED
break;
}
return RC_OK;
}
17f30: e28dd004 add sp, sp, #4
17f34: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
/* 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) +
17f38: e5903058 ldr r3, [r0, #88] ; 0x58 17f3c: e08160a1 add r6, r1, r1, lsr #1 17f40: e083aa36 add sl, r3, r6, lsr sl 17f44: eaffffe4 b 17edc <fat_set_fat_cluster+0x58>
}
}
break;
case FAT_FAT16:
*((uint16_t *)(sec_buf + ofs)) =
17f48: e59d3000 ldr r3, [sp]
(uint16_t )(CT_LE_W(in_val));
17f4c: e18390b6 strh r9, [r3, r6]
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
17f50: e3a03001 mov r3, #1 17f54: e5c43088 strb r3, [r4, #136] ; 0x88 17f58: eafffff4 b 17f30 <fat_set_fat_cluster+0xac>
return rc;
switch ( fs_info->vol.type )
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
17f5c: e3150001 tst r5, #1
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*(sec_buf + ofs) &= 0x0F;
17f60: e59d3000 ldr r3, [sp]
return rc;
switch ( fs_info->vol.type )
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
17f64: 0a00001d beq 17fe0 <fat_set_fat_cluster+0x15c>
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*(sec_buf + ofs) &= 0x0F;
17f68: e7d32006 ldrb r2, [r3, r6] 17f6c: e202200f and r2, r2, #15 17f70: e7c32006 strb r2, [r3, r6]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);
17f74: e59d3000 ldr r3, [sp] 17f78: e7d32006 ldrb r2, [r3, r6]
switch ( fs_info->vol.type )
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
17f7c: e1a09a09 lsl r9, r9, #20
*(sec_buf + ofs) &= 0x0F;
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);
17f80: e1822829 orr r2, r2, r9, lsr #16 17f84: e7c32006 strb r2, [r3, r6]
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
17f88: e1d430b0 ldrh r3, [r4] 17f8c: e2433001 sub r3, r3, #1 17f90: e1530006 cmp r3, r6 17f94: e5c48088 strb r8, [r4, #136] ; 0x88
17f98: 0a000026 beq 18038 <fat_set_fat_cluster+0x1b4>
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0x00;
17f9c: e59d3000 ldr r3, [sp] 17fa0: e2866001 add r6, r6, #1 17fa4: e7c30006 strb r0, [r3, r6]
*(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8);
17fa8: e59d3000 ldr r3, [sp] 17fac: e7d32006 ldrb r2, [r3, r6] 17fb0: e1829c29 orr r9, r2, r9, lsr #24 17fb4: e7c39006 strb r9, [r3, r6] 17fb8: eaffffdc b 17f30 <fat_set_fat_cluster+0xac>
break;
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
*((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
17fbc: e59d3000 ldr r3, [sp] 17fc0: 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));
17fc4: e3c9920f bic r9, r9, #-268435456 ; 0xf0000000
*((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);
17fc8: e202220f and r2, r2, #-268435456 ; 0xf0000000
*((uint32_t *)(sec_buf + ofs)) |= fat32_clv;
17fcc: e1829009 orr r9, r2, r9 17fd0: e7839006 str r9, [r3, r6] 17fd4: e3a03001 mov r3, #1 17fd8: e5c43088 strb r3, [r4, #136] ; 0x88 17fdc: eaffffd3 b 17f30 <fat_set_fat_cluster+0xac>
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*(sec_buf + ofs) &= 0x00;
17fe0: e7c30006 strb r0, [r3, r6]
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
17fe4: e59d3000 ldr r3, [sp]
*(sec_buf + ofs + 1) |= (uint8_t )((fat16_clv & 0xFF00)>>8);
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
17fe8: e1a09a09 lsl r9, r9, #20
*(sec_buf + ofs) &= 0x00;
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
17fec: 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;
17ff0: e1a09229 lsr r9, r9, #4
*(sec_buf + ofs) &= 0x00;
*(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);
17ff4: e1822829 orr r2, r2, r9, lsr #16 17ff8: e7c32006 strb r2, [r3, r6]
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
17ffc: e1d430b0 ldrh r3, [r4] 18000: e2433001 sub r3, r3, #1 18004: e1530006 cmp r3, r6 18008: e5c48088 strb r8, [r4, #136] ; 0x88
1800c: 0a000018 beq 18074 <fat_set_fat_cluster+0x1f0>
fat_buf_mark_modified(fs_info);
}
else
{
*(sec_buf + ofs + 1) &= 0xF0;
18010: e59d3000 ldr r3, [sp] 18014: e2866001 add r6, r6, #1 18018: e7d32006 ldrb r2, [r3, r6] 1801c: e3c2200f bic r2, r2, #15 18020: e7c32006 strb r2, [r3, r6]
*(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
18024: e59d3000 ldr r3, [sp] 18028: e7d32006 ldrb r2, [r3, r6] 1802c: e1829c29 orr r9, r2, r9, lsr #24 18030: e7c39006 strb r9, [r3, r6] 18034: eaffffbd b 17f30 <fat_set_fat_cluster+0xac>
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
18038: e1a00004 mov r0, r4 <== NOT EXECUTED 1803c: e28a1001 add r1, sl, #1 <== NOT EXECUTED 18040: e1a02008 mov r2, r8 <== NOT EXECUTED 18044: e1a0300d mov r3, sp <== NOT EXECUTED 18048: ebffe7e8 bl 11ff0 <fat_buf_access> <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
1804c: e3500000 cmp r0, #0 <== NOT EXECUTED 18050: 1affffb6 bne 17f30 <fat_set_fat_cluster+0xac> <== NOT EXECUTED
return rc;
*sec_buf &= 0x00;
18054: e59d3000 ldr r3, [sp] <== NOT EXECUTED 18058: e5c30000 strb r0, [r3] <== NOT EXECUTED
if (rc != RC_OK)
return rc;
*sec_buf &= 0xF0;
*sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);
1805c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 18060: e5d32000 ldrb r2, [r3] <== NOT EXECUTED 18064: e1829c29 orr r9, r2, r9, lsr #24 <== NOT EXECUTED 18068: e5c39000 strb r9, [r3] <== NOT EXECUTED 1806c: e5c48088 strb r8, [r4, #136] ; 0x88 <== NOT EXECUTED 18070: eaffffae b 17f30 <fat_set_fat_cluster+0xac> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
18074: e1a00004 mov r0, r4 <== NOT EXECUTED 18078: e28a1001 add r1, sl, #1 <== NOT EXECUTED 1807c: e1a02008 mov r2, r8 <== NOT EXECUTED 18080: e1a0300d mov r3, sp <== NOT EXECUTED 18084: ebffe7d9 bl 11ff0 <fat_buf_access> <== NOT EXECUTED
&sec_buf);
if (rc != RC_OK)
18088: e3500000 cmp r0, #0 <== NOT EXECUTED 1808c: 1affffa7 bne 17f30 <fat_set_fat_cluster+0xac> <== NOT EXECUTED
return rc;
*sec_buf &= 0xF0;
18090: e59d3000 ldr r3, [sp] <== NOT EXECUTED 18094: e5d32000 ldrb r2, [r3] <== NOT EXECUTED 18098: e3c2200f bic r2, r2, #15 <== NOT EXECUTED 1809c: e5c32000 strb r2, [r3] <== NOT EXECUTED 180a0: eaffffed b 1805c <fat_set_fat_cluster+0x1d8> <== NOT EXECUTED
00012cac <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)
{
12cac: e92d41f0 push {r4, r5, r6, r7, r8, lr}
12cb0: e1a05000 mov r5, r0
int rc = RC_OK;
int i = 0;
rc = fat_sync(fs_info);
12cb4: ebffffcc bl 12bec <fat_sync>
if ( rc != RC_OK )
rc = -1;
12cb8: e2508000 subs r8, r0, #0 12cbc: 13e08000 mvnne r8, #0 12cc0: 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;
12cc4: e595406c ldr r4, [r5, #108] ; 0x6c 12cc8: e0844007 add r4, r4, r7
while ( (node = rtems_chain_get(the_chain)) != NULL )
12ccc: ea000000 b 12cd4 <fat_shutdown_drive+0x28>
free(node);
12cd0: ebffc5a1 bl 435c <free> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
12cd4: e1a00004 mov r0, r4 12cd8: ebffd987 bl 92fc <_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 )
12cdc: e2506000 subs r6, r0, #0
12ce0: 1afffffa bne 12cd0 <fat_shutdown_drive+0x24>
12ce4: e287700c add r7, r7, #12
rc = fat_sync(fs_info);
if ( rc != RC_OK )
rc = -1;
for (i = 0; i < FAT_HASH_SIZE; i++)
12ce8: e3570018 cmp r7, #24
12cec: 1afffff4 bne 12cc4 <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;
12cf0: e5954070 ldr r4, [r5, #112] ; 0x70 12cf4: e0844006 add r4, r4, r6
while ( (node = rtems_chain_get(the_chain)) != NULL )
12cf8: ea000000 b 12d00 <fat_shutdown_drive+0x54>
free(node);
12cfc: ebffc596 bl 435c <free> <== NOT EXECUTED
12d00: e1a00004 mov r0, r4 12d04: ebffd97c bl 92fc <_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 )
12d08: e3500000 cmp r0, #0
12d0c: 1afffffa bne 12cfc <fat_shutdown_drive+0x50>
12d10: e286600c add r6, r6, #12
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
for (i = 0; i < FAT_HASH_SIZE; i++)
12d14: e3560018 cmp r6, #24
12d18: 1afffff4 bne 12cf0 <fat_shutdown_drive+0x44>
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
12d1c: e595006c ldr r0, [r5, #108] ; 0x6c 12d20: ebffc58d bl 435c <free>
free(fs_info->rhash);
12d24: e5950070 ldr r0, [r5, #112] ; 0x70 12d28: ebffc58b bl 435c <free>
free(fs_info->uino);
12d2c: e5950074 ldr r0, [r5, #116] ; 0x74 12d30: ebffc589 bl 435c <free>
free(fs_info->sec_buf);
12d34: e5950090 ldr r0, [r5, #144] ; 0x90 12d38: ebffc587 bl 435c <free>
close(fs_info->vol.fd);
12d3c: e5950060 ldr r0, [r5, #96] ; 0x60 12d40: ebffc4dc bl 40b8 <close>
if (rc)
12d44: e3580000 cmp r8, #0
12d48: 0a000002 beq 12d58 <fat_shutdown_drive+0xac>
errno = EIO;
12d4c: eb001ad8 bl 198b4 <__errno> <== NOT EXECUTED 12d50: e3a03005 mov r3, #5 <== NOT EXECUTED 12d54: e5803000 str r3, [r0] <== NOT EXECUTED
return rc;
}
12d58: e1a00008 mov r0, r8
12d5c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
00012bec <fat_sync>:
return RC_OK;
}
int
fat_sync(fat_fs_info_t *fs_info)
{
12bec: e92d4070 push {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)
12bf0: e5d0300e ldrb r3, [r0, #14] 12bf4: e3530004 cmp r3, #4
return RC_OK;
}
int
fat_sync(fat_fs_info_t *fs_info)
{
12bf8: e24dd008 sub sp, sp, #8 12bfc: e1a04000 mov r4, r0
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)
12c00: 0a000009 beq 12c2c <fat_sync+0x40>
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
sizeof(le_free_count),
&le_free_count);
}
if (next_free != fs_info->vol.next_cl_in_fs_info)
12c04: e3a05000 mov r5, #0
rc = fat_fat32_update_fsinfo_sector(fs_info);
if ( rc != RC_OK )
rc = -1;
fat_buf_release(fs_info);
12c08: e1a00004 mov r0, r4 12c0c: ebfffc8e bl 11e4c <fat_buf_release>
if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)
12c10: e5940064 ldr r0, [r4, #100] ; 0x64 12c14: ebfff5c2 bl 10324 <rtems_bdbuf_syncdev> 12c18: e3500000 cmp r0, #0
rc = -1;
return rc;
}
12c1c: 01a00005 moveq r0, r5
12c20: 13e00000 mvnne r0, #0
12c24: e28dd008 add sp, sp, #8
12c28: e8bd8070 pop {r4, r5, r6, pc}
{
ssize_t ret1 = 0, ret2 = 0;
if (fs_info->vol.type == FAT_FAT32)
{
uint32_t free_count = fs_info->vol.free_cls;
12c2c: e5902044 ldr r2, [r0, #68] ; 0x44
uint32_t next_free = fs_info->vol.next_cl;
if (free_count != fs_info->vol.free_cls_in_fs_info)
12c30: e5901048 ldr r1, [r0, #72] ; 0x48 12c34: e1520001 cmp r2, r1
ssize_t ret1 = 0, ret2 = 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;
12c38: e590504c ldr r5, [r0, #76] ; 0x4c
if (free_count != fs_info->vol.free_cls_in_fs_info)
12c3c: 03a06000 moveq r6, #0
12c40: 0a000007 beq 12c64 <fat_sync+0x78>
{
uint32_t le_free_count = CT_LE_L(free_count);
12c44: e28dc008 add ip, sp, #8 <== NOT EXECUTED 12c48: e52c2004 str r2, [ip, #-4]! <== NOT EXECUTED
fs_info->vol.free_cls_in_fs_info = free_count;
12c4c: e5802048 str r2, [r0, #72] ; 0x48 <== NOT EXECUTED
ret1 = fat_sector_write(fs_info,
12c50: e1d014b0 ldrh r1, [r0, #64] ; 0x40 <== NOT EXECUTED 12c54: e3a02f7a mov r2, #488 ; 0x1e8 <== NOT EXECUTED 12c58: e58dc000 str ip, [sp] <== NOT EXECUTED 12c5c: ebfffd33 bl 12130 <fat_sector_write> <== NOT EXECUTED 12c60: e1a06fa0 lsr r6, r0, #31 <== 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)
12c64: e5943050 ldr r3, [r4, #80] ; 0x50 12c68: e1550003 cmp r5, r3 12c6c: 03a00000 moveq r0, #0
12c70: 0a000009 beq 12c9c <fat_sync+0xb0>
{
uint32_t le_next_free = CT_LE_L(next_free);
12c74: e28dc008 add ip, sp, #8 12c78: e52c5004 str r5, [ip, #-4]!
fs_info->vol.next_cl_in_fs_info = next_free;
ret2 = fat_sector_write(fs_info,
12c7c: e1d414b0 ldrh r1, [r4, #64] ; 0x40
if (next_free != fs_info->vol.next_cl_in_fs_info)
{
uint32_t le_next_free = CT_LE_L(next_free);
fs_info->vol.next_cl_in_fs_info = next_free;
12c80: e5845050 str r5, [r4, #80] ; 0x50
ret2 = fat_sector_write(fs_info,
12c84: e1a00004 mov r0, r4 12c88: e3a02f7b mov r2, #492 ; 0x1ec 12c8c: e3a03004 mov r3, #4 12c90: e58dc000 str ip, [sp] 12c94: ebfffd25 bl 12130 <fat_sector_write> 12c98: e1a00fa0 lsr r0, r0, #31
sizeof(le_next_free),
&le_next_free);
}
}
if ( (ret1 < 0) || (ret2 < 0) )
12c9c: e1900006 orrs r0, r0, r6
12ca0: 0affffd7 beq 12c04 <fat_sync+0x18>
{
int rc = RC_OK;
rc = fat_fat32_update_fsinfo_sector(fs_info);
if ( rc != RC_OK )
rc = -1;
12ca4: e3e05000 mvn r5, #0 <== NOT EXECUTED 12ca8: eaffffd6 b 12c08 <fat_sync+0x1c> <== NOT EXECUTED
00023178 <fchmod>:
int fchmod( int fd, mode_t mode )
{
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
23178: e59f30ac ldr r3, [pc, #172] ; 2322c <fchmod+0xb4> 2317c: e5933000 ldr r3, [r3] 23180: e1500003 cmp r0, r3
/**
* POSIX 1003.1b 5.6.4 - Change File Modes
*/
int fchmod( int fd, mode_t mode )
{
23184: e92d4030 push {r4, r5, lr}
23188: e1a05001 mov r5, r1
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2318c: 2a000021 bcs 23218 <fchmod+0xa0>
iop = rtems_libio_iop( fd );
23190: e59f3098 ldr r3, [pc, #152] ; 23230 <fchmod+0xb8> 23194: e5933000 ldr r3, [r3] 23198: e0800080 add r0, r0, r0, lsl #1 2319c: e0834200 add r4, r3, r0, lsl #4
rtems_libio_check_is_open(iop);
231a0: e594300c ldr r3, [r4, #12] 231a4: e3130c01 tst r3, #256 ; 0x100
231a8: 0a00001a beq 23218 <fchmod+0xa0>
if (iop->pathinfo.mt_entry->writeable) {
231ac: e5943024 ldr r3, [r4, #36] ; 0x24 231b0: e5d32029 ldrb r2, [r3, #41] ; 0x29 231b4: e3520000 cmp r2, #0
231b8: 1a000005 bne 231d4 <fchmod+0x5c>
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode );
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
231bc: eb004aae bl 35c7c <__errno> <== NOT EXECUTED 231c0: e3a0301e mov r3, #30 <== NOT EXECUTED 231c4: e5803000 str r3, [r0] <== NOT EXECUTED
rv = -1;
231c8: e3e05000 mvn r5, #0 <== NOT EXECUTED
}
return rv;
}
231cc: e1a00005 mov r0, r5
231d0: e8bd8030 pop {r4, r5, pc}
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 );
231d4: e1a00003 mov r0, r3 231d8: e593300c ldr r3, [r3, #12] 231dc: e1a0e00f mov lr, pc 231e0: e593f000 ldr pc, [r3]
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
if (iop->pathinfo.mt_entry->writeable) {
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode );
231e4: e5943024 ldr r3, [r4, #36] ; 0x24 231e8: e1a01005 mov r1, r5 231ec: e2840010 add r0, r4, #16 231f0: e593300c ldr r3, [r3, #12] 231f4: e1a0e00f mov lr, pc 231f8: e593f020 ldr pc, [r3, #32] 231fc: 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;
23200: e5940024 ldr r0, [r4, #36] ; 0x24
(*mt_entry->ops->unlock_h)( mt_entry );
23204: e590300c ldr r3, [r0, #12] 23208: e1a0e00f mov lr, pc 2320c: e593f004 ldr pc, [r3, #4]
errno = EROFS;
rv = -1;
}
return rv;
}
23210: e1a00005 mov r0, r5
23214: e8bd8030 pop {r4, r5, pc}
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
23218: eb004a97 bl 35c7c <__errno> 2321c: e3a03009 mov r3, #9 23220: e5803000 str r3, [r0] 23224: e3e05000 mvn r5, #0 23228: eaffffe7 b 231cc <fchmod+0x54>
00023234 <fchown>:
int fchown( int fd, uid_t owner, gid_t group )
{
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
23234: e59f30bc ldr r3, [pc, #188] ; 232f8 <fchown+0xc4> 23238: 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 )
{
2323c: e1a01801 lsl r1, r1, #16 23240: e1a02802 lsl r2, r2, #16
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
23244: 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 )
{
23248: e92d4070 push {r4, r5, r6, lr}
2324c: e1a06821 lsr r6, r1, #16
23250: e1a05822 lsr r5, r2, #16
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
23254: 2a000022 bcs 232e4 <fchown+0xb0>
iop = rtems_libio_iop( fd );
23258: e59f309c ldr r3, [pc, #156] ; 232fc <fchown+0xc8> 2325c: e5933000 ldr r3, [r3] 23260: e0800080 add r0, r0, r0, lsl #1 23264: e0834200 add r4, r3, r0, lsl #4
rtems_libio_check_is_open(iop);
23268: e594300c ldr r3, [r4, #12] 2326c: e3130c01 tst r3, #256 ; 0x100
23270: 0a00001b beq 232e4 <fchown+0xb0>
if (iop->pathinfo.mt_entry->writeable) {
23274: e5943024 ldr r3, [r4, #36] ; 0x24 23278: e5d32029 ldrb r2, [r3, #41] ; 0x29 2327c: e3520000 cmp r2, #0
23280: 1a000005 bne 2329c <fchown+0x68>
owner,
group
);
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
23284: eb004a7c bl 35c7c <__errno> <== NOT EXECUTED 23288: e3a0301e mov r3, #30 <== NOT EXECUTED 2328c: e5803000 str r3, [r0] <== NOT EXECUTED
rv = -1;
23290: e3e05000 mvn r5, #0 <== NOT EXECUTED
}
return rv;
}
23294: e1a00005 mov r0, r5
23298: e8bd8070 pop {r4, r5, r6, pc}
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 );
2329c: e1a00003 mov r0, r3 232a0: e593300c ldr r3, [r3, #12] 232a4: e1a0e00f mov lr, pc 232a8: e593f000 ldr pc, [r3]
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
if (iop->pathinfo.mt_entry->writeable) {
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->chown_h)(
232ac: e5943024 ldr r3, [r4, #36] ; 0x24 232b0: e1a02005 mov r2, r5 232b4: e1a01006 mov r1, r6 232b8: e2840010 add r0, r4, #16 232bc: e593300c ldr r3, [r3, #12] 232c0: e1a0e00f mov lr, pc 232c4: e593f024 ldr pc, [r3, #36] ; 0x24 232c8: 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;
232cc: e5940024 ldr r0, [r4, #36] ; 0x24
(*mt_entry->ops->unlock_h)( mt_entry );
232d0: e590300c ldr r3, [r0, #12] 232d4: e1a0e00f mov lr, pc 232d8: e593f004 ldr pc, [r3, #4]
errno = EROFS;
rv = -1;
}
return rv;
}
232dc: e1a00005 mov r0, r5
232e0: e8bd8070 pop {r4, r5, r6, pc}
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
232e4: eb004a64 bl 35c7c <__errno> 232e8: e3a03009 mov r3, #9 232ec: e5803000 str r3, [r0] 232f0: e3e05000 mvn r5, #0 232f4: eaffffe6 b 23294 <fchown+0x60>
0002f17c <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
2f17c: e92d000e push {r1, r2, r3}
2f180: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
2f184: e59f31f8 ldr r3, [pc, #504] ; 2f384 <fcntl+0x208> 2f188: e5933000 ldr r3, [r3]
int fcntl(
int fd,
int cmd,
...
)
{
2f18c: e24dd004 sub sp, sp, #4
int ret; va_list ap; va_start( ap, cmd );
2f190: e28d2024 add r2, sp, #36 ; 0x24
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
2f194: e1500003 cmp r0, r3
int fcntl(
int fd,
int cmd,
...
)
{
2f198: e59d4020 ldr r4, [sp, #32]
int ret; va_list ap; va_start( ap, cmd );
2f19c: e58d2000 str r2, [sp]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
2f1a0: 2a00006f bcs 2f364 <fcntl+0x1e8>
iop = rtems_libio_iop( fd );
2f1a4: e59f61dc ldr r6, [pc, #476] ; 2f388 <fcntl+0x20c> 2f1a8: e5963000 ldr r3, [r6] 2f1ac: e0800080 add r0, r0, r0, lsl #1 2f1b0: e0835200 add r5, r3, r0, lsl #4
rtems_libio_check_is_open(iop);
2f1b4: e595000c ldr r0, [r5, #12] 2f1b8: e3100c01 tst r0, #256 ; 0x100
2f1bc: 0a000068 beq 2f364 <fcntl+0x1e8>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
2f1c0: e3540009 cmp r4, #9 2f1c4: 979ff104 ldrls pc, [pc, r4, lsl #2] 2f1c8: ea000026 b 2f268 <fcntl+0xec> 2f1cc: 0002f278 .word 0x0002f278
2f1d0: 0002f328 .word 0x0002f328 <== NOT EXECUTED 2f1d4: 0002f338 .word 0x0002f338 <== NOT EXECUTED 2f1d8: 0002f358 .word 0x0002f358 <== NOT EXECUTED 2f1dc: 0002f218 .word 0x0002f218 <== NOT EXECUTED 2f1e0: 0002f1f4 .word 0x0002f1f4 <== NOT EXECUTED 2f1e4: 0002f1f4 .word 0x0002f1f4 <== NOT EXECUTED 2f1e8: 0002f1f4 .word 0x0002f1f4 <== NOT EXECUTED 2f1ec: 0002f1f4 .word 0x0002f1f4 <== NOT EXECUTED 2f1f0: 0002f1f4 .word 0x0002f1f4 <== NOT EXECUTED
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
2f1f4: ebffc0e6 bl 1f594 <__errno> 2f1f8: e3a03086 mov r3, #134 ; 0x86 2f1fc: e5803000 str r3, [r0]
if (ret >= 0) {
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
if (err) {
errno = err;
ret = -1;
2f200: e3e08000 mvn r8, #0
va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; }
2f204: e1a00008 mov r0, r8
2f208: e28dd004 add sp, sp, #4
2f20c: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr}
2f210: e28dd00c add sp, sp, #12
2f214: e12fff1e bx lr
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
2f218: e5920000 ldr r0, [r2] 2f21c: ebff60d0 bl 7564 <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
2f220: e595200c ldr r2, [r5, #12] 2f224: e59f3160 ldr r3, [pc, #352] ; 2f38c <fcntl+0x210> 2f228: e3c22c02 bic r2, r2, #512 ; 0x200 2f22c: e0003003 and r3, r0, r3 2f230: e3c22001 bic r2, r2, #1 2f234: e1833002 orr r3, r3, r2 2f238: e585300c str r3, [r5, #12]
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
2f23c: e3a08000 mov r8, #0
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
2f240: e1a01004 mov r1, r4 2f244: e5953020 ldr r3, [r5, #32] 2f248: e1a00005 mov r0, r5 2f24c: e1a0e00f mov lr, pc 2f250: e593f028 ldr pc, [r3, #40] ; 0x28
if (err) {
2f254: e2504000 subs r4, r0, #0
2f258: 0affffe9 beq 2f204 <fcntl+0x88>
errno = err;
2f25c: ebffc0cc bl 1f594 <__errno> <== NOT EXECUTED 2f260: e5804000 str r4, [r0] <== NOT EXECUTED 2f264: eaffffe5 b 2f200 <fcntl+0x84> <== NOT EXECUTED
errno = ENOTSUP;
ret = -1;
break;
default:
errno = EINVAL;
2f268: ebffc0c9 bl 1f594 <__errno> 2f26c: e3a03016 mov r3, #22 2f270: e5803000 str r3, [r0] 2f274: eaffffe1 b 2f200 <fcntl+0x84>
/*
* FIXME: We ignore the start value fd2 for the file descriptor search. This
* is not POSIX conform.
*/
rtems_libio_t *diop = rtems_libio_allocate();
2f278: ebff60d9 bl 75e4 <rtems_libio_allocate>
if (diop != NULL) {
2f27c: e2507000 subs r7, r0, #0
2f280: 0affffde beq 2f200 <fcntl+0x84>
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
2f284: e595000c ldr r0, [r5, #12] 2f288: ebff60c2 bl 7598 <rtems_libio_to_fcntl_flags>
oflag &= ~O_CREAT;
2f28c: e3c08c02 bic r8, r0, #512 ; 0x200
diop->flags |= rtems_libio_fcntl_flags( oflag );
2f290: e1a00008 mov r0, r8 2f294: e597a00c ldr sl, [r7, #12] 2f298: ebff60b1 bl 7564 <rtems_libio_fcntl_flags>
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;
2f29c: e5953024 ldr r3, [r5, #36] ; 0x24 2f2a0: e180000a orr r0, r0, sl 2f2a4: e587000c str r0, [r7, #12]
(*mt_entry->ops->lock_h)( mt_entry );
2f2a8: e1a00003 mov r0, r3 2f2ac: e593300c ldr r3, [r3, #12] 2f2b0: e1a0e00f mov lr, pc 2f2b4: e593f000 ldr pc, [r3]
rtems_filesystem_instance_lock( &iop->pathinfo );
rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
2f2b8: e2851010 add r1, r5, #16 2f2bc: e2870010 add r0, r7, #16 2f2c0: ebff9b1f bl 15f44 <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;
2f2c4: e5953024 ldr r3, [r5, #36] ; 0x24
(*mt_entry->ops->unlock_h)( mt_entry );
2f2c8: e1a00003 mov r0, r3 2f2cc: e593300c ldr r3, [r3, #12] 2f2d0: e1a0e00f mov lr, pc 2f2d4: 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 );
2f2d8: e3a01000 mov r1, #0 2f2dc: e1a02008 mov r2, r8 2f2e0: e597c020 ldr ip, [r7, #32] 2f2e4: e1a00007 mov r0, r7 2f2e8: e1a03001 mov r3, r1 2f2ec: e1a0e00f mov lr, pc 2f2f0: e59cf000 ldr pc, [ip]
if ( rv == 0 ) {
2f2f4: e2508000 subs r8, r0, #0
2f2f8: 1a00001e bne 2f378 <fcntl+0x1fc>
rv = diop - rtems_libio_iops;
2f2fc: e5963000 ldr r3, [r6] 2f300: e0637007 rsb r7, r3, r7 2f304: e1a07247 asr r7, r7, #4 2f308: e0878107 add r8, r7, r7, lsl #2 2f30c: e0888208 add r8, r8, r8, lsl #4 2f310: e0888408 add r8, r8, r8, lsl #8 2f314: e0888808 add r8, r8, r8, lsl #16 2f318: e0878088 add r8, r7, r8, lsl #1
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
2f31c: e3580000 cmp r8, #0
2f320: aaffffc6 bge 2f240 <fcntl+0xc4>
2f324: eaffffb6 b 2f204 <fcntl+0x88> <== 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);
2f328: e3100b02 tst r0, #2048 ; 0x800 2f32c: 03a08000 moveq r8, #0 2f330: 13a08001 movne r8, #1 2f334: eaffffc1 b 2f240 <fcntl+0xc4>
* 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 ) )
2f338: e5928000 ldr r8, [r2] 2f33c: e3580000 cmp r8, #0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
2f340: 13800b02 orrne r0, r0, #2048 ; 0x800
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
2f344: 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;
2f348: 1585000c strne r0, [r5, #12]
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
2f34c: 13a08000 movne r8, #0
*/
if ( va_arg( ap, int ) )
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
2f350: 0585000c streq r0, [r5, #12] 2f354: eaffffb9 b 2f240 <fcntl+0xc4>
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
2f358: ebff608e bl 7598 <rtems_libio_to_fcntl_flags> 2f35c: e1a08000 mov r8, r0 2f360: eaffffed b 2f31c <fcntl+0x1a0>
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
2f364: ebffc08a bl 1f594 <__errno> 2f368: e3a03009 mov r3, #9 2f36c: e5803000 str r3, [r0] 2f370: e3e08000 mvn r8, #0 2f374: eaffffa2 b 2f204 <fcntl+0x88>
*/
rv = (*diop->pathinfo.handlers->open_h)( diop, NULL, oflag, 0 );
if ( rv == 0 ) {
rv = diop - rtems_libio_iops;
} else {
rtems_libio_free( diop );
2f378: e1a00007 mov r0, r7 <== NOT EXECUTED 2f37c: ebff60b0 bl 7644 <rtems_libio_free> <== NOT EXECUTED 2f380: eaffffe5 b 2f31c <fcntl+0x1a0> <== NOT EXECUTED
0000cac8 <fifo_open>:
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
cac8: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
cacc: e59f441c ldr r4, [pc, #1052] ; cef0 <fifo_open+0x428>
cad0: e5948000 ldr r8, [r4]
cad4: e3580000 cmp r8, #0
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
cad8: e24dd008 sub sp, sp, #8
cadc: e1a05000 mov r5, r0
cae0: e1a07001 mov r7, r1
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
cae4: 0a000025 beq cb80 <fifo_open+0xb8>
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
cae8: e3a01000 mov r1, #0
caec: e1a00008 mov r0, r8
caf0: e1a02001 mov r2, r1
caf4: ebffece9 bl 7ea0 <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
caf8: e250a000 subs sl, r0, #0
cafc: 1a0000d0 bne ce44 <fifo_open+0x37c>
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
cb00: e5956000 ldr r6, [r5]
if (pipe == NULL) {
cb04: e3560000 cmp r6, #0
cb08: 0a000080 beq cd10 <fifo_open+0x248>
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
cb0c: e3a01000 mov r1, #0
cb10: e5960028 ldr r0, [r6, #40] ; 0x28
cb14: e1a02001 mov r2, r1
cb18: ebffece0 bl 7ea0 <rtems_semaphore_obtain>
err = -EINTR;
if (*pipep == NULL) {
cb1c: e5953000 ldr r3, [r5]
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
cb20: e3500000 cmp r0, #0
cb24: 01a08000 moveq r8, r0
cb28: 13e08003 mvnne r8, #3
err = -EINTR;
if (*pipep == NULL) {
cb2c: e3530000 cmp r3, #0
cb30: 0a0000b2 beq ce00 <fifo_open+0x338>
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
cb34: e5940000 ldr r0, [r4]
cb38: ebffed21 bl 7fc4 <rtems_semaphore_release>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
cb3c: e3580000 cmp r8, #0
cb40: 1a00000b bne cb74 <fifo_open+0xac>
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
cb44: e597300c ldr r3, [r7, #12]
cb48: e2033006 and r3, r3, #6
cb4c: e3530004 cmp r3, #4
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
cb50: e5954000 ldr r4, [r5]
switch (LIBIO_ACCMODE(iop)) {
cb54: 0a000015 beq cbb0 <fifo_open+0xe8>
cb58: e3530006 cmp r3, #6
cb5c: 0a000057 beq ccc0 <fifo_open+0x1f8>
cb60: e3530002 cmp r3, #2
cb64: 0a000035 beq cc40 <fifo_open+0x178>
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
cb68: e5940028 ldr r0, [r4, #40] ; 0x28
cb6c: ebffed14 bl 7fc4 <rtems_semaphore_release>
return 0;
cb70: e3a08000 mov r8, #0
out_error:
pipe_release(pipep, iop);
return err;
}
cb74: e1a00008 mov r0, r8
cb78: e28dd008 add sp, sp, #8
cb7c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
cb80: e59f636c ldr r6, [pc, #876] ; cef4 <fifo_open+0x42c>
cb84: e1a01008 mov r1, r8
cb88: e5960000 ldr r0, [r6]
cb8c: e1a02008 mov r2, r8
cb90: ebffecc2 bl 7ea0 <rtems_semaphore_obtain>
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
cb94: e5943000 ldr r3, [r4]
cb98: e3530000 cmp r3, #0
cb9c: 0a00009d beq ce18 <fifo_open+0x350>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
cba0: e5960000 ldr r0, [r6] <== NOT EXECUTED
cba4: ebffed06 bl 7fc4 <rtems_semaphore_release> <== NOT EXECUTED
cba8: e5948000 ldr r8, [r4] <== NOT EXECUTED
cbac: eaffffcd b cae8 <fifo_open+0x20> <== NOT EXECUTED
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
cbb0: e5943014 ldr r3, [r4, #20]
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
cbb4: e5941024 ldr r1, [r4, #36] ; 0x24
if (pipe->Writers ++ == 0)
cbb8: e2832001 add r2, r3, #1
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
cbbc: e2811001 add r1, r1, #1
if (pipe->Writers ++ == 0)
cbc0: e3530000 cmp r3, #0
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
cbc4: e5841024 str r1, [r4, #36] ; 0x24
if (pipe->Writers ++ == 0)
cbc8: e5842014 str r2, [r4, #20]
cbcc: 0a00009e beq ce4c <fifo_open+0x384>
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
cbd0: e5943010 ldr r3, [r4, #16]
cbd4: e3530000 cmp r3, #0
cbd8: 1affffe2 bne cb68 <fifo_open+0xa0>
cbdc: e597300c ldr r3, [r7, #12]
cbe0: e3130001 tst r3, #1
err = -ENXIO;
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
cbe4: 05946020 ldreq r6, [r4, #32]
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
cbe8: 0a000007 beq cc0c <fifo_open+0x144>
cbec: ea0000af b ceb0 <fifo_open+0x3e8>
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
cbf0: e5940028 ldr r0, [r4, #40] ; 0x28
cbf4: ebffeca9 bl 7ea0 <rtems_semaphore_obtain>
cbf8: e3500000 cmp r0, #0
cbfc: 1a00000a bne cc2c <fifo_open+0x164>
goto out_error;
} while (prevCounter == pipe->readerCounter);
cc00: e5943020 ldr r3, [r4, #32]
cc04: e1530006 cmp r3, r6
cc08: 1affffd6 bne cb68 <fifo_open+0xa0>
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
cc0c: e5940028 ldr r0, [r4, #40] ; 0x28
cc10: ebffeceb bl 7fc4 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
cc14: e3a01000 mov r1, #0
cc18: e5940030 ldr r0, [r4, #48] ; 0x30
cc1c: eb000495 bl de78 <rtems_barrier_wait>
cc20: e2501000 subs r1, r0, #0
goto out_error;
if (! PIPE_LOCK(pipe))
cc24: e1a02001 mov r2, r1
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
cc28: 0afffff0 beq cbf0 <fifo_open+0x128>
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
cc2c: e3e08003 mvn r8, #3 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
cc30: e1a00005 mov r0, r5
cc34: e1a01007 mov r1, r7
cc38: ebffff69 bl c9e4 <pipe_release>
return err;
cc3c: eaffffcc b cb74 <fifo_open+0xac>
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
cc40: e5943010 ldr r3, [r4, #16]
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
cc44: e5941020 ldr r1, [r4, #32]
if (pipe->Readers ++ == 0)
cc48: e2832001 add r2, r3, #1
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
cc4c: e2811001 add r1, r1, #1
if (pipe->Readers ++ == 0)
cc50: e3530000 cmp r3, #0
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
cc54: e5841020 str r1, [r4, #32]
if (pipe->Readers ++ == 0)
cc58: e5842010 str r2, [r4, #16]
cc5c: 0a000082 beq ce6c <fifo_open+0x3a4>
PIPE_WAKEUPWRITERS(pipe);
if (pipe->Writers == 0) {
cc60: e5943014 ldr r3, [r4, #20]
cc64: e3530000 cmp r3, #0
cc68: 1affffbe bne cb68 <fifo_open+0xa0>
/* Not an error */
if (LIBIO_NODELAY(iop))
cc6c: e597300c ldr r3, [r7, #12]
cc70: e3130001 tst r3, #1
cc74: 1affffbb bne cb68 <fifo_open+0xa0>
break;
prevCounter = pipe->writerCounter;
cc78: e5946024 ldr r6, [r4, #36] ; 0x24
cc7c: ea000006 b cc9c <fifo_open+0x1d4>
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
cc80: e5940028 ldr r0, [r4, #40] ; 0x28
cc84: ebffec85 bl 7ea0 <rtems_semaphore_obtain>
cc88: e3500000 cmp r0, #0
cc8c: 1affffe6 bne cc2c <fifo_open+0x164>
goto out_error;
} while (prevCounter == pipe->writerCounter);
cc90: e5943024 ldr r3, [r4, #36] ; 0x24
cc94: e1530006 cmp r3, r6
cc98: 1affffb2 bne cb68 <fifo_open+0xa0>
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
cc9c: e5940028 ldr r0, [r4, #40] ; 0x28
cca0: ebffecc7 bl 7fc4 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
cca4: e3a01000 mov r1, #0
cca8: e594002c ldr r0, [r4, #44] ; 0x2c
ccac: eb000471 bl de78 <rtems_barrier_wait>
ccb0: e2501000 subs r1, r0, #0
goto out_error;
if (! PIPE_LOCK(pipe))
ccb4: e1a02001 mov r2, r1
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ccb8: 0afffff0 beq cc80 <fifo_open+0x1b8>
ccbc: eaffffda b cc2c <fifo_open+0x164> <== NOT EXECUTED
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
ccc0: e5943010 ldr r3, [r4, #16]
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
ccc4: e5941020 ldr r1, [r4, #32]
if (pipe->Readers ++ == 0)
ccc8: e2832001 add r2, r3, #1
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
cccc: e2811001 add r1, r1, #1
if (pipe->Readers ++ == 0)
ccd0: e3530000 cmp r3, #0
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
ccd4: e5841020 str r1, [r4, #32]
if (pipe->Readers ++ == 0)
ccd8: e5842010 str r2, [r4, #16]
ccdc: 0a00005e beq ce5c <fifo_open+0x394>
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
cce0: e5943014 ldr r3, [r4, #20]
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
cce4: e5941024 ldr r1, [r4, #36] ; 0x24
if (pipe->Writers ++ == 0)
cce8: e2832001 add r2, r3, #1
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
ccec: e2811001 add r1, r1, #1
if (pipe->Writers ++ == 0)
ccf0: e3530000 cmp r3, #0
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
ccf4: e5841024 str r1, [r4, #36] ; 0x24
if (pipe->Writers ++ == 0)
ccf8: e5842014 str r2, [r4, #20]
ccfc: 1affff99 bne cb68 <fifo_open+0xa0>
PIPE_WAKEUPREADERS(pipe);
cd00: e594002c ldr r0, [r4, #44] ; 0x2c
cd04: e28d1004 add r1, sp, #4
cd08: eb000442 bl de18 <rtems_barrier_release>
cd0c: eaffff95 b cb68 <fifo_open+0xa0>
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
cd10: e3a00034 mov r0, #52 ; 0x34
cd14: ebffdbac bl 3bcc <malloc>
if (pipe == NULL)
cd18: e2506000 subs r6, r0, #0
cd1c: 0a00006f beq cee0 <fifo_open+0x418>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
cd20: e1a02006 mov r2, r6
cd24: e482a004 str sl, [r2], #4
cd28: e2822004 add r2, r2, #4
cd2c: e482a004 str sl, [r2], #4
cd30: e482a004 str sl, [r2], #4
cd34: e482a004 str sl, [r2], #4
cd38: e482a004 str sl, [r2], #4
cd3c: e482a004 str sl, [r2], #4
cd40: e482a004 str sl, [r2], #4
cd44: e482a004 str sl, [r2], #4
cd48: e482a004 str sl, [r2], #4
cd4c: e482a004 str sl, [r2], #4
cd50: e482a004 str sl, [r2], #4
pipe->Size = PIPE_BUF;
cd54: e3a03c02 mov r3, #512 ; 0x200
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
cd58: e582a000 str sl, [r2]
pipe->Size = PIPE_BUF;
pipe->Buffer = malloc(pipe->Size);
cd5c: e1a00003 mov r0, r3
pipe = malloc(sizeof(pipe_control_t));
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
pipe->Size = PIPE_BUF;
cd60: e5863004 str r3, [r6, #4]
pipe->Buffer = malloc(pipe->Size);
cd64: ebffdb98 bl 3bcc <malloc>
if (! pipe->Buffer)
cd68: 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);
cd6c: e5860000 str r0, [r6]
if (! pipe->Buffer)
cd70: 0a000058 beq ced8 <fifo_open+0x410>
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
cd74: e59f817c ldr r8, [pc, #380] ; cef8 <fifo_open+0x430>
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
cd78: e59f017c ldr r0, [pc, #380] ; cefc <fifo_open+0x434>
rtems_build_name ('P', 'I', 'r', c),
cd7c: e5d83000 ldrb r3, [r8]
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
cd80: e1a0100a mov r1, sl
cd84: e1830000 orr r0, r3, r0
cd88: e1a0200a mov r2, sl
cd8c: e286302c add r3, r6, #44 ; 0x2c
cd90: eb0003c3 bl dca4 <rtems_barrier_create>
cd94: e2501000 subs r1, r0, #0
cd98: 1a00004c bne ced0 <fifo_open+0x408>
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),
cd9c: e5d83000 ldrb r3, [r8]
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(
cda0: e59f0158 ldr r0, [pc, #344] ; cf00 <fifo_open+0x438>
cda4: e1a02001 mov r2, r1
cda8: e1830000 orr r0, r3, r0
cdac: e2863030 add r3, r6, #48 ; 0x30
cdb0: eb0003bb bl dca4 <rtems_barrier_create>
cdb4: e2503000 subs r3, r0, #0
cdb8: 1a000042 bne cec8 <fifo_open+0x400>
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,
cdbc: e5d82000 ldrb r2, [r8]
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(
cdc0: e59f013c ldr r0, [pc, #316] ; cf04 <fifo_open+0x43c>
cdc4: e286c028 add ip, r6, #40 ; 0x28
cdc8: e1820000 orr r0, r2, r0
cdcc: e3a01001 mov r1, #1
cdd0: e3a02010 mov r2, #16
cdd4: e58dc000 str ip, [sp]
cdd8: ebffeb97 bl 7c3c <rtems_semaphore_create>
cddc: e3500000 cmp r0, #0
cde0: 1a000036 bne cec0 <fifo_open+0x3f8>
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
cde4: e5d83000 ldrb r3, [r8]
cde8: e353007a cmp r3, #122 ; 0x7a
cdec: e2832001 add r2, r3, #1
c = 'a';
cdf0: 03a03061 moveq r3, #97 ; 0x61
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
cdf4: e5c82000 strb r2, [r8]
c = 'a';
cdf8: 05c83000 strbeq r3, [r8]
cdfc: eaffff42 b cb0c <fifo_open+0x44>
if (! PIPE_LOCK(pipe))
err = -EINTR;
if (*pipep == NULL) {
if (err)
ce00: e3580000 cmp r8, #0
ce04: 1a00001c bne ce7c <fifo_open+0x3b4>
pipe_free(pipe);
else
*pipep = pipe;
ce08: e5856000 str r6, [r5]
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
ce0c: e5940000 ldr r0, [r4]
ce10: ebffec6b bl 7fc4 <rtems_semaphore_release>
ce14: eaffff4a b cb44 <fifo_open+0x7c>
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
sc = rtems_semaphore_create(
ce18: e1a03008 mov r3, r8
ce1c: e3a01001 mov r1, #1
ce20: e3a02054 mov r2, #84 ; 0x54
ce24: e59f00dc ldr r0, [pc, #220] ; cf08 <fifo_open+0x440>
ce28: e58d4000 str r4, [sp]
ce2c: ebffeb82 bl 7c3c <rtems_semaphore_create>
ce30: e1a08000 mov r8, r0
ce34: e5960000 ldr r0, [r6]
ce38: ebffec61 bl 7fc4 <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
ce3c: e3580000 cmp r8, #0
ce40: 0a000028 beq cee8 <fifo_open+0x420>
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
}
if (sc == RTEMS_SUCCESSFUL) {
ce44: e3e0800b mvn r8, #11
ce48: eaffff49 b cb74 <fifo_open+0xac>
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
ce4c: e594002c ldr r0, [r4, #44] ; 0x2c
ce50: e28d1004 add r1, sp, #4
ce54: eb0003ef bl de18 <rtems_barrier_release>
ce58: eaffff5c b cbd0 <fifo_open+0x108>
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
ce5c: e5940030 ldr r0, [r4, #48] ; 0x30
ce60: e28d1004 add r1, sp, #4
ce64: eb0003eb bl de18 <rtems_barrier_release>
ce68: eaffff9c b cce0 <fifo_open+0x218>
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
ce6c: e5940030 ldr r0, [r4, #48] ; 0x30
ce70: e28d1004 add r1, sp, #4
ce74: eb0003e7 bl de18 <rtems_barrier_release>
ce78: eaffff78 b cc60 <fifo_open+0x198>
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
ce7c: e596002c ldr r0, [r6, #44] ; 0x2c <== NOT EXECUTED
ce80: eb0003b9 bl dd6c <rtems_barrier_delete> <== NOT EXECUTED
rtems_barrier_delete(pipe->writeBarrier);
ce84: e5960030 ldr r0, [r6, #48] ; 0x30 <== NOT EXECUTED
ce88: eb0003b7 bl dd6c <rtems_barrier_delete> <== NOT EXECUTED
rtems_semaphore_delete(pipe->Semaphore);
ce8c: e5960028 ldr r0, [r6, #40] ; 0x28 <== NOT EXECUTED
ce90: ebffebd9 bl 7dfc <rtems_semaphore_delete> <== NOT EXECUTED
free(pipe->Buffer);
ce94: e5960000 ldr r0, [r6] <== NOT EXECUTED
ce98: ebffda3e bl 3798 <free> <== NOT EXECUTED
free(pipe);
ce9c: e1a00006 mov r0, r6 <== NOT EXECUTED
cea0: ebffda3c bl 3798 <free> <== NOT EXECUTED
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
cea4: e5940000 ldr r0, [r4]
cea8: ebffec45 bl 7fc4 <rtems_semaphore_release>
ceac: eaffff30 b cb74 <fifo_open+0xac>
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
ceb0: e5940028 ldr r0, [r4, #40] ; 0x28
ceb4: ebffec42 bl 7fc4 <rtems_semaphore_release>
err = -ENXIO;
ceb8: e3e08005 mvn r8, #5
goto out_error;
cebc: eaffff5b b cc30 <fifo_open+0x168>
if (c ++ == 'z')
c = 'a';
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
cec0: e5960030 ldr r0, [r6, #48] ; 0x30
cec4: eb0003a8 bl dd6c <rtems_barrier_delete>
err_wbar: rtems_barrier_delete(pipe->readBarrier);
cec8: e596002c ldr r0, [r6, #44] ; 0x2c
cecc: eb0003a6 bl dd6c <rtems_barrier_delete>
err_rbar: free(pipe->Buffer);
ced0: e5960000 ldr r0, [r6]
ced4: ebffda2f bl 3798 <free>
err_buf: free(pipe);
ced8: e1a00006 mov r0, r6
cedc: ebffda2d bl 3798 <free>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
cee0: e3e0800b mvn r8, #11
cee4: eaffffee b cea4 <fifo_open+0x3dc>
cee8: e5948000 ldr r8, [r4]
ceec: eafffefd b cae8 <fifo_open+0x20>
00008a3c <fpathconf>:
{
long return_value;
rtems_libio_t *iop;
const rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
8a3c: e59f30f4 ldr r3, [pc, #244] ; 8b38 <fpathconf+0xfc>
8a40: e5933000 ldr r3, [r3]
8a44: e1500003 cmp r0, r3
*/
long fpathconf(
int fd,
int name
)
{
8a48: 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);
8a4c: 2a000034 bcs 8b24 <fpathconf+0xe8>
iop = rtems_libio_iop(fd);
8a50: e59f30e4 ldr r3, [pc, #228] ; 8b3c <fpathconf+0x100>
8a54: e5933000 ldr r3, [r3]
8a58: e0800080 add r0, r0, r0, lsl #1
8a5c: e0830200 add r0, r3, r0, lsl #4
rtems_libio_check_is_open(iop);
8a60: e590300c ldr r3, [r0, #12]
8a64: e3130c01 tst r3, #256 ; 0x100
8a68: 0a00002d beq 8b24 <fpathconf+0xe8>
/*
* Now process the information request.
*/
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
8a6c: e5903024 ldr r3, [r0, #36] ; 0x24
8a70: e593302c ldr r3, [r3, #44] ; 0x2c
switch ( name ) {
8a74: e351000b cmp r1, #11
8a78: 979ff101 ldrls pc, [pc, r1, lsl #2]
8a7c: ea00000d b 8ab8 <fpathconf+0x7c>
8a80: 00008acc .word 0x00008acc
8a84: 00008ad4 .word 0x00008ad4 <== NOT EXECUTED
8a88: 00008adc .word 0x00008adc <== NOT EXECUTED
8a8c: 00008ae4 .word 0x00008ae4 <== NOT EXECUTED
8a90: 00008aec .word 0x00008aec <== NOT EXECUTED
8a94: 00008af4 .word 0x00008af4 <== NOT EXECUTED
8a98: 00008afc .word 0x00008afc <== NOT EXECUTED
8a9c: 00008b04 .word 0x00008b04 <== NOT EXECUTED
8aa0: 00008b0c .word 0x00008b0c <== NOT EXECUTED
8aa4: 00008b14 .word 0x00008b14 <== NOT EXECUTED
8aa8: 00008b1c .word 0x00008b1c <== NOT EXECUTED
8aac: 00008ab0 .word 0x00008ab0 <== NOT EXECUTED
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
8ab0: e5930028 ldr r0, [r3, #40] ; 0x28
break;
8ab4: e49df004 pop {pc} ; (ldr pc, [sp], #4)
default:
rtems_set_errno_and_return_minus_one( EINVAL );
8ab8: eb000615 bl a314 <__errno>
8abc: e3a03016 mov r3, #22
8ac0: e5803000 str r3, [r0]
8ac4: e3e00000 mvn r0, #0
break;
}
return return_value;
}
8ac8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
case _PC_LINK_MAX:
return_value = the_limits->link_max;
8acc: e5930000 ldr r0, [r3]
break;
8ad0: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
8ad4: e5930004 ldr r0, [r3, #4]
break;
8ad8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
8adc: e5930008 ldr r0, [r3, #8]
break;
8ae0: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_NAME_MAX:
return_value = the_limits->name_max;
8ae4: e593000c ldr r0, [r3, #12]
break;
8ae8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PATH_MAX:
return_value = the_limits->path_max;
8aec: e5930010 ldr r0, [r3, #16]
break;
8af0: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
8af4: e5930014 ldr r0, [r3, #20]
break;
8af8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
8afc: e593001c ldr r0, [r3, #28]
break;
8b00: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
8b04: e5930020 ldr r0, [r3, #32]
break;
8b08: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
8b0c: e593002c ldr r0, [r3, #44] ; 0x2c
break;
8b10: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
8b14: e5930018 ldr r0, [r3, #24]
break;
8b18: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
8b1c: e5930024 ldr r0, [r3, #36] ; 0x24
break;
8b20: e49df004 pop {pc} ; (ldr pc, [sp], #4)
rtems_libio_t *iop;
const rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
iop = rtems_libio_iop(fd);
rtems_libio_check_is_open(iop);
8b24: eb0005fa bl a314 <__errno>
8b28: e3a03009 mov r3, #9
8b2c: e5803000 str r3, [r0]
8b30: e3e00000 mvn r0, #0
8b34: e49df004 pop {pc} ; (ldr pc, [sp], #4)
00018acc <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
18acc: e92d4030 push {r4, r5, lr}
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
18ad0: e2514000 subs r4, r1, #0
18ad4: 0a000019 beq 18b40 <fstat+0x74>
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
18ad8: e59f3074 ldr r3, [pc, #116] ; 18b54 <fstat+0x88> 18adc: e5933000 ldr r3, [r3] 18ae0: e1500003 cmp r0, r3
18ae4: 2a000010 bcs 18b2c <fstat+0x60>
18ae8: e59f3068 ldr r3, [pc, #104] ; 18b58 <fstat+0x8c> 18aec: e5933000 ldr r3, [r3] 18af0: e0800080 add r0, r0, r0, lsl #1 18af4: e0835200 add r5, r3, r0, lsl #4
rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop);
18af8: e595300c ldr r3, [r5, #12] 18afc: e3130c01 tst r3, #256 ; 0x100
18b00: 0a000009 beq 18b2c <fstat+0x60>
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
18b04: e3a01000 mov r1, #0 18b08: e3a02048 mov r2, #72 ; 0x48 18b0c: e1a00004 mov r0, r4 18b10: ebffd5a4 bl e1a8 <memset>
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
18b14: e5953020 ldr r3, [r5, #32] 18b18: e2850010 add r0, r5, #16 18b1c: e1a01004 mov r1, r4 18b20: e1a0e00f mov lr, pc 18b24: e593f018 ldr pc, [r3, #24]
}
18b28: e8bd8030 pop {r4, r5, pc}
/* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop);
18b2c: ebffd32d bl d7e8 <__errno>
18b30: e3a03009 mov r3, #9
18b34: e5803000 str r3, [r0]
18b38: e3e00000 mvn r0, #0
18b3c: e8bd8030 pop {r4, r5, pc}
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
rtems_set_errno_and_return_minus_one( EFAULT );
18b40: ebffd328 bl d7e8 <__errno> <== NOT EXECUTED
18b44: e3a0300e mov r3, #14 <== NOT EXECUTED
18b48: e5803000 str r3, [r0] <== NOT EXECUTED
18b4c: e3e00000 mvn r0, #0 <== NOT EXECUTED
18b50: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00002544 <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) {
2544: e59f3074 ldr r3, [pc, #116] ; 25c0 <get_disk_entry+0x7c>
2548: e593c000 ldr ip, [r3]
254c: e15c0000 cmp ip, r0
2550: 9a000018 bls 25b8 <get_disk_entry+0x74>
2554: e5933004 ldr r3, [r3, #4]
2558: e3530000 cmp r3, #0
return dd;
}
}
return NULL;
255c: 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) {
2560: 012fff1e bxeq lr
rtems_disk_device_table *dtab = disktab + major;
2564: e083c180 add ip, r3, r0, lsl #3
if (minor < dtab->size && dtab->minor != NULL) {
2568: e59cc004 ldr ip, [ip, #4]
256c: e15c0001 cmp ip, r1
2570: 9a000010 bls 25b8 <get_disk_entry+0x74>
2574: e7930180 ldr r0, [r3, r0, lsl #3]
2578: e3500000 cmp r0, #0
257c: 012fff1e bxeq lr
rtems_disk_device *dd = dtab->minor [minor];
2580: e7900101 ldr r0, [r0, r1, lsl #2]
if (dd != NULL && !lookup_only) {
2584: e3500000 cmp r0, #0
2588: 012fff1e bxeq lr
258c: e3520000 cmp r2, #0
2590: 112fff1e bxne lr
if (!dd->deleted) {
2594: e5d03040 ldrb r3, [r0, #64] ; 0x40
2598: e3530000 cmp r3, #0
259c: 1a000003 bne 25b0 <get_disk_entry+0x6c>
++dd->uses;
25a0: e5903014 ldr r3, [r0, #20]
25a4: e2833001 add r3, r3, #1
25a8: e5803014 str r3, [r0, #20]
25ac: e12fff1e bx lr
} else {
dd = NULL;
25b0: e1a00002 mov r0, r2
return dd;
}
}
return NULL;
}
25b4: e12fff1e bx lr
return dd;
}
}
return NULL;
25b8: e3a00000 mov r0, #0 <== NOT EXECUTED
25bc: e12fff1e bx lr <== NOT EXECUTED
000039a0 <get_sector>:
*/
static rtems_status_code
get_sector(int fd,
uint32_t sector_num,
rtems_sector_data_t **sector)
{
39a0: 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)
39a4: e2528000 subs r8, r2, #0
*/
static rtems_status_code
get_sector(int fd,
uint32_t sector_num,
rtems_sector_data_t **sector)
{
39a8: e1a05000 mov r5, r0
39ac: e1a04001 mov r4, r1
off_t off;
off_t new_off;
if (sector == NULL)
{
return RTEMS_INTERNAL_ERROR;
39b0: 03a00019 moveq r0, #25
rtems_sector_data_t *s;
ssize_t n;
off_t off;
off_t new_off;
if (sector == NULL)
39b4: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
{
return RTEMS_INTERNAL_ERROR;
}
off = sector_num * RTEMS_IDE_SECTOR_SIZE;
39b8: e1a03481 lsl r3, r1, #9
39bc: e3a07000 mov r7, #0
39c0: e1a06003 mov r6, r3
new_off = lseek(fd, off, SEEK_SET);
39c4: e1a01003 mov r1, r3
39c8: e1a02007 mov r2, r7
39cc: e1a03007 mov r3, r7
39d0: eb0004eb bl 4d84 <lseek>
if (new_off != off) {
39d4: e1510007 cmp r1, r7
39d8: 01500006 cmpeq r0, r6
39dc: 0a000001 beq 39e8 <get_sector+0x48>
return RTEMS_IO_ERROR;
39e0: e3a0001b mov r0, #27 <== NOT EXECUTED
s->sector_num = sector_num;
*sector = s;
return RTEMS_SUCCESSFUL;
}
39e4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
new_off = lseek(fd, off, SEEK_SET);
if (new_off != off) {
return RTEMS_IO_ERROR;
}
s = (rtems_sector_data_t *) malloc(sizeof(rtems_sector_data_t) + RTEMS_IDE_SECTOR_SIZE);
39e8: e3a00f81 mov r0, #516 ; 0x204
39ec: eb00054b bl 4f20 <malloc>
if (s == NULL)
39f0: e2506000 subs r6, r0, #0
{
return RTEMS_NO_MEMORY;
39f4: 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)
39f8: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
{
return RTEMS_NO_MEMORY;
}
n = read(fd, s->data, RTEMS_IDE_SECTOR_SIZE);
39fc: e1a00005 mov r0, r5
3a00: e2861004 add r1, r6, #4
3a04: e3a02c02 mov r2, #512 ; 0x200
3a08: eb0007f0 bl 59d0 <read>
if (n != RTEMS_IDE_SECTOR_SIZE)
3a0c: e3500c02 cmp r0, #512 ; 0x200
{
free(s);
return RTEMS_IO_ERROR;
}
s->sector_num = sector_num;
3a10: 05864000 streq r4, [r6]
*sector = s;
return RTEMS_SUCCESSFUL;
3a14: 03a00000 moveq r0, #0
return RTEMS_IO_ERROR;
}
s->sector_num = sector_num;
*sector = s;
3a18: 05886000 streq r6, [r8]
{
return RTEMS_NO_MEMORY;
}
n = read(fd, s->data, RTEMS_IDE_SECTOR_SIZE);
if (n != RTEMS_IDE_SECTOR_SIZE)
3a1c: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
{
free(s);
3a20: e1a00006 mov r0, r6 <== NOT EXECUTED
3a24: eb0003be bl 4924 <free> <== NOT EXECUTED
return RTEMS_IO_ERROR;
3a28: e3a0001b mov r0, #27 <== NOT EXECUTED
3a2c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00002324 <getchark>:
#include <rtems.h>
#include <rtems/bspIo.h>
int getchark(void)
{
if ( BSP_poll_char )
2324: e59f3020 ldr r3, [pc, #32] ; 234c <getchark+0x28> <== NOT EXECUTED
2328: e5933000 ldr r3, [r3] <== NOT EXECUTED
232c: e3530000 cmp r3, #0 <== NOT EXECUTED
#include <rtems.h>
#include <rtems/bspIo.h>
int getchark(void)
{
2330: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( BSP_poll_char )
2334: 0a000002 beq 2344 <getchark+0x20> <== NOT EXECUTED
return (*BSP_poll_char)();
2338: e1a0e00f mov lr, pc <== NOT EXECUTED
233c: e12fff13 bx r3 <== NOT EXECUTED
2340: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
return -1;
2344: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
2348: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
000025b8 <gettimeofday>:
*/
int gettimeofday(
struct timeval *tp,
void * __tz __attribute__((unused))
)
{
25b8: e92d40d0 push {r4, r6, r7, lr}
/* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp )
25bc: e2504000 subs r4, r0, #0
*/
int gettimeofday(
struct timeval *tp,
void * __tz __attribute__((unused))
)
{
25c0: e24dd008 sub sp, sp, #8
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp )
25c4: 0a000015 beq 2620 <gettimeofday+0x68>
)
{
Timestamp_Control snapshot_as_timestamp;
Timestamp_Control *snapshot_as_timestamp_ptr;
snapshot_as_timestamp_ptr =
25c8: e59f1064 ldr r1, [pc, #100] ; 2634 <gettimeofday+0x7c>
25cc: e1a0000d mov r0, sp
25d0: eb0013c0 bl 74d8 <_TOD_Get_with_nanoseconds>
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
}
25d4: e89000c0 ldm r0, {r6, r7}
static inline void _Timestamp64_implementation_To_timeval(
const Timestamp64_Control *_timestamp,
struct timeval *_timeval
)
{
_timeval->tv_sec = (time_t) (*_timestamp / 1000000000U);
25d8: e59f2058 ldr r2, [pc, #88] ; 2638 <gettimeofday+0x80>
25dc: e3a03000 mov r3, #0
25e0: e1a00006 mov r0, r6
25e4: e1a01007 mov r1, r7
25e8: eb005362 bl 17378 <__divdi3>
_timeval->tv_usec = (suseconds_t) ((*_timestamp % 1000000000U) / 1000U);
25ec: e59f2044 ldr r2, [pc, #68] ; 2638 <gettimeofday+0x80>
25f0: e3a03000 mov r3, #0
static inline void _Timestamp64_implementation_To_timeval(
const Timestamp64_Control *_timestamp,
struct timeval *_timeval
)
{
_timeval->tv_sec = (time_t) (*_timestamp / 1000000000U);
25f4: e5840000 str r0, [r4]
_timeval->tv_usec = (suseconds_t) ((*_timestamp % 1000000000U) / 1000U);
25f8: e1a01007 mov r1, r7
25fc: e1a00006 mov r0, r6
2600: eb005497 bl 17864 <__moddi3>
2604: e3a02ffa mov r2, #1000 ; 0x3e8
2608: e3a03000 mov r3, #0
260c: eb005359 bl 17378 <__divdi3>
2610: e5840004 str r0, [r4, #4]
* Timezone information ignored by the OS proper. Per email
* with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X
* do it. This puts us in good company.
*/
return 0;
2614: e3a00000 mov r0, #0
}
2618: e28dd008 add sp, sp, #8
261c: e8bd80d0 pop {r4, r6, r7, pc}
void * __tz __attribute__((unused))
)
{
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp )
rtems_set_errno_and_return_minus_one( EFAULT );
2620: eb002c70 bl d7e8 <__errno> <== NOT EXECUTED
2624: e3a0300e mov r3, #14 <== NOT EXECUTED
2628: e5803000 str r3, [r0] <== NOT EXECUTED
262c: e3e00000 mvn r0, #0 <== NOT EXECUTED
2630: eafffff8 b 2618 <gettimeofday+0x60> <== NOT EXECUTED
00005100 <iproc>:
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
if (tty->termios.c_iflag & ISTRIP)
5100: e5913030 ldr r3, [r1, #48] ; 0x30
5104: e3130020 tst r3, #32
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
5108: e92d4030 push {r4, r5, lr}
510c: e20040ff and r4, r0, #255 ; 0xff
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
5110: 1200407f andne r4, r0, #127 ; 0x7f
if (tty->termios.c_iflag & IUCLC)
5114: e3130c02 tst r3, #512 ; 0x200
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
5118: e1a05001 mov r5, r1
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
511c: 0a000007 beq 5140 <iproc+0x40>
c = tolower (c);
5120: e59f21a0 ldr r2, [pc, #416] ; 52c8 <iproc+0x1c8>
5124: e5922000 ldr r2, [r2]
5128: e0822004 add r2, r2, r4
512c: e5d22001 ldrb r2, [r2, #1]
5130: e2022003 and r2, r2, #3
5134: e3520001 cmp r2, #1
5138: 02844020 addeq r4, r4, #32
513c: e20440ff and r4, r4, #255 ; 0xff
if (c == '\r') {
5140: e354000d cmp r4, #13
5144: 0a000014 beq 519c <iproc+0x9c>
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
5148: e354000a cmp r4, #10
514c: 0a000036 beq 522c <iproc+0x12c>
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
5150: e3540000 cmp r4, #0
5154: 1a000016 bne 51b4 <iproc+0xb4>
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
5158: e59f316c ldr r3, [pc, #364] ; 52cc <iproc+0x1cc>
515c: e5932008 ldr r2, [r3, #8]
5160: e5953020 ldr r3, [r5, #32]
5164: e2422001 sub r2, r2, #1
5168: e1530002 cmp r3, r2
516c: 2a000008 bcs 5194 <iproc+0x94>
if (tty->termios.c_lflag & ECHO)
5170: e595203c ldr r2, [r5, #60] ; 0x3c
5174: e3120008 tst r2, #8
5178: 1a00002e bne 5238 <iproc+0x138>
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
517c: e595101c ldr r1, [r5, #28] <== NOT EXECUTED
5180: e2832001 add r2, r3, #1 <== NOT EXECUTED
5184: e7c14003 strb r4, [r1, r3] <== NOT EXECUTED
} return 0;
5188: e3a00000 mov r0, #0 <== NOT EXECUTED
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
518c: e5852020 str r2, [r5, #32] <== NOT EXECUTED
5190: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
} return 0;
5194: e3a00000 mov r0, #0 <== NOT EXECUTED
}
5198: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
519c: e3130080 tst r3, #128 ; 0x80
return 0;
51a0: 13a00000 movne r0, #0
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
51a4: 18bd8030 popne {r4, r5, pc}
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
51a8: e3130c01 tst r3, #256 ; 0x100
51ac: 03a0400d moveq r4, #13
51b0: 13a0400a movne r4, #10
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
51b4: e595303c ldr r3, [r5, #60] ; 0x3c
51b8: e3130002 tst r3, #2
51bc: 0affffe5 beq 5158 <iproc+0x58>
if (c == tty->termios.c_cc[VERASE]) {
51c0: e5d52043 ldrb r2, [r5, #67] ; 0x43
51c4: e1520004 cmp r2, r4
51c8: 0a000039 beq 52b4 <iproc+0x1b4>
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
51cc: e5d52044 ldrb r2, [r5, #68] ; 0x44
51d0: e1520004 cmp r2, r4
51d4: 0a000025 beq 5270 <iproc+0x170>
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
51d8: e5d52045 ldrb r2, [r5, #69] ; 0x45
51dc: e1520004 cmp r2, r4
return 1;
51e0: 03a00001 moveq r0, #1
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
51e4: 08bd8030 popeq {r4, r5, pc}
return 1;
} else if (c == '\n') {
51e8: e354000a cmp r4, #10
51ec: 0a000024 beq 5284 <iproc+0x184>
if (tty->termios.c_lflag & (ECHO | ECHONL))
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
51f0: e5d5204c ldrb r2, [r5, #76] ; 0x4c
51f4: e1520004 cmp r2, r4
51f8: 0a000002 beq 5208 <iproc+0x108>
51fc: e5d52051 ldrb r2, [r5, #81] ; 0x51
5200: e1520004 cmp r2, r4
5204: 1affffd3 bne 5158 <iproc+0x58>
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
5208: e3130008 tst r3, #8 <== NOT EXECUTED
520c: 1a000013 bne 5260 <iproc+0x160> <== NOT EXECUTED
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
5210: e285101c add r1, r5, #28 <== NOT EXECUTED
5214: e891000a ldm r1, {r1, r3} <== NOT EXECUTED
5218: e2832001 add r2, r3, #1 <== NOT EXECUTED
521c: e7c14003 strb r4, [r1, r3] <== NOT EXECUTED
return 1;
5220: e3a00001 mov r0, #1 <== NOT EXECUTED
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
5224: e5852020 str r2, [r5, #32] <== NOT EXECUTED
return 1;
5228: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
522c: e3130040 tst r3, #64 ; 0x40
5230: 13a0400d movne r4, #13
5234: eaffffde b 51b4 <iproc+0xb4>
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
5238: e1a00004 mov r0, r4
523c: e1a01005 mov r1, r5
5240: ebffff04 bl 4e58 <echo>
5244: e5953020 ldr r3, [r5, #32]
tty->cbuf[tty->ccount++] = c;
5248: e595101c ldr r1, [r5, #28]
524c: e2832001 add r2, r3, #1
5250: e7c14003 strb r4, [r1, r3]
} return 0;
5254: e3a00000 mov r0, #0
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
5258: e5852020 str r2, [r5, #32]
525c: e8bd8030 pop {r4, r5, pc}
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
5260: e1a00004 mov r0, r4 <== NOT EXECUTED
5264: e1a01005 mov r1, r5 <== NOT EXECUTED
5268: ebfffefa bl 4e58 <echo> <== NOT EXECUTED
526c: eaffffe7 b 5210 <iproc+0x110> <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
5270: e1a00005 mov r0, r5
5274: e3a01001 mov r1, #1
5278: ebffff1b bl 4eec <erase>
return 0;
527c: e3a00000 mov r0, #0
5280: e8bd8030 pop {r4, r5, pc}
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
} else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
5284: e3130048 tst r3, #72 ; 0x48
echo (c, tty);
5288: 11a00004 movne r0, r4
528c: 11a01005 movne r1, r5
5290: 1bfffef0 blne 4e58 <echo>
tty->cbuf[tty->ccount++] = c;
5294: e285101c add r1, r5, #28
5298: e891000a ldm r1, {r1, r3}
529c: e3a0000a mov r0, #10
52a0: e2832001 add r2, r3, #1
52a4: e7c10003 strb r0, [r1, r3]
return 1;
52a8: e3a00001 mov r0, #1
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
} else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
52ac: e5852020 str r2, [r5, #32]
return 1;
52b0: e8bd8030 pop {r4, r5, pc}
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
52b4: e1a00005 mov r0, r5
52b8: e3a01000 mov r1, #0
52bc: ebffff0a bl 4eec <erase>
return 0;
52c0: e3a00000 mov r0, #0
52c4: e8bd8030 pop {r4, r5, pc}
00018b80 <kill>:
#if !defined(RTEMS_POSIX_API)
int kill( pid_t pid, int sig )
{
return 0;
}
18b80: e3a00000 mov r0, #0 <== NOT EXECUTED 18b84: e12fff1e bx lr <== NOT EXECUTED
0000284c <malloc>:
size_t size
)
{
void *return_this;
MSBUMP(malloc_calls, 1);
284c: e59f30cc ldr r3, [pc, #204] ; 2920 <malloc+0xd4>
2850: e5932004 ldr r2, [r3, #4]
2854: e2822001 add r2, r2, #1
#include "malloc_p.h"
void *malloc(
size_t size
)
{
2858: e92d4070 push {r4, r5, r6, lr}
285c: e1a04000 mov r4, r0
void *return_this;
MSBUMP(malloc_calls, 1);
2860: e5832004 str r2, [r3, #4]
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
2864: ebffffbb bl 2758 <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
2868: e3540000 cmp r4, #0
return (void *) 0;
286c: 01a06004 moveq r6, r4
malloc_deferred_frees_process();
/*
* Validate the parameters
*/
if ( !size )
2870: 0a000018 beq 28d8 <malloc+0x8c>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
2874: e59f30a8 ldr r3, [pc, #168] ; 2924 <malloc+0xd8>
2878: e5933000 ldr r3, [r3]
287c: e3530003 cmp r3, #3
2880: 0a000016 beq 28e0 <malloc+0x94>
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
2884: e59f509c ldr r5, [pc, #156] ; 2928 <malloc+0xdc>
2888: e3a02000 mov r2, #0
288c: e5950000 ldr r0, [r5]
2890: e1a01004 mov r1, r4
2894: e1a03002 mov r3, r2
2898: eb001659 bl 8204 <_Protected_heap_Allocate_aligned_with_boundary>
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
289c: e2506000 subs r6, r0, #0
28a0: 0a000013 beq 28f4 <malloc+0xa8>
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
28a4: e59f3080 ldr r3, [pc, #128] ; 292c <malloc+0xe0>
28a8: e5933000 ldr r3, [r3]
28ac: e3530000 cmp r3, #0
(*rtems_malloc_dirty_helper)( return_this, size );
28b0: 11a00006 movne r0, r6
28b4: 11a01004 movne r1, r4
28b8: 11a0e00f movne lr, pc
28bc: 112fff13 bxne r3
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
28c0: e59f3068 ldr r3, [pc, #104] ; 2930 <malloc+0xe4>
28c4: e5933000 ldr r3, [r3]
28c8: e3530000 cmp r3, #0
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
28cc: 11a00006 movne r0, r6
28d0: 11a0e00f movne lr, pc
28d4: 1593f004 ldrne pc, [r3, #4]
return return_this;
}
28d8: e1a00006 mov r0, r6
28dc: e8bd8070 pop {r4, r5, r6, pc}
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
28e0: ebffff8f bl 2724 <malloc_is_system_state_OK>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
28e4: e3500000 cmp r0, #0
!malloc_is_system_state_OK() )
return NULL;
28e8: 01a06000 moveq r6, r0
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
28ec: 1affffe4 bne 2884 <malloc+0x38>
28f0: eafffff8 b 28d8 <malloc+0x8c> <== NOT EXECUTED
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
return_this = (*rtems_malloc_extend_handler)( RTEMS_Malloc_Heap, size );
28f4: e5950000 ldr r0, [r5]
28f8: e1a01004 mov r1, r4
28fc: e59f3030 ldr r3, [pc, #48] ; 2934 <malloc+0xe8>
2900: e1a0e00f mov lr, pc
2904: e593f000 ldr pc, [r3]
if ( !return_this ) {
2908: e2506000 subs r6, r0, #0
290c: 1affffe4 bne 28a4 <malloc+0x58>
errno = ENOMEM;
2910: eb002bb4 bl d7e8 <__errno>
2914: e3a0300c mov r3, #12
2918: e5803000 str r3, [r0]
return (void *) 0;
291c: eaffffed b 28d8 <malloc+0x8c>
0000cdb8 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode
)
{
cdb8: e92d4030 push {r4, r5, lr}
the_jnode = iop->pathinfo.node_access;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & LIBIO_FLAGS_WRITE)
cdbc: e590c00c ldr ip, [r0, #12]
cdc0: e21cc004 ands ip, ip, #4
rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode
)
{
cdc4: e24dd004 sub sp, sp, #4
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
cdc8: e5902018 ldr r2, [r0, #24]
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & LIBIO_FLAGS_WRITE)
cdcc: 0a000014 beq ce24 <memfile_open+0x6c>
cdd0: e592304c ldr r3, [r2, #76] ; 0x4c
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
cdd4: e5933000 ldr r3, [r3]
cdd8: e3530005 cmp r3, #5
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
return -1;
}
return 0;
cddc: 13a00000 movne r0, #0
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & LIBIO_FLAGS_WRITE)
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
cde0: 0a000001 beq cdec <memfile_open+0x34>
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
return -1;
}
return 0;
}
cde4: e28dd004 add sp, sp, #4
cde8: e8bd8030 pop {r4, r5, pc}
/*
* 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;
cdec: e592c050 ldr ip, [r2, #80] ; 0x50 <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->control = &IMFS_node_control_memfile;
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
cdf0: e3a01000 mov r1, #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;
cdf4: e59f0050 ldr r0, [pc, #80] ; ce4c <memfile_open+0x94> <== NOT EXECUTED
the_jnode->info.file.size = 0;
cdf8: e3a04000 mov r4, #0 <== NOT EXECUTED
cdfc: e3a05000 mov r5, #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)
ce00: e15c0001 cmp ip, r1 <== 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;
ce04: e5923058 ldr r3, [r2, #88] ; 0x58 <== NOT EXECUTED
the_jnode->control = &IMFS_node_control_memfile;
ce08: e582004c str r0, [r2, #76] ; 0x4c <== NOT EXECUTED
the_jnode->info.file.size = 0;
ce0c: e5824050 str r4, [r2, #80] ; 0x50 <== NOT EXECUTED
ce10: e5825054 str r5, [r2, #84] ; 0x54 <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
ce14: e5821058 str r1, [r2, #88] ; 0x58 <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
ce18: e582105c str r1, [r2, #92] ; 0x5c <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
ce1c: e5821060 str r1, [r2, #96] ; 0x60 <== NOT EXECUTED
if ((count != 0)
ce20: 1a000001 bne ce2c <memfile_open+0x74> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
return -1;
}
return 0;
ce24: e1a0000c mov r0, ip
ce28: eaffffed b cde4 <memfile_open+0x2c>
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
ce2c: e1a00002 mov r0, r2 <== NOT EXECUTED
ce30: e1a01004 mov r1, r4 <== NOT EXECUTED
ce34: e1a02005 mov r2, r5 <== NOT EXECUTED
ce38: e58dc000 str ip, [sp] <== NOT EXECUTED
ce3c: ebffff5a bl cbac <IMFS_memfile_write> <== NOT EXECUTED
ce40: e3700001 cmn r0, #1 <== NOT EXECUTED
return -1;
}
return 0;
ce44: 13a00000 movne r0, #0 <== NOT EXECUTED
ce48: eaffffe5 b cde4 <memfile_open+0x2c> <== NOT EXECUTED
00002a28 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
2a28: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
int rv = 0;
if (
2a2c: e3530001 cmp r3, #1
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
2a30: e24dd05c sub sp, sp, #92 ; 0x5c
2a34: e1a07003 mov r7, r3
2a38: e1a08000 mov r8, r0
2a3c: e1a06001 mov r6, r1
2a40: e1a0b002 mov fp, r2
int rv = 0;
if (
2a44: 8a000088 bhi 2c6c <mount+0x244>
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
2a48: e1a00002 mov r0, r2
2a4c: eb002128 bl aef4 <rtems_filesystem_get_mount_handler>
rtems_filesystem_get_mount_handler( filesystemtype );
if ( fsmount_me_h != NULL ) {
2a50: e3500000 cmp r0, #0
2a54: e58d0004 str r0, [sp, #4]
2a58: 0a000083 beq 2c6c <mount+0x244>
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
2a5c: e3560000 cmp r6, #0
2a60: 0a000077 beq 2c44 <mount+0x21c>
}
return rv;
}
int mount(
2a64: e1a00006 mov r0, r6
2a68: eb00311a bl eed8 <strlen>
2a6c: e2800001 add r0, r0, #1
2a70: e58d6008 str r6, [sp, #8]
2a74: e58d0000 str r0, [sp]
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;
2a78: e1a0000b mov r0, fp
2a7c: eb003115 bl eed8 <strlen>
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
2a80: e3580000 cmp r8, #0
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
2a84: e1a09000 mov r9, r0
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
2a88: 01a0a008 moveq sl, r8
2a8c: 0a000002 beq 2a9c <mount+0x74>
2a90: e1a00008 mov r0, r8
2a94: eb00310f bl eed8 <strlen>
2a98: e280a001 add sl, r0, #1
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
2a9c: e59d3000 ldr r3, [sp]
2aa0: e0831009 add r1, r3, r9
2aa4: e2811065 add r1, r1, #101 ; 0x65
+ sizeof( rtems_filesystem_global_location_t );
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
2aa8: e3a00001 mov r0, #1
2aac: e081100a add r1, r1, sl
2ab0: ebfffdfa bl 22a0 <calloc>
if ( mt_entry != NULL ) {
2ab4: e2504000 subs r4, r0, #0
2ab8: 0a000066 beq 2c58 <mount+0x230>
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 );
2abc: e2845064 add r5, 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;
2ac0: e2899001 add r9, r9, #1
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 );
memcpy( str, filesystemtype, filesystemtype_size );
2ac4: e1a00005 mov r0, r5
2ac8: e1a0100b mov r1, fp
2acc: e1a02009 mov r2, r9
2ad0: eb002d7e bl e0d0 <memcpy>
mt_entry->type = str;
str += filesystemtype_size;
if ( source_or_null != NULL ) {
2ad4: e3580000 cmp r8, #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;
2ad8: e5845034 str r5, [r4, #52] ; 0x34
+ 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 =
2adc: e284b040 add fp, r4, #64 ; 0x40
((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;
str += filesystemtype_size;
2ae0: e0855009 add r5, r5, r9
if ( source_or_null != NULL ) {
2ae4: 0a000005 beq 2b00 <mount+0xd8>
memcpy( str, source_or_null, source_size );
2ae8: e1a00005 mov r0, r5
2aec: e1a01008 mov r1, r8
2af0: e1a0200a mov r2, sl
2af4: eb002d75 bl e0d0 <memcpy>
mt_entry->dev = str;
2af8: e5845038 str r5, [r4, #56] ; 0x38
str += source_size;
2afc: e085500a add r5, r5, sl
}
memcpy( str, target, target_size );
2b00: e59d1008 ldr r1, [sp, #8]
2b04: e59d2000 ldr r2, [sp]
2b08: e1a00005 mov r0, r5
2b0c: eb002d6f bl e0d0 <memcpy>
mt_entry->target = str;
str += target_size;
mt_entry->mounted = true;
mt_entry->mt_fs_root = mt_fs_root;
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
2b10: e59fe21c ldr lr, [pc, #540] ; 2d34 <mount+0x30c>
memcpy( str, target, target_size );
mt_entry->target = str;
str += target_size;
mt_entry->mounted = true;
2b14: e3a0c001 mov ip, #1
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
_Chain_Initialize( the_chain, starting_address, number_nodes, node_size );
2b18: e2840014 add r0, r4, #20
2b1c: e1a0100b mov r1, fp
2b20: e1a0200c mov r2, ip
2b24: e3a03024 mov r3, #36 ; 0x24
mt_entry->dev = str;
str += source_size;
}
memcpy( str, target, target_size );
mt_entry->target = str;
2b28: e5845030 str r5, [r4, #48] ; 0x30
str += target_size;
mt_entry->mounted = true;
2b2c: e5c4c028 strb ip, [r4, #40] ; 0x28
mt_entry->mt_fs_root = mt_fs_root;
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
2b30: e584e02c str lr, [r4, #44] ; 0x2c
mt_fs_root->location.mt_entry = mt_entry;
mt_fs_root->reference_count = 1;
2b34: e584c058 str ip, [r4, #88] ; 0x58
memcpy( str, target, target_size );
mt_entry->target = str;
str += target_size;
mt_entry->mounted = true;
mt_entry->mt_fs_root = mt_fs_root;
2b38: e584b024 str fp, [r4, #36] ; 0x24
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
mt_fs_root->location.mt_entry = mt_entry;
2b3c: e5844054 str r4, [r4, #84] ; 0x54
2b40: eb00115a bl 70b0 <_Chain_Initialize>
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
2b44: e5c47029 strb r7, [r4, #41] ; 0x29
rv = (*fsmount_me_h)( mt_entry, data );
2b48: e1a00004 mov r0, r4
2b4c: e59d1080 ldr r1, [sp, #128] ; 0x80
2b50: e59d3004 ldr r3, [sp, #4]
2b54: e1a0e00f mov lr, pc
2b58: e12fff13 bx r3
if ( rv == 0 ) {
2b5c: e2505000 subs r5, r0, #0
2b60: 1a000024 bne 2bf8 <mount+0x1d0>
if ( target != NULL ) {
2b64: e3560000 cmp r6, #0
2b68: 0a000044 beq 2c80 <mount+0x258>
{
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 =
2b6c: e1a01006 mov r1, r6
2b70: e3a0201f mov r2, #31
2b74: e28d000c add r0, sp, #12
2b78: eb00033d bl 3874 <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;
2b7c: e5902014 ldr r2, [r0, #20]
return (*mt_entry->ops->are_nodes_equal_h)(
2b80: e592300c ldr r3, [r2, #12]
2b84: e5921024 ldr r1, [r2, #36] ; 0x24
2b88: e1a0e00f mov lr, pc
2b8c: e593f010 ldr pc, [r3, #16]
rtems_filesystem_eval_path_start( &ctx, target, eval_flags );
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
2b90: e3500000 cmp r0, #0
2b94: 1a00005a bne 2d04 <mount+0x2dc>
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(
2b98: e28d1024 add r1, sp, #36 ; 0x24
2b9c: e28d0044 add r0, sp, #68 ; 0x44
2ba0: eb0003f7 bl 3b84 <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 );
2ba4: e28d0044 add r0, sp, #68 ; 0x44
2ba8: eb000477 bl 3d8c <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 );
2bac: e5903014 ldr r3, [r0, #20]
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 );
2bb0: e1a06000 mov r6, r0
mt_entry->mt_point_node = mt_point_node;
2bb4: e5840020 str r0, [r4, #32]
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
2bb8: e593300c ldr r3, [r3, #12]
2bbc: e1a00004 mov r0, r4
2bc0: e1a0e00f mov lr, pc
2bc4: e593f030 ldr pc, [r3, #48] ; 0x30
if ( rv == 0 ) {
2bc8: e2505000 subs r5, r0, #0
2bcc: 0a00000e beq 2c0c <mount+0x1e4>
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
rtems_filesystem_mt_unlock();
} else {
rtems_filesystem_global_location_release( mt_point_node );
2bd0: e1a00006 mov r0, r6
2bd4: eb00041f bl 3c58 <rtems_filesystem_global_location_release>
} else {
rtems_filesystem_eval_path_error( &ctx, EBUSY );
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
2bd8: e28d000c add r0, sp, #12
2bdc: eb00032e bl 389c <rtems_filesystem_eval_path_cleanup>
rv = register_subordinate_file_system( mt_entry, target );
} else {
rv = register_root_file_system( mt_entry );
}
if ( rv != 0 ) {
2be0: e3550000 cmp r5, #0
2be4: 0a000005 beq 2c00 <mount+0x1d8>
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
2be8: e594300c ldr r3, [r4, #12]
2bec: e1a00004 mov r0, r4
2bf0: e1a0e00f mov lr, pc
2bf4: e593f03c ldr pc, [r3, #60] ; 0x3c
}
}
if ( rv != 0 ) {
free( mt_entry );
2bf8: e1a00004 mov r0, r4
2bfc: ebfffe44 bl 2514 <free>
errno = EINVAL;
rv = -1;
}
return rv;
}
2c00: e1a00005 mov r0, r5
2c04: e28dd05c add sp, sp, #92 ; 0x5c
2c08: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
2c0c: e59f6124 ldr r6, [pc, #292] ; 2d38 <mount+0x310>
2c10: e1a01005 mov r1, r5
2c14: e1a02005 mov r2, r5
2c18: e5960000 ldr r0, [r6]
2c1c: eb000e74 bl 65f4 <rtems_semaphore_obtain>
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
2c20: e59f3114 ldr r3, [pc, #276] ; 2d3c <mount+0x314>
2c24: e5932008 ldr r2, [r3, #8]
the_node->next = tail;
2c28: e2831004 add r1, r3, #4
tail->previous = the_node; old_last->next = the_node; the_node->previous = old_last;
2c2c: e8840006 stm r4, {r1, r2}
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
2c30: e5960000 ldr r0, [r6]
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;
2c34: e5824000 str r4, [r2]
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
2c38: e5834008 str r4, [r3, #8]
2c3c: eb000eb5 bl 6718 <rtems_semaphore_release>
2c40: eaffffe4 b 2bd8 <mount+0x1b0>
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
2c44: e59f30f4 ldr r3, [pc, #244] ; 2d40 <mount+0x318>
2c48: e58d3008 str r3, [sp, #8]
2c4c: e3a03002 mov r3, #2
2c50: e58d3000 str r3, [sp]
2c54: eaffff87 b 2a78 <mount+0x50>
if ( rv != 0 ) {
free( mt_entry );
}
} else {
errno = ENOMEM;
2c58: eb002ae2 bl d7e8 <__errno> <== NOT EXECUTED
2c5c: e3a0300c mov r3, #12 <== NOT EXECUTED
2c60: e5803000 str r3, [r0] <== NOT EXECUTED
rv = -1;
2c64: e3e05000 mvn r5, #0 <== NOT EXECUTED
2c68: eaffffe4 b 2c00 <mount+0x1d8> <== NOT EXECUTED
} else {
errno = EINVAL;
rv = -1;
}
} else {
errno = EINVAL;
2c6c: eb002add bl d7e8 <__errno>
2c70: e3a03016 mov r3, #22
2c74: e5803000 str r3, [r0]
rv = -1;
2c78: e3e05000 mvn r5, #0
2c7c: eaffffdf b 2c00 <mount+0x1d8>
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
2c80: e59f60b0 ldr r6, [pc, #176] ; 2d38 <mount+0x310>
2c84: e1a01005 mov r1, r5
2c88: e1a02005 mov r2, r5
2c8c: e5960000 ldr r0, [r6]
2c90: eb000e57 bl 65f4 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
2c94: e59f30a0 ldr r3, [pc, #160] ; 2d3c <mount+0x314>
)
{
int rv = 0;
rtems_filesystem_mt_lock();
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
2c98: e5932000 ldr r2, [r3]
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
2c9c: e2831004 add r1, r3, #4
2ca0: e1520001 cmp r2, r1
2ca4: 1a00001b bne 2d18 <mount+0x2f0>
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
2ca8: e5931008 ldr r1, [r3, #8]
the_node->next = tail;
2cac: e5842000 str r2, [r4]
tail->previous = the_node;
2cb0: e5834008 str r4, [r3, #8]
old_last->next = the_node;
2cb4: e5814000 str r4, [r1]
the_node->previous = old_last;
2cb8: e5841004 str r1, [r4, #4]
}
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 );
2cbc: e2847024 add r7, r4, #36 ; 0x24
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
2cc0: e5960000 ldr r0, [r6]
2cc4: eb000e93 bl 6718 <rtems_semaphore_release>
rv = -1;
}
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
rtems_filesystem_global_location_t *new_fs_root =
2cc8: e1a00007 mov r0, r7
2ccc: eb0003fe bl 3ccc <rtems_filesystem_global_location_obtain>
2cd0: e1a08000 mov r8, r0
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_t *new_fs_current =
2cd4: e1a00007 mov r0, r7
2cd8: eb0003fb bl 3ccc <rtems_filesystem_global_location_obtain>
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
2cdc: e59f6060 ldr r6, [pc, #96] ; 2d44 <mount+0x31c>
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 =
2ce0: e1a04000 mov r4, r0
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
2ce4: e5960000 ldr r0, [r6]
2ce8: e1a01008 mov r1, r8
2cec: e2800004 add r0, r0, #4
2cf0: eb0003ed bl 3cac <rtems_filesystem_global_location_assign>
&rtems_filesystem_root,
new_fs_root
);
rtems_filesystem_global_location_assign(
2cf4: e5960000 ldr r0, [r6]
2cf8: e1a01004 mov r1, r4
2cfc: eb0003ea bl 3cac <rtems_filesystem_global_location_assign>
2d00: eaffffbe b 2c00 <mount+0x1d8>
rtems_filesystem_mt_unlock();
} else {
rtems_filesystem_global_location_release( mt_point_node );
}
} else {
rtems_filesystem_eval_path_error( &ctx, EBUSY );
2d04: e28d000c add r0, sp, #12
2d08: e3a01010 mov r1, #16
2d0c: eb000217 bl 3570 <rtems_filesystem_eval_path_error>
rv = -1;
2d10: e3e05000 mvn r5, #0
2d14: eaffffaf b 2bd8 <mount+0x1b0>
rtems_chain_append_unprotected(
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
} else {
errno = EINVAL;
2d18: eb002ab2 bl d7e8 <__errno> <== NOT EXECUTED
2d1c: e3a03016 mov r3, #22 <== NOT EXECUTED
2d20: e5803000 str r3, [r0] <== NOT EXECUTED
2d24: e5960000 ldr r0, [r6] <== NOT EXECUTED
2d28: eb000e7a bl 6718 <rtems_semaphore_release> <== NOT EXECUTED
rv = -1;
2d2c: e3e05000 mvn r5, #0 <== NOT EXECUTED
2d30: eaffffac b 2be8 <mount+0x1c0> <== NOT EXECUTED
00016024 <msdos_creat_node>:
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
16024: 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;
16028: e590c014 ldr ip, [r0, #20]
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
1602c: e1a05000 mov r5, r0 16030: e24dd0ac sub sp, sp, #172 ; 0xac
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;
16034: e3a04000 mov r4, #0
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;
16038: e59c9008 ldr r9, [ip, #8]
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
1603c: e595c008 ldr ip, [r5, #8]
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
16040: e1a06003 mov r6, r3
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
16044: e3e08000 mvn r8, #0 16048: e1a07001 mov r7, r1 1604c: e1a0a002 mov sl, r2
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
16050: e28d0014 add r0, sp, #20 16054: e1a01004 mov r1, r4 16058: e3a02040 mov r2, #64 ; 0x40
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
1605c: e58dc010 str ip, [sp, #16]
fat_file_fd_t *fat_fd = NULL;
16060: e58d40a4 str r4, [sp, #164] ; 0xa4
time_t time_ret = 0;
uint16_t time_val = 0;
16064: e1cd4ab8 strh r4, [sp, #168] ; 0xa8
uint16_t date = 0;
16068: e1cd4aba strh r4, [sp, #170] ; 0xaa
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
1606c: e58d4094 str r4, [sp, #148] ; 0x94
dir_pos->sname.ofs = 0;
16070: e58d4098 str r4, [sp, #152] ; 0x98
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
16074: e58d809c str r8, [sp, #156] ; 0x9c
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
16078: 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);
1607c: e58d4054 str r4, [sp, #84] ; 0x54 16080: e58d4058 str r4, [sp, #88] ; 0x58 16084: e58d405c str r4, [sp, #92] ; 0x5c 16088: e58d4060 str r4, [sp, #96] ; 0x60 1608c: e58d4064 str r4, [sp, #100] ; 0x64 16090: e58d4068 str r4, [sp, #104] ; 0x68 16094: e58d406c str r4, [sp, #108] ; 0x6c 16098: e58d4070 str r4, [sp, #112] ; 0x70
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
1609c: eb0010e1 bl 1a428 <memset>
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
160a0: e3560f41 cmp r6, #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;
160a4: e1a0b004 mov fp, r4
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) {
160a8: ca0000b6 bgt 16388 <msdos_creat_node+0x364>
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
}
name_type = msdos_long_to_short (name, name_len,
160ac: e1a0000a mov r0, sl 160b0: e1a01006 mov r1, r6 160b4: e28d2054 add r2, sp, #84 ; 0x54 160b8: e3a0300b mov r3, #11 160bc: eb00010e bl 164fc <msdos_long_to_short>
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
if (name_type == MSDOS_NAME_INVALID) {
160c0: e3500000 cmp r0, #0 160c4: e58d000c str r0, [sp, #12]
160c8: 0a0000b2 beq 16398 <msdos_creat_node+0x374>
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
/* set up last write date and time */
time_ret = time(NULL);
160cc: e1a00004 mov r0, r4
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;
160d0: e5cd4060 strb r4, [sp, #96] ; 0x60
/* set up last write date and time */
time_ret = time(NULL);
160d4: eb0021a8 bl 1e77c <time>
if ( time_ret == -1 )
160d8: 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);
160dc: e1a08000 mov r8, r0
if ( time_ret == -1 )
160e0: 0a00006c beq 16298 <msdos_creat_node+0x274>
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
160e4: e28d20a8 add r2, sp, #168 ; 0xa8 160e8: e28d10aa add r1, sp, #170 ; 0xaa 160ec: eb000a0c bl 18924 <msdos_date_unix2dos>
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
160f0: e1dd3aba ldrh r3, [sp, #170] ; 0xaa
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);
160f4: e1dd2ab8 ldrh r2, [sp, #168] ; 0xa8
*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) {
160f8: e3570000 cmp r7, #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);
160fc: e1cd26b2 strh r2, [sp, #98] ; 0x62
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
16100: e1cd36b4 strh r3, [sp, #100] ; 0x64
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
16104: e1cd26ba strh r2, [sp, #106] ; 0x6a
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
16108: e1cd36bc strh r3, [sp, #108] ; 0x6c
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
1610c: e1cd36b6 strh r3, [sp, #102] ; 0x66
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
16110: e58d4070 str r4, [sp, #112] ; 0x70
if (type == MSDOS_DIRECTORY) {
16114: 0a000062 beq 162a4 <msdos_creat_node+0x280>
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
}
else if (type == MSDOS_HARD_LINK) {
16118: e3570002 cmp r7, #2
1611c: 0a00006d beq 162d8 <msdos_creat_node+0x2b4>
* 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;
16120: e5dd305f ldrb r3, [sp, #95] ; 0x5f 16124: e3833020 orr r3, r3, #32 16128: 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,
1612c: e59dc00c ldr ip, [sp, #12] 16130: e28d4094 add r4, sp, #148 ; 0x94 16134: e58dc000 str ip, [sp] 16138: e1a00005 mov r0, r5 1613c: e28dc054 add ip, sp, #84 ; 0x54 16140: e3a01001 mov r1, #1 16144: e1a0200a mov r2, sl 16148: e1a03006 mov r3, r6 1614c: e58d4004 str r4, [sp, #4] 16150: e58dc008 str ip, [sp, #8] 16154: eb0005ea bl 17904 <msdos_get_name_node>
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
16158: e2508000 subs r8, r0, #0
1615c: 1a00004d bne 16298 <msdos_creat_node+0x274>
/*
* if we create a new file we are done, if directory there are more steps
* to do
*/
if (type == MSDOS_DIRECTORY)
16160: e3570000 cmp r7, #0
16164: 1a00004b bne 16298 <msdos_creat_node+0x274>
{
/* open new directory as fat-file */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
16168: e1a00009 mov r0, r9 1616c: e1a01004 mov r1, r4 16170: e28d20a4 add r2, sp, #164 ; 0xa4 16174: ebffec12 bl 111c4 <fat_file_open>
if (rc != RC_OK)
16178: e2508000 subs r8, r0, #0
1617c: 1a000050 bne 162c4 <msdos_creat_node+0x2a0>
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
16180: e59d80a4 ldr r8, [sp, #164] ; 0xa4
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
16184: e3a03602 mov r3, #2097152 ; 0x200000 16188: e5883014 str r3, [r8, #20]
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
1618c: e5887018 str r7, [r8, #24]
fat_fd->fat_file_type = FAT_DIRECTORY;
16190: e5887010 str r7, [r8, #16]
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
16194: e28de054 add lr, sp, #84 ; 0x54
16198: e8be000f ldm lr!, {r0, r1, r2, r3}
1619c: e28d6014 add r6, sp, #20
161a0: e8a6000f stmia r6!, {r0, r1, r2, r3}
161a4: e89e000f ldm lr, {r0, r1, r2, r3}
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
161a8: e28dc054 add ip, sp, #84 ; 0x54
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
161ac: e886000f stm r6, {r0, r1, r2, r3}
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
161b0: e8bc000f ldm ip!, {r0, r1, r2, r3}
161b4: e28dc034 add ip, sp, #52 ; 0x34
161b8: e8ac000f stmia ip!, {r0, r1, r2, r3}
161bc: e89e000f ldm lr, {r0, r1, r2, r3}
161c0: e88c000f stm ip, {r0, r1, r2, r3}
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
161c4: e59f3200 ldr r3, [pc, #512] ; 163cc <msdos_creat_node+0x3a8> 161c8: e3a0200b mov r2, #11 161cc: e5931000 ldr r1, [r3] 161d0: e28d0014 add r0, sp, #20 161d4: eb00105d bl 1a350 <memcpy>
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
161d8: e59f31f0 ldr r3, [pc, #496] ; 163d0 <msdos_creat_node+0x3ac> 161dc: e28d0034 add r0, sp, #52 ; 0x34 161e0: e5931000 ldr r1, [r3] 161e4: e3a0200b mov r2, #11 161e8: eb001058 bl 1a350 <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)) &&
161ec: e59dc010 ldr ip, [sp, #16] 161f0: e59c3020 ldr r3, [ip, #32] 161f4: e3530001 cmp r3, #1
161f8: 0a00006a beq 163a8 <msdos_creat_node+0x384>
*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));
161fc: e59dc010 ldr ip, [sp, #16] 16200: e59c301c ldr r3, [ip, #28]
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
16204: e1a02823 lsr r2, r3, #16
*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));
16208: 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));
1620c: e1cd24b8 strh r2, [sp, #72] ; 0x48
/*
* 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,
16210: e28dc014 add ip, sp, #20 16214: e1a00009 mov r0, r9 16218: e1a01008 mov r1, r8 1621c: e3a02000 mov r2, #0 16220: e3a03040 mov r3, #64 ; 0x40 16224: e58dc000 str ip, [sp] 16228: ebffee29 bl 11ad4 <fat_file_write>
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
1622c: e3500000 cmp r0, #0
16230: ba00001f blt 162b4 <msdos_creat_node+0x290>
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
16234: e59d10a4 ldr r1, [sp, #164] ; 0xa4
/* 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));
16238: e2812018 add r2, r1, #24
1623c: e8921004 ldm r2, {r2, ip}
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
16240: e1d930b6 ldrh r3, [r9, #6] 16244: e0823003 add r3, r2, r3 16248: 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));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
1624c: e1a0e82c lsr lr, ip, #16
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
16250: e1cdc2be strh ip, [sp, #46] ; 0x2e
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
16254: e1a00009 mov r0, r9 16258: e28dc014 add ip, sp, #20 1625c: e3a02000 mov r2, #0 16260: e3a03020 mov r3, #32
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
16264: e1cde2b8 strh lr, [sp, #40] ; 0x28
/* rewrite dot entry */
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
16268: e58dc000 str ip, [sp] 1626c: ebffee18 bl 11ad4 <fat_file_write>
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
16270: e3500000 cmp r0, #0
16274: ba00000e blt 162b4 <msdos_creat_node+0x290>
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);
16278: e5950014 ldr r0, [r5, #20] 1627c: e59d10a4 ldr r1, [sp, #164] ; 0xa4 16280: eb00015c bl 167f8 <msdos_set_first_cluster_num>
if (rc != RC_OK)
16284: e2508000 subs r8, r0, #0
16288: 1a00000a bne 162b8 <msdos_creat_node+0x294>
goto error;
fat_file_close(&fs_info->fat, fat_fd);
1628c: e1a00009 mov r0, r9 16290: e59d10a4 ldr r1, [sp, #164] ; 0xa4 16294: ebffed24 bl 1172c <fat_file_close>
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
16298: e1a00008 mov r0, r8
1629c: e28dd0ac add sp, sp, #172 ; 0xac
162a0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* 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;
162a4: e5dd305f ldrb r3, [sp, #95] ; 0x5f 162a8: e3833010 orr r3, r3, #16 162ac: e5cd305f strb r3, [sp, #95] ; 0x5f 162b0: eaffff9d b 1612c <msdos_creat_node+0x108>
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;
162b4: 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);
162b8: e1a00009 mov r0, r9 <== NOT EXECUTED 162bc: e59d10a4 ldr r1, [sp, #164] ; 0xa4 <== NOT EXECUTED 162c0: ebffed19 bl 1172c <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);
162c4: e5950014 ldr r0, [r5, #20] <== NOT EXECUTED 162c8: e1a01004 mov r1, r4 <== NOT EXECUTED 162cc: e3a020e5 mov r2, #229 ; 0xe5 <== NOT EXECUTED 162d0: eb000196 bl 16930 <msdos_set_first_char4file_name> <== NOT EXECUTED
return rc;
162d4: eaffffef b 16298 <msdos_creat_node+0x274> <== NOT EXECUTED
* node to the newly created
*/
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat,
162d8: e59dc0d4 ldr ip, [sp, #212] ; 0xd4 <== NOT EXECUTED 162dc: e59c3020 ldr r3, [ip, #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)) )
162e0: e3530000 cmp r3, #0 <== NOT EXECUTED 162e4: 1a000022 bne 16374 <msdos_creat_node+0x350> <== NOT EXECUTED 162e8: e5d9200e ldrb r2, [r9, #14] <== NOT EXECUTED 162ec: e3120003 tst r2, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
162f0: 15991020 ldrne r1, [r9, #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)) )
162f4: 0a00001e beq 16374 <msdos_creat_node+0x350> <== NOT EXECUTED
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
162f8: e59dc0d4 ldr ip, [sp, #212] ; 0xd4 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
162fc: e1d920b0 ldrh r2, [r9] <== 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);
16300: e59c3024 ldr r3, [ip, #36] ; 0x24 <== NOT EXECUTED 16304: e5d9c002 ldrb ip, [r9, #2] <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
16308: e2422001 sub r2, r2, #1 <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
1630c: e0811c33 add r1, r1, r3, lsr ip <== NOT EXECUTED 16310: e0022003 and r2, r2, r3 <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
16314: e28d4074 add r4, sp, #116 ; 0x74 <== NOT EXECUTED
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));
ret = _fat_block_read(&fs_info->fat,
16318: e1a00009 mov r0, r9 <== NOT EXECUTED 1631c: e3a03020 mov r3, #32 <== NOT EXECUTED 16320: e58d4000 str r4, [sp] <== NOT EXECUTED 16324: ebffef5c bl 1209c <_fat_block_read> <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
16328: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
1632c: 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) {
16330: baffffd8 blt 16298 <msdos_creat_node+0x274> <== NOT EXECUTED
return -1;
}
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
16334: e5d4e00b ldrb lr, [r4, #11] <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
16338: e5d4c00d ldrb ip, [r4, #13] <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
1633c: e1d400be ldrh r0, [r4, #14] <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
16340: e1d411b0 ldrh r1, [r4, #16] <== NOT EXECUTED
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
16344: e594201c ldr r2, [r4, #28] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
16348: e1d431ba ldrh r3, [r4, #26] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
1634c: e1d441b4 ldrh r4, [r4, #20] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
/*
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
16350: e38ee020 orr lr, lr, #32 <== NOT EXECUTED
}
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
16354: e5cdc061 strb ip, [sp, #97] ; 0x61 <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
16358: e1cd06b2 strh r0, [sp, #98] ; 0x62 <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
1635c: e1cd16b4 strh r1, [sp, #100] ; 0x64 <== NOT EXECUTED
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
16360: e58d2070 str r2, [sp, #112] ; 0x70 <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
16364: e1cd36be strh r3, [sp, #110] ; 0x6e <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
16368: e1cd46b8 strh r4, [sp, #104] ; 0x68 <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
/*
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
1636c: e5cde05f strb lr, [sp, #95] ; 0x5f <== NOT EXECUTED 16370: eaffff6d b 1612c <msdos_creat_node+0x108> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
16374: e5d90005 ldrb r0, [r9, #5] <== NOT EXECUTED 16378: e5992034 ldr r2, [r9, #52] ; 0x34 <== NOT EXECUTED 1637c: e2431002 sub r1, r3, #2 <== NOT EXECUTED 16380: e0821011 add r1, r2, r1, lsl r0 <== NOT EXECUTED 16384: eaffffdb b 162f8 <msdos_creat_node+0x2d4> <== NOT EXECUTED
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) {
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
16388: eb000d49 bl 198b4 <__errno> <== NOT EXECUTED 1638c: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED 16390: e5803000 str r3, [r0] <== NOT EXECUTED 16394: eaffffbf b 16298 <msdos_creat_node+0x274> <== NOT EXECUTED
name_type = msdos_long_to_short (name, name_len,
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
if (name_type == MSDOS_NAME_INVALID) {
rtems_set_errno_and_return_minus_one(EINVAL);
16398: eb000d45 bl 198b4 <__errno> <== NOT EXECUTED 1639c: e3a03016 mov r3, #22 <== NOT EXECUTED 163a0: e5803000 str r3, [r0] <== NOT EXECUTED 163a4: eaffffbb b 16298 <msdos_creat_node+0x274> <== NOT EXECUTED
/*
* here we can ommit FAT32 condition because for all FAT types dirs
* right under root dir should contain 0 in dotdot entry but for
* FAT12/16 parent_fat_fd->cluster_num always contains such value
*/
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
163a8: e59c3024 ldr r3, [ip, #36] ; 0x24 163ac: e3530000 cmp r3, #0
163b0: 1affff91 bne 161fc <msdos_creat_node+0x1d8>
(fs_info->fat.vol.type & FAT_FAT32))
163b4: e5d9300e ldrb r3, [r9, #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)) &&
163b8: e3130004 tst r3, #4
(fs_info->fat.vol.type & FAT_FAT32))
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
163bc: 11cd74be strhne r7, [sp, #78] ; 0x4e
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
163c0: 11cd74b8 strhne r7, [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)) &&
163c4: 1affff91 bne 16210 <msdos_creat_node+0x1ec>
163c8: eaffff8b b 161fc <msdos_creat_node+0x1d8>
00018aa8 <msdos_date_dos2unix>:
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
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
18aa8: e2012b3e and r2, r1, #63488 ; 0xf800
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
18aac: e201ce7e and ip, r1, #2016 ; 0x7e0
+ ((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) {
18ab0: e59f30f8 ldr r3, [pc, #248] ; 18bb0 <msdos_date_dos2unix+0x108>
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
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
18ab4: e1a025a2 lsr r2, r2, #11
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
18ab8: e1a0c2ac lsr ip, ip, #5
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
18abc: e0622202 rsb r2, r2, r2, lsl #4
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
18ac0: e06cc20c rsb ip, ip, ip, lsl #4
* 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)
{
18ac4: e92d01f0 push {r4, r5, r6, r7, r8}
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
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
18ac8: e0622202 rsb r2, r2, r2, lsl #4
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
18acc: e1a0c08c lsl ip, ip, #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) {
18ad0: e1d340bc ldrh r4, [r3, #12]
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
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
18ad4: e08c2182 add r2, ip, r2, lsl #3
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)
18ad8: 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;
18adc: e0822001 add r2, r2, r1
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
18ae0: e1540000 cmp r4, r0
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)
18ae4: e1a02082 lsl r2, r2, #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) {
18ae8: 05930010 ldreq r0, [r3, #16]
18aec: 0a000029 beq 18b98 <msdos_date_dos2unix+0xf0> lastdosdate = dd; days = 0; year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
18af0: e2007cfe and r7, r0, #65024 ; 0xfe00
for (y = 0; y < year; y++)
18af4: e1b074a7 lsrs r7, r7, #9
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
lastdosdate = dd;
18af8: e1c300bc strh r0, [r3, #12]
days = 0; year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT; for (y = 0; y < year; y++) 18afc: 0a000028 beq 18ba4 <msdos_date_dos2unix+0xfc>
18b00: e59f60ac ldr r6, [pc, #172] ; 18bb4 <msdos_date_dos2unix+0x10c> 18b04: e3a04000 mov r4, #0
days += y & 0x03 ? 365 : 366;
18b08: e59f10a8 ldr r1, [pc, #168] ; 18bb8 <msdos_date_dos2unix+0x110>
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
18b0c: e1a05004 mov r5, r4
days += y & 0x03 ? 365 : 366;
18b10: e1a08006 mov r8, r6 18b14: ea000002 b 18b24 <msdos_date_dos2unix+0x7c> 18b18: e3150003 tst r5, #3 18b1c: 01a06008 moveq r6, r8 18b20: 11a06001 movne r6, r1
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
18b24: e2855001 add r5, r5, #1 18b28: e1550007 cmp r5, r7
days += y & 0x03 ? 365 : 366;
18b2c: e0844006 add r4, r4, r6
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
18b30: 1afffff8 bne 18b18 <msdos_date_dos2unix+0x70>
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
18b34: e59f1080 ldr r1, [pc, #128] ; 18bbc <msdos_date_dos2unix+0x114> 18b38: e3150003 tst r5, #3 18b3c: e2416018 sub r6, r1, #24 18b40: 01a06001 moveq r6, r1
/* * Prevent going from 0 to 0xffffffff in the following * loop. */ month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
18b44: e2008e1e and r8, r0, #480 ; 0x1e0
if (month == 0) {
18b48: e1b082a8 lsrs r8, r8, #5
18b4c: 0a000007 beq 18b70 <msdos_date_dos2unix+0xc8> month = 1; } for (m = 0; m < month - 1; m++)
18b50: e2588001 subs r8, r8, #1
18b54: 0a000005 beq 18b70 <msdos_date_dos2unix+0xc8>
18b58: e3a05000 mov r5, #0 <== NOT EXECUTED
days += months[m];
18b5c: e0d670b2 ldrh r7, [r6], #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++)
18b60: e2855001 add r5, r5, #1 <== NOT EXECUTED 18b64: e1550008 cmp r5, r8 <== NOT EXECUTED
days += months[m];
18b68: e0844007 add r4, r4, r7 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
18b6c: 3afffffa bcc 18b5c <msdos_date_dos2unix+0xb4> <== NOT EXECUTED
days += months[m]; days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
18b70: e200001f and r0, r0, #31 18b74: e2400001 sub r0, r0, #1 18b78: e0804004 add r4, r0, r4
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
18b7c: e0844084 add r4, r4, r4, lsl #1 18b80: e0644204 rsb r4, r4, r4, lsl #4 18b84: e0644204 rsb r4, r4, r4, lsl #4 18b88: e59f0030 ldr r0, [pc, #48] ; 18bc0 <msdos_date_dos2unix+0x118> 18b8c: e1a04384 lsl r4, r4, #7 18b90: e0840000 add r0, r4, r0 18b94: e5830010 str r0, [r3, #16]
} return seconds + lastseconds; }
18b98: e0800002 add r0, r0, r2
18b9c: e8bd01f0 pop {r4, r5, r6, r7, r8}
18ba0: e12fff1e bx lr
* 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;
18ba4: e1a04007 mov r4, r7 <== NOT EXECUTED
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT; for (y = 0; y < year; y++) days += y & 0x03 ? 365 : 366; months = year & 0x03 ? regyear : leapyear;
18ba8: e59f600c ldr r6, [pc, #12] ; 18bbc <msdos_date_dos2unix+0x114><== NOT EXECUTED 18bac: eaffffe4 b 18b44 <msdos_date_dos2unix+0x9c> <== NOT EXECUTED
00018924 <msdos_date_unix2dos>:
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
18924: e59f3154 ldr r3, [pc, #340] ; 18a80 <msdos_date_unix2dos+0x15c> 18928: e593c000 ldr ip, [r3] 1892c: e15c0000 cmp ip, 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)
{
18930: e92d01f0 push {r4, r5, r6, r7, r8}
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
18934: 0a00004e beq 18a74 <msdos_date_unix2dos+0x150>
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
18938: e59f5144 ldr r5, [pc, #324] ; 18a84 <msdos_date_unix2dos+0x160>
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
1893c: e59f6144 ldr r6, [pc, #324] ; 18a88 <msdos_date_unix2dos+0x164>
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
18940: e0858590 umull r8, r5, r0, r5
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
18944: e084c096 umull ip, r4, r6, r0
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
18948: e59f713c ldr r7, [pc, #316] ; 18a8c <msdos_date_unix2dos+0x168> 1894c: e1a055a5 lsr r5, r5, #11
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
18950: e1a042a4 lsr r4, r4, #5
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
18954: e0878795 umull r8, r7, r5, r7
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
18958: e086c694 umull ip, r6, r4, r6
/* * 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);
1895c: e59fc12c ldr ip, [pc, #300] ; 18a90 <msdos_date_unix2dos+0x16c> 18960: e08c8c90 umull r8, ip, r0, ip
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
18964: e1a07227 lsr r7, r7, #4 18968: e0877087 add r7, r7, r7, lsl #1
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
1896c: e1a062a6 lsr r6, r6, #5
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
18970: e0455187 sub r5, r5, r7, lsl #3
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
18974: e0666206 rsb r6, r6, r6, lsl #4 18978: e0446106 sub r6, r4, r6, lsl #2
* 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)
1897c: e1a05585 lsl r5, r5, #11 18980: e0644204 rsb r4, r4, r4, lsl #4 18984: e0855286 add r5, r5, r6, lsl #5 18988: e0407104 sub r7, r0, r4, lsl #2 1898c: e08570a7 add r7, r5, r7, lsr #1
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
18990: e5935008 ldr r5, [r3, #8]
/* * 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);
18994: e1a0c82c lsr ip, ip, #16
* 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)
18998: e1a07807 lsl r7, r7, #16 1899c: e1a07827 lsr r7, r7, #16
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
189a0: e15c0005 cmp ip, r5
/*
* 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;
189a4: e5830000 str r0, [r3]
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
189a8: e1c370b4 strh r7, [r3, #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);
if (days != lastday) {
189ac: 01d3c0b6 ldrheq ip, [r3, #6]
189b0: 0a000027 beq 18a54 <msdos_date_unix2dos+0x130> lastday = days;
189b4: e583c008 str ip, [r3, #8]
for (year = 1970;; year++) {
189b8: e59f00d4 ldr r0, [pc, #212] ; 18a94 <msdos_date_unix2dos+0x170>
inc = year & 0x03 ? 365 : 366;
189bc: e59f80d4 ldr r8, [pc, #212] ; 18a98 <msdos_date_unix2dos+0x174> 189c0: e59f60d4 ldr r6, [pc, #212] ; 18a9c <msdos_date_unix2dos+0x178> 189c4: ea000001 b 189d0 <msdos_date_unix2dos+0xac>
if (days < inc) break; days -= inc;
189c8: e064c00c rsb ip, r4, ip
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
lastday = days;
for (year = 1970;; year++) {
189cc: e2800001 add r0, r0, #1
inc = year & 0x03 ? 365 : 366;
189d0: e2105003 ands r5, r0, #3 189d4: 01a04008 moveq r4, r8 189d8: 11a04006 movne r4, r6
if (days < inc)
189dc: e15c0004 cmp ip, r4
189e0: 2afffff8 bcs 189c8 <msdos_date_unix2dos+0xa4> break; days -= inc; } months = year & 0x03 ? regyear : leapyear;
189e4: e59f40b4 ldr r4, [pc, #180] ; 18aa0 <msdos_date_unix2dos+0x17c> 189e8: e3550000 cmp r5, #0 189ec: e2446018 sub r6, r4, #24 189f0: 01a06004 moveq r6, r4
for (month = 0; month < 12; month++) {
189f4: e3a04000 mov r4, #0
if (days < months[month])
189f8: e0d650b2 ldrh r5, [r6], #2 189fc: e155000c cmp r5, ip
18a00: 8a000017 bhi 18a64 <msdos_date_unix2dos+0x140>
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
18a04: e2844001 add r4, r4, #1 <== NOT EXECUTED 18a08: e354000c cmp r4, #12 <== NOT EXECUTED
if (days < months[month]) break; days -= months[month];
18a0c: e065c00c rsb ip, r5, ip <== NOT EXECUTED
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
18a10: 1afffff8 bne 189f8 <msdos_date_unix2dos+0xd4> <== NOT EXECUTED 18a14: e3a04e1a mov r4, #416 ; 0x1a0 <== NOT EXECUTED
if (days < months[month]) break; days -= months[month]; } lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
18a18: e2844001 add r4, r4, #1 18a1c: e084c00c add ip, r4, ip
* 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)
18a20: e59f407c ldr r4, [pc, #124] ; 18aa4 <msdos_date_unix2dos+0x180>
for (month = 0; month < 12; month++) {
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
18a24: e1a0c80c lsl ip, ip, #16 18a28: e1a0c82c lsr ip, ip, #16
* 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)
18a2c: e1500004 cmp r0, r4
for (month = 0; month < 12; month++) {
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
18a30: e1c3c0b6 strh ip, [r3, #6]
* 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) 18a34: 9a000006 bls 18a54 <msdos_date_unix2dos+0x130> lastddate += (year - 1980) <<
18a38: e2400e7b sub r0, r0, #1968 ; 0x7b0 18a3c: e240000c sub r0, r0, #12 18a40: e08cc480 add ip, ip, r0, lsl #9 18a44: e1a0c80c lsl ip, ip, #16 18a48: e59f3030 ldr r3, [pc, #48] ; 18a80 <msdos_date_unix2dos+0x15c> 18a4c: e1a0c82c lsr ip, ip, #16 18a50: e1c3c0b6 strh ip, [r3, #6]
MSDOS_DD_YEAR_SHIFT; } } *dtp = lastdtime;
18a54: e1c270b0 strh r7, [r2]
*ddp = lastddate;
18a58: e1c1c0b0 strh ip, [r1]
}
18a5c: e8bd01f0 pop {r4, r5, r6, r7, r8}
18a60: e12fff1e bx lr
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
if (days < months[month])
18a64: e1a04a84 lsl r4, r4, #21 18a68: e2844602 add r4, r4, #2097152 ; 0x200000 18a6c: e1a04824 lsr r4, r4, #16 18a70: eaffffe8 b 18a18 <msdos_date_unix2dos+0xf4>
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
18a74: e1d370b4 ldrh r7, [r3, #4] 18a78: e1d3c0b6 ldrh ip, [r3, #6] 18a7c: eafffff4 b 18a54 <msdos_date_unix2dos+0x130>
00016a88 <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
)
{
16a88: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
16a8c: e5905008 ldr r5, [r0, #8]
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
16a90: e24dd008 sub sp, sp, #8
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;
16a94: e3a09000 mov r9, #0
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
16a98: e58d1004 str r1, [sp, #4]
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;
16a9c: e5c29000 strb r9, [r2] 16aa0: e1d5a0b0 ldrh sl, [r5] 16aa4: e59540a0 ldr r4, [r5, #160] ; 0xa0
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
16aa8: e1a0b002 mov fp, r2
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,
16aac: e1a00005 mov r0, r5 16ab0: e59d1004 ldr r1, [sp, #4] 16ab4: e0020a99 mul r2, r9, sl 16ab8: e1a0300a mov r3, sl 16abc: e58d4000 str r4, [sp] 16ac0: ebffea5d bl 1143c <fat_file_read> 16ac4: e3500000 cmp r0, #0
16ac8: 0a00002c beq 16b80 <msdos_dir_is_empty+0xf8>
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
16acc: e350001f cmp r0, #31
16ad0: da00002d ble 16b8c <msdos_dir_is_empty+0x104>
return -1;
assert(ret == fs_info->fat.vol.bps);
16ad4: e1d5a0b0 ldrh sl, [r5] 16ad8: e15a0000 cmp sl, r0
16adc: 1a00002c bne 16b94 <msdos_dir_is_empty+0x10c>
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
16ae0: e35a0000 cmp sl, #0
16ae4: 0a000022 beq 16b74 <msdos_dir_is_empty+0xec>
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
return -1;
assert(ret == fs_info->fat.vol.bps);
16ae8: e59540a0 ldr r4, [r5, #160] ; 0xa0
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
16aec: e3a06000 mov r6, #0
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
return -1;
assert(ret == fs_info->fat.vol.bps);
16af0: e1a07004 mov r7, r4
* 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)) ==
16af4: e7d48006 ldrb r8, [r4, r6] 16af8: e35800e5 cmp r8, #229 ; 0xe5
16afc: 0a000016 beq 16b5c <msdos_dir_is_empty+0xd4>
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
16b00: e5d7300b ldrb r3, [r7, #11] 16b04: 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) ||
16b08: e353000f cmp r3, #15
16b0c: 0a000012 beq 16b5c <msdos_dir_is_empty+0xd4>
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
16b10: e1a00007 mov r0, r7 16b14: e59f108c ldr r1, [pc, #140] ; 16ba8 <msdos_dir_is_empty+0x120> 16b18: e3a0200b mov r2, #11 16b1c: eb0014ba bl 1be0c <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) ||
16b20: e3500000 cmp r0, #0
16b24: 0a00000c beq 16b5c <msdos_dir_is_empty+0xd4>
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
16b28: e1a00007 mov r0, r7 16b2c: e59f1078 ldr r1, [pc, #120] ; 16bac <msdos_dir_is_empty+0x124> 16b30: e3a0200b mov r2, #11 16b34: eb0014b4 bl 1be0c <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) ||
16b38: e3500000 cmp r0, #0
16b3c: 0a000006 beq 16b5c <msdos_dir_is_empty+0xd4>
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
16b40: e3580000 cmp r8, #0
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
16b44: 03a03001 moveq r3, #1 16b48: 05cb3000 strbeq r3, [fp]
return RC_OK;
16b4c: 01a00008 moveq r0, r8
}
/*
* Short file name entries mean not empty.
*/
return RC_OK;
16b50: 13a00000 movne r0, #0
}
j++;
}
*ret_val = true;
return RC_OK;
}
16b54: e28dd008 add sp, sp, #8
16b58: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
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)
16b5c: e2866020 add r6, r6, #32
return -1;
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
16b60: e156000a cmp r6, sl
i < fs_info->fat.vol.bps;
i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
16b64: e2877020 add r7, r7, #32
return -1;
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
16b68: 3affffe1 bcc 16af4 <msdos_dir_is_empty+0x6c>
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
16b6c: e2899001 add r9, r9, #1 <== NOT EXECUTED 16b70: eaffffcd b 16aac <msdos_dir_is_empty+0x24> <== NOT EXECUTED
*/
if ((*MSDOS_DIR_NAME(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
return RC_OK;
16b74: e59540a0 ldr r4, [r5, #160] ; 0xa0 <== NOT EXECUTED
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
16b78: e2899001 add r9, r9, #1 <== NOT EXECUTED 16b7c: eaffffca b 16aac <msdos_dir_is_empty+0x24> <== NOT EXECUTED
}
*ret_val = true;
16b80: e3a03001 mov r3, #1 <== NOT EXECUTED 16b84: e5cb3000 strb r3, [fp] <== NOT EXECUTED
return RC_OK;
16b88: eafffff1 b 16b54 <msdos_dir_is_empty+0xcc> <== 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;
16b8c: e3e00000 mvn r0, #0 <== NOT EXECUTED 16b90: eaffffef b 16b54 <msdos_dir_is_empty+0xcc> <== NOT EXECUTED
assert(ret == fs_info->fat.vol.bps);
16b94: e59f0014 ldr r0, [pc, #20] ; 16bb0 <msdos_dir_is_empty+0x128><== NOT EXECUTED 16b98: e59f1014 ldr r1, [pc, #20] ; 16bb4 <msdos_dir_is_empty+0x12c><== NOT EXECUTED 16b9c: e59f2014 ldr r2, [pc, #20] ; 16bb8 <msdos_dir_is_empty+0x130><== NOT EXECUTED 16ba0: e59f3014 ldr r3, [pc, #20] ; 16bbc <msdos_dir_is_empty+0x134><== NOT EXECUTED 16ba4: ebfff2fa bl 13794 <__assert_func> <== NOT EXECUTED
00018d9c <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)
{
18d9c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
18da0: e5903018 ldr r3, [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)
{
18da4: e24ddf55 sub sp, sp, #340 ; 0x154 <== NOT EXECUTED 18da8: e58d000c str r0, [sp, #12] <== 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 :
18dac: e593c020 ldr ip, [r3, #32] <== NOT EXECUTED
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
18db0: e5900024 ldr r0, [r0, #36] ; 0x24 <== 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)
{
18db4: e58d101c str r1, [sp, #28] <== 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);
18db8: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
18dbc: e58d3014 str r3, [sp, #20] <== 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 :
18dc0: e35c0001 cmp ip, #1 <== NOT EXECUTED
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
fat_file_fd_t *tmp_fat_fd = NULL;
18dc4: e3a03000 mov r3, #0 <== 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)
{
18dc8: e1a04002 mov r4, r2 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
18dcc: e5905008 ldr r5, [r0, #8] <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
fat_file_fd_t *tmp_fat_fd = NULL;
18dd0: 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;
18dd4: e58d3150 str r3, [sp, #336] ; 0x150 <== 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);
18dd8: e99100c0 ldmib r1, {r6, r7} <== 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 :
18ddc: 0a0000fc beq 191d4 <msdos_dir_read+0x438> <== NOT EXECUTED 18de0: e1d510b6 ldrh r1, [r5, #6] <== NOT EXECUTED 18de4: e58d1020 str r1, [sp, #32] <== NOT EXECUTED
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
18de8: e3a01000 mov r1, #0 <== NOT EXECUTED 18dec: e595009c ldr r0, [r5, #156] ; 0x9c <== NOT EXECUTED 18df0: e1a02001 mov r2, r1 <== NOT EXECUTED 18df4: ebffbe8f bl 8838 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
18df8: e3500000 cmp r0, #0 <== NOT EXECUTED 18dfc: 1a00011f bne 19280 <msdos_dir_read+0x4e4> <== NOT EXECUTED
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
18e00: e59fb504 ldr fp, [pc, #1284] ; 1930c <msdos_dir_read+0x570><== NOT EXECUTED 18e04: e08b2b94 umull r2, fp, r4, fp <== NOT EXECUTED 18e08: e1a0b42b lsr fp, fp, #8 <== NOT EXECUTED 18e0c: e08bb20b add fp, fp, fp, lsl #4 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
18e10: e1b0b20b lsls fp, fp, #4 <== NOT EXECUTED 18e14: 01a0300b moveq r3, fp <== NOT EXECUTED 18e18: 0a000090 beq 19060 <msdos_dir_read+0x2c4> <== 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);
18e1c: e58d0008 str r0, [sp, #8] <== NOT EXECUTED 18e20: e3a03000 mov r3, #0 <== NOT EXECUTED 18e24: e1a00006 mov r0, r6 <== NOT EXECUTED 18e28: e1a01007 mov r1, r7 <== NOT EXECUTED 18e2c: e3a02e11 mov r2, #272 ; 0x110 <== NOT EXECUTED 18e30: ebffa287 bl 1854 <__divdi3> <== NOT EXECUTED 18e34: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 18e38: e58d3010 str r3, [sp, #16] <== NOT EXECUTED 18e3c: e58d3018 str r3, [sp, #24] <== NOT EXECUTED 18e40: e1a08000 mov r8, r0 <== NOT EXECUTED 18e44: e3e0a000 mvn sl, #0 <== NOT EXECUTED 18e48: e1a09003 mov r9, r3 <== 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),
18e4c: e595c0a0 ldr ip, [r5, #160] ; 0xa0 <== NOT EXECUTED 18e50: e1a00005 mov r0, r5 <== NOT EXECUTED 18e54: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED 18e58: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 18e5c: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 18e60: e58dc000 str ip, [sp] <== NOT EXECUTED 18e64: ebffe174 bl 1143c <fat_file_read> <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
18e68: 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),
18e6c: e1a06000 mov r6, r0 <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
18e70: da000100 ble 19278 <msdos_dir_read+0x4dc> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
18e74: e59570a0 ldr r7, [r5, #160] ; 0xa0 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
18e78: e5d73000 ldrb r3, [r7] <== NOT EXECUTED 18e7c: e3530000 cmp r3, #0 <== NOT EXECUTED 18e80: 0a0000c9 beq 191ac <msdos_dir_read+0x410> <== NOT EXECUTED 18e84: e3a04000 mov r4, #0 <== NOT EXECUTED 18e88: ea000009 b 18eb4 <msdos_dir_read+0x118> <== NOT EXECUTED
/* Is the directory entry empty */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
18e8c: e352000f cmp r2, #15 <== NOT EXECUTED 18e90: 0a000060 beq 19018 <msdos_dir_read+0x27c> <== 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)
18e94: e2844020 add r4, r4, #32 <== NOT EXECUTED 18e98: e1540006 cmp r4, r6 <== NOT EXECUTED 18e9c: 2a000068 bcs 19044 <msdos_dir_read+0x2a8> <== NOT EXECUTED
{
char* entry = (char*) fs_info->cl_buf + i;
18ea0: e59570a0 ldr r7, [r5, #160] ; 0xa0 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
18ea4: e7d73004 ldrb r3, [r7, r4] <== NOT EXECUTED 18ea8: e3530000 cmp r3, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
18eac: e0877004 add r7, r7, r4 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
18eb0: 0a0000bd beq 191ac <msdos_dir_read+0x410> <== 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)
18eb4: e35300e5 cmp r3, #229 ; 0xe5 <== NOT EXECUTED 18eb8: 0afffff5 beq 18e94 <msdos_dir_read+0xf8> <== NOT EXECUTED
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
18ebc: e5d7200b ldrb r2, [r7, #11] <== NOT EXECUTED 18ec0: e3120008 tst r2, #8 <== NOT EXECUTED
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) != MSDOS_ATTR_LFN))
18ec4: e202203f and r2, r2, #63 ; 0x3f <== NOT EXECUTED
/* Is the directory entry empty */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
18ec8: 1affffef bne 18e8c <msdos_dir_read+0xf0> <== 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) ==
18ecc: e352000f cmp r2, #15 <== NOT EXECUTED 18ed0: 0a000050 beq 19018 <msdos_dir_read+0x27c> <== NOT EXECUTED
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
18ed4: e3580000 cmp r8, #0 <== NOT EXECUTED
{
lfn_start = FAT_FILE_SHORT_NAME;
start--;
18ed8: 12488001 subne r8, r8, #1 <== NOT EXECUTED
/*
* Skip active entries until get the entry to start from.
*/
if (start)
{
lfn_start = FAT_FILE_SHORT_NAME;
18edc: 13e0a000 mvnne sl, #0 <== NOT EXECUTED
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
18ee0: 1affffeb bne 18e94 <msdos_dir_read+0xf8> <== 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,
18ee4: e28dce15 add ip, sp, #336 ; 0x150 <== NOT EXECUTED 18ee8: e1a00005 mov r0, r5 <== NOT EXECUTED 18eec: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED 18ef0: e3a02001 mov r2, #1 <== NOT EXECUTED 18ef4: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 18ef8: e58dc000 str ip, [sp] <== NOT EXECUTED 18efc: ebffe233 bl 117d0 <fat_file_ioctl> <== NOT EXECUTED
j * bts2rd, &cur_cln);
if (rc != RC_OK)
18f00: e3500000 cmp r0, #0 <== NOT EXECUTED 18f04: 1a0000bc bne 191fc <msdos_dir_read+0x460> <== 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;
18f08: e3e03000 mvn r3, #0 <== NOT EXECUTED 18f0c: e58d3144 str r3, [sp, #324] ; 0x144 <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
18f10: 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;
18f14: 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);
18f18: e1a00005 mov r0, r5 <== NOT EXECUTED 18f1c: e28d1f4f add r1, sp, #316 ; 0x13c <== NOT EXECUTED 18f20: 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;
18f24: e58d313c str r3, [sp, #316] ; 0x13c <== NOT EXECUTED
dir_pos.sname.ofs = i;
18f28: e58d4140 str r4, [sp, #320] ; 0x140 <== NOT EXECUTED
rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
18f2c: ebffe0a4 bl 111c4 <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
18f30: e3500000 cmp r0, #0 <== NOT EXECUTED 18f34: 1a0000b0 bne 191fc <msdos_dir_read+0x460> <== NOT EXECUTED
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
tmp_dirent.d_reclen = sizeof(struct dirent);
tmp_dirent.d_ino = tmp_fat_fd->ino;
18f38: e59d314c ldr r3, [sp, #332] ; 0x14c <== NOT EXECUTED 18f3c: e593300c ldr r3, [r3, #12] <== NOT EXECUTED
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
tmp_dirent.d_reclen = sizeof(struct dirent);
18f40: e3a02e11 mov r2, #272 ; 0x110 <== 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)
18f44: e37a0001 cmn sl, #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;
18f48: e58d9030 str r9, [sp, #48] ; 0x30 <== NOT EXECUTED 18f4c: e58d8034 str r8, [sp, #52] ; 0x34 <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
18f50: e1cd23b8 strh r2, [sp, #56] ; 0x38 <== NOT EXECUTED
tmp_dirent.d_ino = tmp_fat_fd->ino;
18f54: 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)
18f58: 0a000012 beq 18fa8 <msdos_dir_read+0x20c> <== 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)
18f5c: e287c00b add ip, r7, #11 <== NOT EXECUTED 18f60: e1a03007 mov r3, r7 <== NOT EXECUTED 18f64: e1a02008 mov r2, r8 <== 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;
18f68: e1a00008 mov r0, r8 <== NOT EXECUTED 18f6c: ea000001 b 18f78 <msdos_dir_read+0x1dc> <== NOT EXECUTED 18f70: e2100001 ands r0, r0, #1 <== NOT EXECUTED 18f74: 13a00080 movne r0, #128 ; 0x80 <== NOT EXECUTED 18f78: e4d31001 ldrb r1, [r3], #1 <== NOT EXECUTED 18f7c: e08120a2 add r2, r1, r2, lsr #1 <== NOT EXECUTED 18f80: e20220ff and r2, r2, #255 ; 0xff <== NOT EXECUTED 18f84: e0820000 add r0, r2, r0 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
18f88: e153000c cmp r3, ip <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
18f8c: e20020ff and r2, r0, #255 ; 0xff <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
18f90: 1afffff6 bne 18f70 <msdos_dir_read+0x1d4> <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
18f94: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 18f98: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 18f9c: e3510000 cmp r1, #0 <== NOT EXECUTED 18fa0: 01520003 cmpeq r2, r3 <== NOT EXECUTED 18fa4: 0a000064 beq 1913c <msdos_dir_read+0x3a0> <== 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)
18fa8: e287c008 add ip, r7, #8 <== NOT EXECUTED 18fac: e1a0300c mov r3, ip <== NOT EXECUTED 18fb0: e3a01008 mov r1, #8 <== NOT EXECUTED
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN-1);
((i > 0) &&
18fb4: e5732001 ldrb r2, [r3, #-1]! <== NOT EXECUTED 18fb8: e3520020 cmp r2, #32 <== NOT EXECUTED 18fbc: 1a000094 bne 19214 <msdos_dir_read+0x478> <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
18fc0: e2511001 subs r1, r1, #1 <== NOT EXECUTED 18fc4: 1afffffa bne 18fb4 <msdos_dir_read+0x218> <== NOT EXECUTED 18fc8: e58d1024 str r1, [sp, #36] ; 0x24 <== 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(
18fcc: e28d303c add r3, sp, #60 ; 0x3c <== 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) &&
18fd0: e5d7200a ldrb r2, [r7, #10] <== NOT EXECUTED 18fd4: e3520020 cmp r2, #32 <== NOT EXECUTED 18fd8: 1a0000c9 bne 19304 <msdos_dir_read+0x568> <== NOT EXECUTED 18fdc: e5d72009 ldrb r2, [r7, #9] <== NOT EXECUTED 18fe0: e3520020 cmp r2, #32 <== NOT EXECUTED 18fe4: 1a0000aa bne 19294 <msdos_dir_read+0x4f8> <== NOT EXECUTED 18fe8: e5d72008 ldrb r2, [r7, #8] <== NOT EXECUTED 18fec: e3520020 cmp r2, #32 <== NOT EXECUTED 18ff0: 13a0e001 movne lr, #1 <== NOT EXECUTED 18ff4: 1a0000a7 bne 19298 <msdos_dir_read+0x4fc> <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
18ff8: e3a02000 mov r2, #0 <== NOT EXECUTED 18ffc: e5c32000 strb r2, [r3] <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
19000: e59f3308 ldr r3, [pc, #776] ; 19310 <msdos_dir_read+0x574> <== NOT EXECUTED 19004: e59d2024 ldr r2, [sp, #36] ; 0x24 <== NOT EXECUTED 19008: e28d1f55 add r1, sp, #340 ; 0x154 <== NOT EXECUTED 1900c: e18120b3 strh r2, [r1, r3] <== NOT EXECUTED 19010: e3e0a000 mvn sl, #0 <== NOT EXECUTED 19014: ea00004d b 19150 <msdos_dir_read+0x3b4> <== NOT EXECUTED
int q;
/*
* Is this is the first entry of a LFN ?
*/
if (lfn_start == FAT_FILE_SHORT_NAME)
19018: e37a0001 cmn sl, #1 <== NOT EXECUTED 1901c: 0a000038 beq 19104 <msdos_dir_read+0x368> <== 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) &
19020: e5d73000 ldrb r3, [r7] <== NOT EXECUTED 19024: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 19028: e203303f and r3, r3, #63 ; 0x3f <== NOT EXECUTED 1902c: e1530001 cmp r3, r1 <== NOT EXECUTED 19030: 0a00000f beq 19074 <msdos_dir_read+0x2d8> <== 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)
19034: e2844020 add r4, r4, #32 <== NOT EXECUTED 19038: e1540006 cmp r4, r6 <== 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;
1903c: e3e0a000 mvn sl, #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)
19040: 3affff96 bcc 18ea0 <msdos_dir_read+0x104> <== NOT EXECUTED 19044: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 19048: e59d3020 ldr r3, [sp, #32] <== 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)
1904c: e35b0000 cmp fp, #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)
19050: e0822003 add r2, r2, r3 <== NOT EXECUTED 19054: e58d2008 str r2, [sp, #8] <== 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)
19058: 1affff7b bne 18e4c <msdos_dir_read+0xb0> <== NOT EXECUTED 1905c: e1a03009 mov r3, r9 <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
19060: e595009c ldr r0, [r5, #156] ; 0x9c <== NOT EXECUTED 19064: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 19068: ebffbe3b bl 895c <rtems_semaphore_release> <== NOT EXECUTED 1906c: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
return cmpltd;
19070: ea000050 b 191b8 <msdos_dir_read+0x41c> <== NOT EXECUTED
* be orphaned entries depending on the history of the
* disk.
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK)) ||
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
19074: e5d7c00d ldrb ip, [r7, #13] <== NOT EXECUTED
* 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) &
MSDOS_LAST_LONG_ENTRY_MASK)) ||
19078: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 1907c: e15c0002 cmp ip, r2 <== NOT EXECUTED 19080: 1affffeb bne 19034 <msdos_dir_read+0x298> <== 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--;
19084: e2411001 sub r1, r1, #1 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
19088: e0813081 add r3, r1, r1, lsl #1 <== 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--;
1908c: e58d1010 str r1, [sp, #16] <== NOT EXECUTED
p = entry + 1;
19090: e2877001 add r7, r7, #1 <== NOT EXECUTED
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
19094: e0813103 add r3, r1, r3, lsl #2 <== NOT EXECUTED 19098: e3a02000 mov r2, #0 <== 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)
1909c: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
190a0: e35300fe cmp r3, #254 ; 0xfe <== 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)
190a4: e0810003 add r0, r1, r3 <== NOT EXECUTED
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
190a8: e1a01002 mov r1, r2 <== NOT EXECUTED
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
190ac: 8a000012 bhi 190fc <msdos_dir_read+0x360> <== NOT EXECUTED
break;
tmp_dirent.d_name[o++] = *p;
190b0: e5d7e000 ldrb lr, [r7] <== NOT EXECUTED 190b4: e5c0e010 strb lr, [r0, #16] <== NOT EXECUTED
if (*p == '\0')
190b8: e5d70000 ldrb r0, [r7] <== NOT EXECUTED 190bc: e3500000 cmp r0, #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;
190c0: e2822001 add r2, r2, #1 <== NOT EXECUTED 190c4: e2833001 add r3, r3, #1 <== NOT EXECUTED
if (*p == '\0')
190c8: 0a00000b beq 190fc <msdos_dir_read+0x360> <== NOT EXECUTED
break;
switch (q)
190cc: e3510004 cmp r1, #4 <== NOT EXECUTED 190d0: 0a00003b beq 191c4 <msdos_dir_read+0x428> <== NOT EXECUTED 190d4: e351000a cmp r1, #10 <== NOT EXECUTED 190d8: 0a00003b beq 191cc <msdos_dir_read+0x430> <== 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++)
190dc: e352000d cmp r2, #13 <== NOT EXECUTED 190e0: 0a000005 beq 190fc <msdos_dir_read+0x360> <== 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)
190e4: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
190e8: e35300fe cmp r3, #254 ; 0xfe <== 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)
190ec: e0810003 add r0, r1, r3 <== NOT EXECUTED
break;
case 10:
p += 4;
break;
default:
p += 2;
190f0: e2877002 add r7, r7, #2 <== NOT EXECUTED
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
190f4: e1a01002 mov r1, r2 <== NOT EXECUTED
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
190f8: 9affffec bls 190b0 <msdos_dir_read+0x314> <== 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++)
190fc: e58dc018 str ip, [sp, #24] <== NOT EXECUTED 19100: ea000026 b 191a0 <msdos_dir_read+0x404> <== NOT EXECUTED
if (lfn_start == FAT_FILE_SHORT_NAME)
{
/*
* The first entry must have the last long entry flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
19104: e3130040 tst r3, #64 ; 0x40 <== NOT EXECUTED 19108: 0affff61 beq 18e94 <msdos_dir_read+0xf8> <== NOT EXECUTED
/*
* Remember the start location of the long file name.
*/
lfn_start =
((j * bts2rd) + i) / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
1910c: e59d1008 ldr r1, [sp, #8] <== 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) &
19110: e203303f and r3, r3, #63 ; 0x3f <== NOT EXECUTED 19114: e58d3010 str r3, [sp, #16] <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
19118: e5d7300d ldrb r3, [r7, #13] <== NOT EXECUTED
/*
* Remember the start location of the long file name.
*/
lfn_start =
((j * bts2rd) + i) / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
1911c: e081a004 add sl, r1, r4 <== NOT EXECUTED
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
19120: e28d003c add r0, sp, #60 ; 0x3c <== NOT EXECUTED 19124: e3a01000 mov r1, #0 <== NOT EXECUTED 19128: e3a02c01 mov r2, #256 ; 0x100 <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
1912c: e1a0a2aa lsr sl, sl, #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) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
19130: e58d3018 str r3, [sp, #24] <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
19134: eb0004bb bl 1a428 <memset> <== NOT EXECUTED 19138: eaffffb8 b 19020 <msdos_dir_read+0x284> <== 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);
1913c: e28d003c add r0, sp, #60 ; 0x3c <== NOT EXECUTED 19140: eb000b19 bl 1bdac <strlen> <== NOT EXECUTED 19144: e59f31c4 ldr r3, [pc, #452] ; 19310 <msdos_dir_read+0x574> <== NOT EXECUTED 19148: e28d1f55 add r1, sp, #340 ; 0x154 <== NOT EXECUTED 1914c: e18100b3 strh r0, [r1, r3] <== NOT EXECUTED
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
19150: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 19154: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 19158: e3a02e11 mov r2, #272 ; 0x110 <== NOT EXECUTED 1915c: e0830009 add r0, r3, r9 <== NOT EXECUTED 19160: eb00047a bl 1a350 <memcpy> <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
19164: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED
19168: e991000c ldmib r1, {r2, r3} <== NOT EXECUTED
1916c: e3a00e11 mov r0, #272 ; 0x110 <== NOT EXECUTED
19170: e0922000 adds r2, r2, r0 <== NOT EXECUTED
19174: e3a01000 mov r1, #0 <== NOT EXECUTED
19178: e0a33001 adc r3, r3, r1 <== NOT EXECUTED
1917c: e59d100c ldr r1, [sp, #12] <== 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);
19180: e1a00005 mov r0, r5 <== NOT EXECUTED
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
19184: e981000c stmib r1, {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);
19188: e59d114c ldr r1, [sp, #332] ; 0x14c <== NOT EXECUTED 1918c: ebffe166 bl 1172c <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
19190: e3500000 cmp r0, #0 <== NOT EXECUTED 19194: 1a000018 bne 191fc <msdos_dir_read+0x460> <== NOT EXECUTED
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
cmpltd += (sizeof(struct dirent));
19198: e2899e11 add r9, r9, #272 ; 0x110 <== NOT EXECUTED
count -= (sizeof(struct dirent));
1919c: e24bbe11 sub fp, fp, #272 ; 0x110 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
191a0: e35b0000 cmp fp, #0 <== NOT EXECUTED 191a4: 1affff3a bne 18e94 <msdos_dir_read+0xf8> <== NOT EXECUTED 191a8: eaffffab b 1905c <msdos_dir_read+0x2c0> <== NOT EXECUTED
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
rtems_semaphore_release(fs_info->vol_sema);
191ac: e595009c ldr r0, [r5, #156] ; 0x9c <== NOT EXECUTED 191b0: ebffbde9 bl 895c <rtems_semaphore_release> <== NOT EXECUTED
return cmpltd;
191b4: e1a03009 mov r3, r9 <== NOT EXECUTED
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
191b8: e1a00003 mov r0, r3 <== NOT EXECUTED
191bc: e28ddf55 add sp, sp, #340 ; 0x154 <== NOT EXECUTED
191c0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
break;
switch (q)
{
case 4:
p += 5;
191c4: e2877005 add r7, r7, #5 <== NOT EXECUTED
break;
191c8: eaffffb3 b 1909c <msdos_dir_read+0x300> <== NOT EXECUTED
case 10:
p += 4;
191cc: e2877004 add r7, r7, #4 <== NOT EXECUTED
break;
191d0: eaffffb1 b 1909c <msdos_dir_read+0x300> <== 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) &&
191d4: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 191d8: e5923024 ldr r3, [r2, #36] ; 0x24 <== NOT EXECUTED 191dc: e3530000 cmp r3, #0 <== NOT EXECUTED 191e0: 1afffefe bne 18de0 <msdos_dir_read+0x44> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
191e4: e5d5300e ldrb r3, [r5, #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) &&
191e8: e3130003 tst r3, #3 <== NOT EXECUTED 191ec: 0afffefb beq 18de0 <msdos_dir_read+0x44> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
191f0: e5923018 ldr r3, [r2, #24] <== NOT EXECUTED 191f4: e58d3020 str r3, [sp, #32] <== NOT EXECUTED 191f8: eafffefa b 18de8 <msdos_dir_read+0x4c> <== NOT EXECUTED 191fc: e1a03000 mov r3, r0 <== 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);
19200: e595009c ldr r0, [r5, #156] ; 0x9c <== NOT EXECUTED 19204: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 19208: ebffbdd3 bl 895c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
1920c: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 19210: eaffffe8 b 191b8 <msdos_dir_read+0x41c> <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
19214: e3510000 cmp r1, #0 <== NOT EXECUTED 19218: e58d1024 str r1, [sp, #36] ; 0x24 <== 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(
1921c: d28d303c addle r3, sp, #60 ; 0x3c <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
19220: daffff6a ble 18fd0 <msdos_dir_read+0x234> <== NOT EXECUTED 19224: e59f20e8 ldr r2, [pc, #232] ; 19314 <msdos_dir_read+0x578> <== NOT EXECUTED 19228: e592a000 ldr sl, [r2] <== 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)
1922c: e0872001 add r2, r7, r1 <== 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(
19230: e58db028 str fp, [sp, #40] ; 0x28 <== 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)
19234: e1a03007 mov r3, r7 <== 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(
19238: e28d003c add r0, sp, #60 ; 0x3c <== NOT EXECUTED 1923c: e1a0b002 mov fp, r2 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
19240: e4d32001 ldrb r2, [r3], #1 <== NOT EXECUTED 19244: e08ae002 add lr, sl, r2 <== NOT EXECUTED 19248: e5dee001 ldrb lr, [lr, #1] <== NOT EXECUTED 1924c: e20ee003 and lr, lr, #3 <== NOT EXECUTED 19250: e35e0001 cmp lr, #1 <== NOT EXECUTED 19254: 02822020 addeq r2, r2, #32 <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
19258: e153000b cmp r3, fp <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
1925c: e4c02001 strb r2, [r0], #1 <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
19260: 1afffff6 bne 19240 <msdos_dir_read+0x4a4> <== NOT EXECUTED 19264: e2813010 add r3, r1, #16 <== NOT EXECUTED 19268: e28d202c add r2, sp, #44 ; 0x2c <== NOT EXECUTED 1926c: e59db028 ldr fp, [sp, #40] ; 0x28 <== NOT EXECUTED 19270: e0823003 add r3, r2, r3 <== NOT EXECUTED 19274: eaffff55 b 18fd0 <msdos_dir_read+0x234> <== NOT EXECUTED
*/
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
rtems_semaphore_release(fs_info->vol_sema);
19278: e595009c ldr r0, [r5, #156] ; 0x9c <== NOT EXECUTED 1927c: ebffbdb6 bl 895c <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
19280: eb00018b bl 198b4 <__errno> <== NOT EXECUTED 19284: e3a03005 mov r3, #5 <== NOT EXECUTED 19288: e5803000 str r3, [r0] <== NOT EXECUTED 1928c: e3e03000 mvn r3, #0 <== NOT EXECUTED 19290: eaffffc8 b 191b8 <msdos_dir_read+0x41c> <== NOT EXECUTED
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
(*src_tmp == ' '));
i--,src_tmp--)
19294: e3a0e002 mov lr, #2 <== NOT EXECUTED
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
19298: e28e0001 add r0, lr, #1 <== NOT EXECUTED 1929c: e0810000 add r0, r1, r0 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
192a0: e3a0202e mov r2, #46 ; 0x2e <== NOT EXECUTED 192a4: e1a0a003 mov sl, r3 <== NOT EXECUTED
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
192a8: e59f1064 ldr r1, [pc, #100] ; 19314 <msdos_dir_read+0x578> <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
192ac: e4ca2001 strb r2, [sl], #1 <== NOT EXECUTED
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
192b0: e24e2001 sub r2, lr, #1 <== NOT EXECUTED 192b4: e58d2028 str r2, [sp, #40] ; 0x28 <== NOT EXECUTED 192b8: e5917000 ldr r7, [r1] <== NOT EXECUTED
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
192bc: e58d0024 str r0, [sp, #36] ; 0x24 <== 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)
192c0: e083000e add r0, r3, lr <== 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++));
192c4: e4dc2001 ldrb r2, [ip], #1 <== NOT EXECUTED 192c8: e0871002 add r1, r7, r2 <== NOT EXECUTED 192cc: e5d11001 ldrb r1, [r1, #1] <== NOT EXECUTED 192d0: e2011003 and r1, r1, #3 <== NOT EXECUTED 192d4: e3510001 cmp r1, #1 <== NOT EXECUTED 192d8: 02822020 addeq r2, r2, #32 <== NOT EXECUTED 192dc: e5e32001 strb r2, [r3, #1]! <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
192e0: e1530000 cmp r3, r0 <== NOT EXECUTED 192e4: 1afffff6 bne 192c4 <msdos_dir_read+0x528> <== 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)
192e8: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 192ec: e59d1028 ldr r1, [sp, #40] ; 0x28 <== NOT EXECUTED 192f0: e2832001 add r2, r3, #1 <== NOT EXECUTED 192f4: e0822001 add r2, r2, r1 <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
192f8: e08a300e add r3, sl, lr <== 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)
192fc: e58d2024 str r2, [sp, #36] ; 0x24 <== NOT EXECUTED 19300: eaffff3c b 18ff8 <msdos_dir_read+0x25c> <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
}
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
19304: e3a0e003 mov lr, #3 <== NOT EXECUTED 19308: eaffffe2 b 19298 <msdos_dir_read+0x4fc> <== NOT EXECUTED
00019318 <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;
19318: e5902014 ldr r2, [r0, #20]
int
msdos_dir_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
1931c: e92d43f0 push {r4, r5, r6, r7, r8, r9, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
19320: e5925008 ldr r5, [r2, #8]
int
msdos_dir_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
19324: 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,
19328: e3a01000 mov r1, #0
int
msdos_dir_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
1932c: e1a03000 mov r3, r0
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,
19330: e1a02001 mov r2, r1 19334: e595009c ldr r0, [r5, #156] ; 0x9c
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;
19338: e5936008 ldr r6, [r3, #8]
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
1933c: ebffbd3d bl 8838 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
19340: e2507000 subs r7, r0, #0
19344: 1a000017 bne 193a8 <msdos_dir_stat+0x90>
static inline dev_t rtems_disk_get_device_identifier(
const rtems_disk_device *dd
)
{
return dd->dev;
19348: e5952064 ldr r2, [r5, #100] ; 0x64
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;
1934c: e596c00c ldr ip, [r6, #12]
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
19350: e8920300 ldm r2, {r8, r9}
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;
19354: e5963018 ldr r3, [r6, #24]
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
19358: e1d510b0 ldrh r1, [r5]
buf->st_mtime = fat_fd->mtime;
1935c: e5962040 ldr r2, [r6, #64] ; 0x40
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
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;
19360: e584c008 str ip, [r4, #8]
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
19364: e59fc050 ldr ip, [pc, #80] ; 193bc <msdos_dir_stat+0xa4>
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
19368: e1a004a3 lsr r0, r3, #9
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
1936c: e8840300 stm r4, {r8, r9}
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
19370: e3a08000 mov r8, #0 19374: e3a09000 mov r9, #0
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
19378: e5840044 str r0, [r4, #68] ; 0x44
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;
1937c: e584c00c str ip, [r4, #12]
buf->st_rdev = 0ll;
19380: e5848018 str r8, [r4, #24] 19384: e584901c str r9, [r4, #28]
buf->st_size = fat_fd->fat_file_size;
19388: e5843020 str r3, [r4, #32] 1938c: 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;
19390: e5841040 str r1, [r4, #64] ; 0x40
buf->st_mtime = fat_fd->mtime;
19394: e5842030 str r2, [r4, #48] ; 0x30
rtems_semaphore_release(fs_info->vol_sema);
19398: e595009c ldr r0, [r5, #156] ; 0x9c 1939c: ebffbd6e bl 895c <rtems_semaphore_release>
return RC_OK;
193a0: e1a00007 mov r0, r7
}
193a4: e8bd83f0 pop {r4, r5, r6, r7, r8, r9, pc}
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
193a8: eb000141 bl 198b4 <__errno> <== NOT EXECUTED
193ac: e3a03005 mov r3, #5 <== NOT EXECUTED
193b0: e5803000 str r3, [r0] <== NOT EXECUTED
193b4: e3e00000 mvn r0, #0 <== NOT EXECUTED
193b8: e8bd83f0 pop {r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
000163e8 <msdos_eval_token>:
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
163e8: e3530001 cmp r3, #1
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
163ec: e92d4010 push {r4, lr}
163f0: e1a04000 mov r4, r0
163f4: 0a00000a beq 16424 <msdos_eval_token+0x3c>
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);
163f8: e1a01002 mov r1, r2 163fc: e2840018 add r0, r4, #24 16400: e1a02003 mov r2, r3 16404: eb000576 bl 179e4 <msdos_find_name>
if (rc == RC_OK) {
16408: e3500000 cmp r0, #0
1640c: 0a00000f beq 16450 <msdos_eval_token+0x68>
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) {
16410: e59f3080 ldr r3, [pc, #128] ; 16498 <msdos_eval_token+0xb0> 16414: e1500003 cmp r0, r3
16418: 1a000019 bne 16484 <msdos_eval_token+0x9c>
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
1641c: e3a00002 mov r0, #2
rtems_filesystem_eval_path_error(ctx, 0);
}
}
return status;
}
16420: e8bd8010 pop {r4, pc}
16424: e5d21000 ldrb r1, [r2]
16428: e351002e cmp r1, #46 ; 0x2e
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
1642c: 03a00000 moveq r0, #0 16430: 0584000c streq r0, [r4, #12]
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
16434: 08bd8010 popeq {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);
16438: e1a01002 mov r1, r2 1643c: e2840018 add r0, r4, #24 16440: e1a02003 mov r2, r3 16444: eb000566 bl 179e4 <msdos_find_name>
if (rc == RC_OK) {
16448: e3500000 cmp r0, #0
1644c: 1affffef bne 16410 <msdos_eval_token+0x28>
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)
16450: e5943020 ldr r3, [r4, #32] 16454: e5932010 ldr r2, [r3, #16]
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
16458: e594302c ldr r3, [r4, #44] ; 0x2c 1645c: e5933008 ldr r3, [r3, #8]
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
16460: e3520000 cmp r2, #0
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
16464: e584000c str r0, [r4, #12]
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
16468: 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;
1646c: 05933094 ldreq r3, [r3, #148] ; 0x94
else
loc->handlers = fs_info->file_handlers;
16470: 15933098 ldrne r3, [r3, #152] ; 0x98
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
16474: 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;
16478: e5843028 str r3, [r4, #40] ; 0x28
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
1647c: 33a00000 movcc r0, #0
16480: e8bd8010 pop {r4, pc}
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else if (rc == MSDOS_NAME_NOT_FOUND_ERR) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
} else {
rtems_filesystem_eval_path_error(ctx, 0);
16484: e1a00004 mov r0, r4 <== NOT EXECUTED 16488: e3a01000 mov r1, #0 <== NOT EXECUTED 1648c: ebffbc3d bl 5588 <rtems_filesystem_eval_path_error> <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
16490: e3a00001 mov r0, #1 <== NOT EXECUTED
16494: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00019418 <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;
19418: 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)
{
1941c: 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;
19420: e5934008 ldr r4, [r3, #8]
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
19424: 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)
{
19428: 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,
1942c: e1a02001 mov r2, r1 19430: e594009c ldr r0, [r4, #156] ; 0x9c 19434: ebffbcff bl 8838 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
19438: e3500000 cmp r0, #0
1943c: 1a000006 bne 1945c <msdos_file_close+0x44>
rtems_set_errno_and_return_minus_one(EIO);
rc = msdos_file_update(iop);
19440: e1a00005 mov r0, r5 19444: ebffffdd bl 193c0 <msdos_file_update> 19448: e1a05000 mov r5, r0
rtems_semaphore_release(fs_info->vol_sema);
1944c: e594009c ldr r0, [r4, #156] ; 0x9c 19450: ebffbd41 bl 895c <rtems_semaphore_release>
return rc;
}
19454: e1a00005 mov r0, r5
19458: e8bd8030 pop {r4, r5, pc}
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
1945c: eb000114 bl 198b4 <__errno> <== NOT EXECUTED 19460: e3a03005 mov r3, #5 <== NOT EXECUTED 19464: e5803000 str r3, [r0] <== NOT EXECUTED 19468: e3e05000 mvn r5, #0 <== NOT EXECUTED 1946c: eafffff8 b 19454 <msdos_file_close+0x3c> <== NOT EXECUTED
00019684 <msdos_file_ftruncate>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately).
*/
int
msdos_file_ftruncate(rtems_libio_t *iop, off_t length)
{
19684: e92d43f0 push {r4, r5, r6, r7, r8, r9, lr}
19688: e1a03000 mov r3, r0
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
1968c: e5900024 ldr r0, [r0, #36] ; 0x24 19690: e5904008 ldr r4, [r0, #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)
{
19694: 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,
19698: e3a01000 mov r1, #0
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately).
*/
int
msdos_file_ftruncate(rtems_libio_t *iop, off_t length)
{
1969c: e24dd008 sub sp, sp, #8 196a0: 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,
196a4: e594009c ldr r0, [r4, #156] ; 0x9c 196a8: e1a02001 mov r2, r1
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;
196ac: e5935018 ldr r5, [r3, #24]
uint32_t old_length;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
196b0: ebffbc60 bl 8838 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
196b4: e3500000 cmp r0, #0
196b8: 1a000029 bne 19764 <msdos_file_ftruncate+0xe0>
rtems_set_errno_and_return_minus_one(EIO);
old_length = fat_fd->fat_file_size;
196bc: e5956018 ldr r6, [r5, #24]
if (length < old_length) {
196c0: e3a03000 mov r3, #0 196c4: e1a02006 mov r2, r6 196c8: e1580002 cmp r8, r2 196cc: e0d91003 sbcs r1, r9, r3
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
196d0: e1a00004 mov r0, r4 196d4: e1a01005 mov r1, r5
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
old_length = fat_fd->fat_file_size;
if (length < old_length) {
196d8: aa00000b bge 1970c <msdos_file_ftruncate+0x88>
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
196dc: e1a02008 mov r2, r8 196e0: ebffdfd0 bl 11628 <fat_file_truncate>
errno = ENOSPC;
rc = -1;
}
}
if (rc == RC_OK) {
196e4: e2507000 subs r7, r0, #0
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
old_length = fat_fd->fat_file_size;
if (length < old_length) {
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
196e8: e1a01008 mov r1, r8
errno = ENOSPC;
rc = -1;
}
}
if (rc == RC_OK) {
196ec: 1a000001 bne 196f8 <msdos_file_ftruncate+0x74>
fat_fd->fat_file_size = length;
196f0: e5851018 str r1, [r5, #24] 196f4: e3a07000 mov r7, #0
}
rtems_semaphore_release(fs_info->vol_sema);
196f8: e594009c ldr r0, [r4, #156] ; 0x9c 196fc: ebffbc96 bl 895c <rtems_semaphore_release>
return rc;
}
19700: e1a00007 mov r0, r7
19704: e28dd008 add sp, sp, #8
19708: e8bd83f0 pop {r4, r5, r6, r7, r8, r9, pc}
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,
1970c: e28dc004 add ip, sp, #4 19710: e3a02001 mov r2, #1 19714: e1a03008 mov r3, r8 19718: e58dc000 str ip, [sp] 1971c: ebffe05c bl 11894 <fat_file_extend>
fat_fd,
true,
length,
&new_length);
if (rc == RC_OK && length != new_length) {
19720: e2507000 subs r7, r0, #0
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,
19724: e1a01008 mov r1, r8
fat_fd,
true,
length,
&new_length);
if (rc == RC_OK && length != new_length) {
19728: 1afffff2 bne 196f8 <msdos_file_ftruncate+0x74>
1972c: e59d2004 ldr r2, [sp, #4] 19730: e3a03000 mov r3, #0 19734: e1530009 cmp r3, r9 19738: 01520008 cmpeq r2, r8
1973c: 0affffeb beq 196f0 <msdos_file_ftruncate+0x6c>
fat_file_truncate(&fs_info->fat, fat_fd, old_length);
19740: e1a01005 mov r1, r5 <== NOT EXECUTED 19744: e1a02006 mov r2, r6 <== NOT EXECUTED 19748: e1a00004 mov r0, r4 <== NOT EXECUTED 1974c: ebffdfb5 bl 11628 <fat_file_truncate> <== NOT EXECUTED
errno = ENOSPC;
19750: eb000057 bl 198b4 <__errno> <== NOT EXECUTED 19754: e3a0301c mov r3, #28 <== NOT EXECUTED 19758: e5803000 str r3, [r0] <== NOT EXECUTED
rc = -1;
1975c: e3e07000 mvn r7, #0 <== NOT EXECUTED 19760: eaffffe4 b 196f8 <msdos_file_ftruncate+0x74> <== NOT EXECUTED
uint32_t old_length;
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);
19764: eb000052 bl 198b4 <__errno> <== NOT EXECUTED 19768: e3a03005 mov r3, #5 <== NOT EXECUTED 1976c: e5803000 str r3, [r0] <== NOT EXECUTED 19770: e3e07000 mvn r7, #0 <== NOT EXECUTED 19774: eaffffe1 b 19700 <msdos_file_ftruncate+0x7c> <== NOT EXECUTED
00019470 <msdos_file_read>:
* the number of bytes read on success, or -1 if error occured (errno set
* appropriately)
*/
ssize_t
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
19470: e92d41f0 push {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;
19474: e5903024 ldr r3, [r0, #36] ; 0x24 19478: 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)
{
1947c: e1a06001 mov r6, 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,
19480: e3a01000 mov r1, #0
* 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)
{
19484: e1a04000 mov r4, r0 19488: e24dd004 sub sp, sp, #4 1948c: 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,
19490: e595009c ldr r0, [r5, #156] ; 0x9c 19494: e1a02001 mov r2, r1
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;
19498: e5948018 ldr r8, [r4, #24]
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
1949c: ebffbce5 bl 8838 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
194a0: e3500000 cmp r0, #0
194a4: 1a000010 bne 194ec <msdos_file_read+0x7c>
rtems_set_errno_and_return_minus_one(EIO);
ret = fat_file_read(&fs_info->fat, fat_fd, iop->offset, count,
194a8: e5942004 ldr r2, [r4, #4] 194ac: e1a00005 mov r0, r5 194b0: e1a01008 mov r1, r8 194b4: e1a03007 mov r3, r7 194b8: e58d6000 str r6, [sp] 194bc: ebffdfde bl 1143c <fat_file_read>
buffer);
if (ret > 0)
194c0: e2506000 subs r6, r0, #0
194c4: da000003 ble 194d8 <msdos_file_read+0x68>
iop->offset += ret;
194c8: e994000c ldmib r4, {r2, r3}
194cc: e0922006 adds r2, r2, r6
194d0: e0a33fc6 adc r3, r3, r6, asr #31
194d4: e984000c stmib r4, {r2, r3}
rtems_semaphore_release(fs_info->vol_sema);
194d8: e595009c ldr r0, [r5, #156] ; 0x9c 194dc: ebffbd1e bl 895c <rtems_semaphore_release>
return ret;
}
194e0: e1a00006 mov r0, r6
194e4: e28dd004 add sp, sp, #4
194e8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
194ec: eb0000f0 bl 198b4 <__errno> <== NOT EXECUTED 194f0: e3a03005 mov r3, #5 <== NOT EXECUTED 194f4: e5803000 str r3, [r0] <== NOT EXECUTED 194f8: e3e06000 mvn r6, #0 <== NOT EXECUTED 194fc: eafffff7 b 194e0 <msdos_file_read+0x70> <== NOT EXECUTED
000195cc <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;
195cc: e5902014 ldr r2, [r0, #20]
int
msdos_file_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
195d0: e92d43f0 push {r4, r5, r6, r7, r8, r9, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
195d4: e5925008 ldr r5, [r2, #8]
int
msdos_file_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
195d8: 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,
195dc: e3a01000 mov r1, #0
int
msdos_file_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
195e0: e1a03000 mov r3, r0
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,
195e4: e1a02001 mov r2, r1 195e8: e595009c ldr r0, [r5, #156] ; 0x9c
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;
195ec: e5936008 ldr r6, [r3, #8]
uint32_t cl_mask = fs_info->fat.vol.bpc - 1;
195f0: e1d580b6 ldrh r8, [r5, #6]
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
195f4: ebffbc8f bl 8838 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
195f8: e2507000 subs r7, r0, #0
195fc: 1a00001a bne 1966c <msdos_file_stat+0xa0>
19600: e5951064 ldr r1, [r5, #100] ; 0x64
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;
19604: e5963018 ldr r3, [r6, #24]
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
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;
19608: e596c00c ldr ip, [r6, #12]
)
{
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;
1960c: e2480001 sub r0, r8, #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;
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
19610: e0802003 add r2, r0, r3
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
19614: e8910300 ldm r1, {r8, r9}
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)
19618: e1c20000 bic r0, r2, r0
>> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bpc;
1961c: e1d510b6 ldrh r1, [r5, #6]
buf->st_mtime = fat_fd->mtime;
19620: e5962040 ldr r2, [r6, #64] ; 0x40
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
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;
19624: e584c008 str ip, [r4, #8]
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
19628: e59fc050 ldr ip, [pc, #80] ; 19680 <msdos_file_stat+0xb4>
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
1962c: e8840300 stm r4, {r8, r9}
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;
19630: e1a004a0 lsr r0, r0, #9
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;
buf->st_rdev = 0ll;
19634: e3a08000 mov r8, #0 19638: e3a09000 mov r9, #0
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
1963c: e5840044 str r0, [r4, #68] ; 0x44
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;
19640: e584c00c str ip, [r4, #12]
buf->st_rdev = 0ll;
19644: e5848018 str r8, [r4, #24] 19648: e584901c str r9, [r4, #28]
buf->st_size = fat_fd->fat_file_size;
1964c: e5843020 str r3, [r4, #32] 19650: e5847024 str r7, [r4, #36] ; 0x24
buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)
>> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bpc;
19654: e5841040 str r1, [r4, #64] ; 0x40
buf->st_mtime = fat_fd->mtime;
19658: e5842030 str r2, [r4, #48] ; 0x30
rtems_semaphore_release(fs_info->vol_sema);
1965c: e595009c ldr r0, [r5, #156] ; 0x9c 19660: ebffbcbd bl 895c <rtems_semaphore_release>
return RC_OK;
19664: e1a00007 mov r0, r7
}
19668: e8bd83f0 pop {r4, r5, r6, r7, r8, r9, pc}
uint32_t cl_mask = fs_info->fat.vol.bpc - 1;
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);
1966c: eb000090 bl 198b4 <__errno> <== NOT EXECUTED
19670: e3a03005 mov r3, #5 <== NOT EXECUTED
19674: e5803000 str r3, [r0] <== NOT EXECUTED
19678: e3e00000 mvn r0, #0 <== NOT EXECUTED
1967c: e8bd83f0 pop {r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
00019778 <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;
19778: 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)
{
1977c: 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;
19780: e5934008 ldr r4, [r3, #8]
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
19784: 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)
{
19788: 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,
1978c: e1a02001 mov r2, r1 19790: e594009c ldr r0, [r4, #156] ; 0x9c 19794: ebffbc27 bl 8838 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
19798: e3500000 cmp r0, #0
1979c: 1a000008 bne 197c4 <msdos_file_sync+0x4c>
rtems_set_errno_and_return_minus_one(EIO);
rc = msdos_file_update(iop);
197a0: e1a00005 mov r0, r5 197a4: ebffff05 bl 193c0 <msdos_file_update>
if (rc != RC_OK)
197a8: e2505000 subs r5, r0, #0
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = fat_sync(&fs_info->fat);
197ac: 01a00004 moveq r0, r4 197b0: 0bffe50d bleq 12bec <fat_sync>
rtems_semaphore_release(fs_info->vol_sema);
197b4: e594009c ldr r0, [r4, #156] ; 0x9c 197b8: ebffbc67 bl 895c <rtems_semaphore_release>
return RC_OK;
}
197bc: e1a00005 mov r0, r5
197c0: e8bd8030 pop {r4, r5, pc}
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
197c4: eb00003a bl 198b4 <__errno> <== NOT EXECUTED 197c8: e3a03005 mov r3, #5 <== NOT EXECUTED 197cc: e5803000 str r3, [r0] <== NOT EXECUTED 197d0: e3e05000 mvn r5, #0 <== NOT EXECUTED 197d4: eafffff8 b 197bc <msdos_file_sync+0x44> <== NOT EXECUTED
000193c0 <msdos_file_update>:
#include "msdos.h"
static int
msdos_file_update(rtems_libio_t *iop)
{
193c0: e92d4030 push {r4, r5, lr}
int rc = RC_OK;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
193c4: 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))
193c8: e5d43030 ldrb r3, [r4, #48] ; 0x30 193cc: e3130001 tst r3, #1
#include "msdos.h"
static int
msdos_file_update(rtems_libio_t *iop)
{
193d0: 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))
193d4: 0a000001 beq 193e0 <msdos_file_update+0x20>
#include "msdos.h"
static int
msdos_file_update(rtems_libio_t *iop)
{
int rc = RC_OK;
193d8: e3a00000 mov r0, #0 <== NOT EXECUTED
return rc;
}
}
return rc;
}
193dc: 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);
193e0: e5900024 ldr r0, [r0, #36] ; 0x24 193e4: e1a01004 mov r1, r4 193e8: ebfff502 bl 167f8 <msdos_set_first_cluster_num>
if (rc != RC_OK)
193ec: e3500000 cmp r0, #0
193f0: 18bd8030 popne {r4, r5, pc}
{
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
193f4: e5950024 ldr r0, [r5, #36] ; 0x24 193f8: e1a01004 mov r1, r4 193fc: ebfff52b bl 168b0 <msdos_set_file_size>
if (rc != RC_OK)
19400: e3500000 cmp r0, #0
19404: 18bd8030 popne {r4, r5, pc}
{
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
19408: e5950024 ldr r0, [r5, #36] ; 0x24 1940c: e1a01004 mov r1, r4
return rc;
}
}
return rc;
}
19410: 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);
19414: eafff4bf b 16718 <msdos_set_dir_wrt_time_and_date>
00019500 <msdos_file_write>:
* the number of bytes written on success, or -1 if error occured
* and errno set appropriately
*/
ssize_t
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
19500: e92d41f0 push {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;
19504: e5903024 ldr r3, [r0, #36] ; 0x24 19508: 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)
{
1950c: e1a07001 mov r7, 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,
19510: e3a01000 mov r1, #0
* 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)
{
19514: e1a04000 mov r4, r0 19518: e24dd004 sub sp, sp, #4 1951c: e1a08002 mov r8, 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,
19520: e596009c ldr r0, [r6, #156] ; 0x9c 19524: e1a02001 mov r2, r1
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;
19528: e5945018 ldr r5, [r4, #24]
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
1952c: ebffbcc1 bl 8838 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
19530: e3500000 cmp r0, #0
19534: 1a00001b bne 195a8 <msdos_file_write+0xa8>
rtems_set_errno_and_return_minus_one(EIO);
if ((iop->flags & LIBIO_FLAGS_APPEND) != 0)
19538: e594300c ldr r3, [r4, #12] 1953c: e3130c02 tst r3, #512 ; 0x200
iop->offset = fat_fd->fat_file_size;
19540: 15952018 ldrne r2, [r5, #24]
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);
if ((iop->flags & LIBIO_FLAGS_APPEND) != 0)
19544: 05942004 ldreq r2, [r4, #4]
iop->offset = fat_fd->fat_file_size;
19548: 15840008 strne r0, [r4, #8] 1954c: 15842004 strne r2, [r4, #4]
ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
19550: e1a00006 mov r0, r6 19554: e1a01005 mov r1, r5 19558: e1a03008 mov r3, r8 1955c: e58d7000 str r7, [sp] 19560: ebffe15b bl 11ad4 <fat_file_write>
buffer);
if (ret < 0)
19564: e2507000 subs r7, r0, #0
19568: ba000013 blt 195bc <msdos_file_write+0xbc>
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
1956c: e994000c ldmib r4, {r2, r3}
if (iop->offset > fat_fd->fat_file_size)
19570: e595c018 ldr ip, [r5, #24]
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
19574: e0922007 adds r2, r2, r7
if (iop->offset > fat_fd->fat_file_size)
19578: e1a0000c mov r0, ip
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
1957c: e0a33fc7 adc r3, r3, r7, asr #31
if (iop->offset > fat_fd->fat_file_size)
19580: e3a01000 mov r1, #0 19584: e1500002 cmp r0, r2 19588: e0d1c003 sbcs ip, r1, r3
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
1958c: 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);
19590: 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;
19594: b5852018 strlt r2, [r5, #24]
rtems_semaphore_release(fs_info->vol_sema);
19598: ebffbcef bl 895c <rtems_semaphore_release>
return ret;
}
1959c: e1a00007 mov r0, r7
195a0: e28dd004 add sp, sp, #4
195a4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
195a8: eb0000c1 bl 198b4 <__errno> <== NOT EXECUTED 195ac: e3a03005 mov r3, #5 <== NOT EXECUTED 195b0: e5803000 str r3, [r0] <== NOT EXECUTED 195b4: e3e07000 mvn r7, #0 <== NOT EXECUTED 195b8: eafffff7 b 1959c <msdos_file_write+0x9c> <== NOT EXECUTED
ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
buffer);
if (ret < 0)
{
rtems_semaphore_release(fs_info->vol_sema);
195bc: e596009c ldr r0, [r6, #156] ; 0x9c <== NOT EXECUTED 195c0: ebffbce5 bl 895c <rtems_semaphore_release> <== NOT EXECUTED
return -1;
195c4: e3e07000 mvn r7, #0 <== NOT EXECUTED 195c8: eafffff3 b 1959c <msdos_file_write+0x9c> <== NOT EXECUTED
00018bc4 <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)
{
18bc4: e92d0030 push {r4, r5}
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
18bc8: e3a03000 mov r3, #0
dn[i] = ' ';
18bcc: e3a0c020 mov ip, #32 18bd0: e7c2c003 strb ip, [r2, r3]
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
18bd4: e2833001 add r3, r3, #1 18bd8: e353000b cmp r3, #11
18bdc: 1afffffb bne 18bd0 <msdos_filename_unix2dos+0xc>
/*
* The filenames "." and ".." are handled specially, since they
* don't follow dos filename rules.
*/
if (un[0] == '.' && unlen == 1) {
18be0: e5d03000 ldrb r3, [r0] 18be4: e353002e cmp r3, #46 ; 0x2e 18be8: 13a0c000 movne ip, #0 18bec: 03a0c001 moveq ip, #1 18bf0: e3510001 cmp r1, #1 18bf4: 0353002e cmpeq r3, #46 ; 0x2e
dn[0] = '.';
18bf8: 03a0302e moveq r3, #46 ; 0x2e 18bfc: 05c23000 strbeq r3, [r2]
/*
* The filenames "." and ".." are handled specially, since they
* don't follow dos filename rules.
*/
if (un[0] == '.' && unlen == 1) {
18c00: 0a000052 beq 18d50 <msdos_filename_unix2dos+0x18c>
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
18c04: e35c0000 cmp ip, #0
18c08: 1a00005a bne 18d78 <msdos_filename_unix2dos+0x1b4>
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
18c0c: e3510000 cmp r1, #0
18c10: 0a00004e beq 18d50 <msdos_filename_unix2dos+0x18c>
18c14: e35c0000 cmp ip, #0
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
dn[0] = '.';
dn[1] = '.';
return 0;
18c18: 11a0c000 movne ip, r0
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
18c1c: 1a000051 bne 18d68 <msdos_filename_unix2dos+0x1a4>
* 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++) {
18c20: e3530000 cmp r3, #0
18c24: 0a00001d beq 18ca0 <msdos_filename_unix2dos+0xdc>
18c28: e353002e cmp r3, #46 ; 0x2e
18c2c: 0a00001b beq 18ca0 <msdos_filename_unix2dos+0xdc>
if (msdos_map[c] == 0)
18c30: e59f4160 ldr r4, [pc, #352] ; 18d98 <msdos_filename_unix2dos+0x1d4> 18c34: e7d4c003 ldrb ip, [r4, r3] 18c38: e35c0000 cmp ip, #0 18c3c: 11a05000 movne r5, r0
/* * 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)
18c40: 13a03000 movne r3, #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)
18c44: 1a000008 bne 18c6c <msdos_filename_unix2dos+0xa8>
18c48: ea000014 b 18ca0 <msdos_filename_unix2dos+0xdc>
* 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++) {
18c4c: e5f5c001 ldrb ip, [r5, #1]! 18c50: e35c0000 cmp ip, #0
18c54: 0a000011 beq 18ca0 <msdos_filename_unix2dos+0xdc>
18c58: e35c002e cmp ip, #46 ; 0x2e
18c5c: 0a00000f beq 18ca0 <msdos_filename_unix2dos+0xdc>
if (msdos_map[c] == 0)
18c60: e7d4c00c ldrb ip, [r4, ip] 18c64: e35c0000 cmp ip, #0
18c68: 0a00000c beq 18ca0 <msdos_filename_unix2dos+0xdc>
* 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++) {
18c6c: e2511001 subs r1, r1, #1
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
18c70: e7c2c003 strb ip, [r2, r3]
* 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++) {
18c74: 03a0c000 moveq ip, #0 18c78: 13a0c001 movne ip, #1 18c7c: e2833001 add r3, r3, #1 18c80: e3530007 cmp r3, #7 18c84: c3a0c000 movgt ip, #0 18c88: d20cc001 andle ip, ip, #1 18c8c: e35c0000 cmp ip, #0
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
un++;
18c90: e2800001 add r0, r0, #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++) {
18c94: 1affffec bne 18c4c <msdos_filename_unix2dos+0x88>
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
18c98: e3510000 cmp r1, #0
18c9c: 0a00002b beq 18d50 <msdos_filename_unix2dos+0x18c>
18ca0: e5d03000 ldrb r3, [r0] 18ca4: e3530000 cmp r3, #0
18ca8: 0a000028 beq 18d50 <msdos_filename_unix2dos+0x18c> un++; unlen--; /* Make sure we've skipped over the dot before stopping. */ if (c == '.')
18cac: e353002e cmp r3, #46 ; 0x2e
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
un++;
18cb0: e2800001 add r0, r0, #1
unlen--;
18cb4: e2411001 sub r1, r1, #1
/* Make sure we've skipped over the dot before stopping. */ if (c == '.')
18cb8: 11a03000 movne r3, r0
18cbc: 0a000008 beq 18ce4 <msdos_filename_unix2dos+0x120>
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
18cc0: e3510000 cmp r1, #0
18cc4: 0a000021 beq 18d50 <msdos_filename_unix2dos+0x18c>
18cc8: e4d30001 ldrb r0, [r3], #1 18ccc: e3500000 cmp r0, #0
18cd0: 0a00001e beq 18d50 <msdos_filename_unix2dos+0x18c> un++; unlen--; /* Make sure we've skipped over the dot before stopping. */ if (c == '.')
18cd4: e350002e cmp r0, #46 ; 0x2e
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
un++;
unlen--;
18cd8: e2411001 sub r1, r1, #1
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
un++;
18cdc: e1a00003 mov r0, r3
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
18ce0: 1afffff6 bne 18cc0 <msdos_filename_unix2dos+0xfc>
/*
* 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++) {
18ce4: e3510000 cmp r1, #0
18ce8: 0a000018 beq 18d50 <msdos_filename_unix2dos+0x18c>
18cec: e5d03000 ldrb r3, [r0] 18cf0: e3530000 cmp r3, #0
18cf4: 0a000015 beq 18d50 <msdos_filename_unix2dos+0x18c>
if (msdos_map[c] == 0)
18cf8: e59f4098 ldr r4, [pc, #152] ; 18d98 <msdos_filename_unix2dos+0x1d4> 18cfc: e7d4c003 ldrb ip, [r4, r3] 18d00: e35c0000 cmp ip, #0
/* * 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)
18d04: 13a03008 movne 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)
18d08: 1a000006 bne 18d28 <msdos_filename_unix2dos+0x164>
18d0c: ea00000f b 18d50 <msdos_filename_unix2dos+0x18c>
/*
* 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++) {
18d10: e5f0c001 ldrb ip, [r0, #1]! 18d14: e35c0000 cmp ip, #0
18d18: 0a00000c beq 18d50 <msdos_filename_unix2dos+0x18c>
if (msdos_map[c] == 0)
18d1c: e7d4c00c ldrb ip, [r4, ip] 18d20: e35c0000 cmp ip, #0
18d24: 0a000009 beq 18d50 <msdos_filename_unix2dos+0x18c>
/*
* 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++) {
18d28: e2511001 subs r1, r1, #1
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
18d2c: e7c2c003 strb ip, [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++) {
18d30: 03a0c000 moveq ip, #0 18d34: 13a0c001 movne ip, #1 18d38: e2833001 add r3, r3, #1 18d3c: e353000a cmp r3, #10 18d40: c3a0c000 movgt ip, #0 18d44: d20cc001 andle ip, ip, #1 18d48: e35c0000 cmp ip, #0
18d4c: 1affffef bne 18d10 <msdos_filename_unix2dos+0x14c>
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
18d50: e3a00000 mov r0, #0
18d54: e8bd0030 pop {r4, r5}
18d58: e12fff1e bx lr
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
18d5c: e5fc3001 ldrb r3, [ip, #1]! <== NOT EXECUTED 18d60: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED 18d64: 1affffad bne 18c20 <msdos_filename_unix2dos+0x5c> <== NOT EXECUTED 18d68: e2511001 subs r1, r1, #1 <== NOT EXECUTED
un++;
18d6c: e2800001 add r0, r0, #1 <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
18d70: 1afffff9 bne 18d5c <msdos_filename_unix2dos+0x198> <== NOT EXECUTED 18d74: eafffff5 b 18d50 <msdos_filename_unix2dos+0x18c> <== NOT EXECUTED
*/
if (un[0] == '.' && unlen == 1) {
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
18d78: e5d04001 ldrb r4, [r0, #1] <== NOT EXECUTED 18d7c: e3510002 cmp r1, #2 <== NOT EXECUTED 18d80: 0354002e cmpeq r4, #46 ; 0x2e <== NOT EXECUTED
dn[0] = '.';
18d84: 03a0302e moveq r3, #46 ; 0x2e <== NOT EXECUTED 18d88: 05c23000 strbeq r3, [r2] <== NOT EXECUTED
dn[1] = '.';
18d8c: 05c23001 strbeq r3, [r2, #1] <== NOT EXECUTED
*/
if (un[0] == '.' && unlen == 1) {
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
18d90: 1affff9d bne 18c0c <msdos_filename_unix2dos+0x48> <== NOT EXECUTED 18d94: eaffffed b 18d50 <msdos_filename_unix2dos+0x18c> <== NOT EXECUTED
000179e4 <msdos_find_name>:
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
179e4: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
179e8: e24dd040 sub sp, sp, #64 ; 0x40
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
179ec: e590c014 ldr ip, [r0, #20]
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
179f0: e1a07001 mov r7, r1
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);
179f4: e28d600c add r6, sp, #12
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
179f8: e3a04000 mov r4, #0
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
name_type = msdos_long_to_short (name,
179fc: e1a01002 mov r1, r2
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
17a00: e1a05000 mov r5, r0 17a04: e1a08002 mov r8, r2
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
name_type = msdos_long_to_short (name,
17a08: e3a0300b mov r3, #11 17a0c: e1a02006 mov r2, r6 17a10: e1a00007 mov r0, r7
const char *name,
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
17a14: e59c9008 ldr r9, [ip, #8]
fat_file_fd_t *fat_fd = NULL;
17a18: e58d403c str r4, [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);
17a1c: e58d400c str r4, [sp, #12] 17a20: e58d4010 str r4, [sp, #16] 17a24: e58d4014 str r4, [sp, #20] 17a28: e58d4018 str r4, [sp, #24] 17a2c: e58d401c str r4, [sp, #28] 17a30: e58d4020 str r4, [sp, #32] 17a34: e58d4024 str r4, [sp, #36] ; 0x24 17a38: e58d4028 str r4, [sp, #40] ; 0x28
name_type = msdos_long_to_short (name,
17a3c: ebfffaae bl 164fc <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,
17a40: e28da02c add sl, sp, #44 ; 0x2c 17a44: e58d0000 str r0, [sp] 17a48: e1a01004 mov r1, r4 17a4c: e1a00005 mov r0, r5 17a50: e1a02007 mov r2, r7 17a54: e1a03008 mov r3, r8 17a58: e58da004 str sl, [sp, #4] 17a5c: e58d6008 str r6, [sp, #8] 17a60: ebffffa7 bl 17904 <msdos_get_name_node>
&dir_pos, node_entry);
if (rc != RC_OK)
17a64: e2504000 subs r4, r0, #0
17a68: 1a000003 bne 17a7c <msdos_find_name+0x98>
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
17a6c: e5dd3017 ldrb r3, [sp, #23] 17a70: e3130008 tst r3, #8
17a74: 0a000003 beq 17a88 <msdos_find_name+0xa4>
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
17a78: e59f4120 ldr r4, [pc, #288] ; 17ba0 <msdos_find_name+0x1bc><== NOT EXECUTED
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
return rc;
}
17a7c: e1a00004 mov r0, r4
17a80: e28dd040 add sp, sp, #64 ; 0x40
17a84: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
&dir_pos, node_entry);
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))
17a88: 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) ||
17a8c: e353000f cmp r3, #15
17a90: 0afffff8 beq 17a78 <msdos_find_name+0x94>
((*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);
17a94: e1a00009 mov r0, r9 17a98: e1a0100a mov r1, sl 17a9c: e28d203c add r2, sp, #60 ; 0x3c 17aa0: ebffe5c7 bl 111c4 <fat_file_open>
if (rc != RC_OK)
17aa4: e2504000 subs r4, r0, #0
17aa8: 1afffff3 bne 17a7c <msdos_find_name+0x98>
return rc;
fat_fd->dir_pos = dir_pos;
17aac: e59d703c ldr r7, [sp, #60] ; 0x3c
* 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)
17ab0: e597e008 ldr lr, [r7, #8]
/* open fat-file corresponded to the found node */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->dir_pos = dir_pos;
17ab4: e89a000f ldm sl, {r0, r1, r2, r3}
17ab8: e287c020 add ip, r7, #32
* 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)
17abc: e35e0001 cmp lr, #1
/* open fat-file corresponded to the found node */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->dir_pos = dir_pos;
17ac0: 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)
17ac4: 0a000007 beq 17ae8 <msdos_find_name+0x104>
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
}
}
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(&fs_info->fat, parent_loc->node_access);
17ac8: e1a00009 mov r0, r9 17acc: e5951008 ldr r1, [r5, #8] 17ad0: ebffe715 bl 1172c <fat_file_close>
if (rc != RC_OK)
17ad4: e2504000 subs r4, r0, #0
17ad8: 1a000021 bne 17b64 <msdos_find_name+0x180>
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
17adc: e59d303c ldr r3, [sp, #60] ; 0x3c 17ae0: e5853008 str r3, [r5, #8]
return rc;
17ae4: eaffffe4 b 17a7c <msdos_find_name+0x98>
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
17ae8: e1d621b4 ldrh r2, [r6, #20] 17aec: e1d631ba ldrh r3, [r6, #26] 17af0: e1833802 orr r3, r3, r2, lsl #16 17af4: 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));
17af8: e1d601b8 ldrh r0, [r6, #24] 17afc: e1d611b6 ldrh r1, [r6, #22] 17b00: eb0003e8 bl 18aa8 <msdos_date_dos2unix>
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
17b04: e5dd3017 ldrb r3, [sp, #23] 17b08: 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));
17b0c: e5870040 str r0, [r7, #64] ; 0x40
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
17b10: 1a000017 bne 17b74 <msdos_find_name+0x190>
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
17b14: e59d303c ldr r3, [sp, #60] ; 0x3c 17b18: e596201c ldr r2, [r6, #28]
fat_fd->fat_file_type = FAT_FILE;
17b1c: e3a01004 mov r1, #4 17b20: e5831010 str r1, [r3, #16]
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
17b24: e3e01000 mvn r1, #0
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
17b28: e5832018 str r2, [r3, #24]
fat_fd->fat_file_type = FAT_FILE;
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
17b2c: e5831014 str r1, [r3, #20]
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
17b30: e593101c ldr r1, [r3, #28]
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;
17b34: e3a00000 mov r0, #0
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
17b38: e3520000 cmp r2, #0
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;
17b3c: e5830034 str r0, [r3, #52] ; 0x34
fat_fd->map.disk_cln = fat_fd->cln;
17b40: e5831038 str r1, [r3, #56] ; 0x38
if ((fat_fd->fat_file_size != 0) &&
17b44: 0a000003 beq 17b58 <msdos_find_name+0x174>
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
17b48: e1d900b6 ldrh r0, [r9, #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) &&
17b4c: e1500002 cmp r0, r2
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
{
fat_fd->map.last_cln = fat_fd->cln;
17b50: 2583103c strcs r1, [r3, #60] ; 0x3c
/* 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) &&
17b54: 2affffdb bcs 17ac8 <msdos_find_name+0xe4>
{
fat_fd->map.last_cln = fat_fd->cln;
}
else
{
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
17b58: e3e02000 mvn r2, #0 17b5c: e583203c str r2, [r3, #60] ; 0x3c 17b60: eaffffd8 b 17ac8 <msdos_find_name+0xe4>
/* 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)
{
fat_file_close(&fs_info->fat, fat_fd);
17b64: e1a00009 mov r0, r9 <== NOT EXECUTED 17b68: e59d103c ldr r1, [sp, #60] ; 0x3c <== NOT EXECUTED 17b6c: ebffe6ee bl 1172c <fat_file_close> <== NOT EXECUTED
return rc;
17b70: eaffffc1 b 17a7c <msdos_find_name+0x98> <== NOT EXECUTED
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
{
fat_fd->fat_file_type = FAT_DIRECTORY;
17b74: e59d103c ldr r1, [sp, #60] ; 0x3c
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
17b78: 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;
17b7c: e5814010 str r4, [r1, #16]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
17b80: e5813014 str r3, [r1, #20]
rc = fat_file_size(&fs_info->fat, fat_fd);
17b84: e1a00009 mov r0, r9 17b88: ebffe87e bl 11d88 <fat_file_size>
if (rc != RC_OK)
17b8c: e2504000 subs r4, r0, #0
17b90: 1afffff3 bne 17b64 <msdos_find_name+0x180>
17b94: e59d303c ldr r3, [sp, #60] ; 0x3c 17b98: e5932018 ldr r2, [r3, #24] 17b9c: eaffffe3 b 17b30 <msdos_find_name+0x14c>
00016bc0 <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
)
{
16bc0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
16bc4: e24dd050 sub sp, sp, #80 ; 0x50
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
16bc8: e59dc074 ldr ip, [sp, #116] ; 0x74
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
16bcc: e5900008 ldr r0, [r0, #8]
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
16bd0: 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);
16bd4: e35c0000 cmp ip, #0
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
16bd8: e58d102c str r1, [sp, #44] ; 0x2c 16bdc: e58d3034 str r3, [sp, #52] ; 0x34 16be0: e58d2008 str r2, [sp, #8]
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
16be4: e58d0020 str r0, [sp, #32]
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
16be8: da000251 ble 17534 <msdos_find_name_in_fat_file+0x974>
* 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))
16bec: e59dc008 ldr ip, [sp, #8]
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
16bf0: e3a02000 mov r2, #0 16bf4: e15c0002 cmp ip, r2 16bf8: e59dc07c ldr ip, [sp, #124] ; 0x7c
dir_pos->sname.ofs = 0; dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
16bfc: e3e03000 mvn r3, #0
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
16c00: e58c2000 str r2, [ip]
dir_pos->sname.ofs = 0; dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
16c04: e98c000c stmib ip, {r2, r3}
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
16c08: e58c300c str r3, [ip, #12]
assert(name_len > 0);
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
16c0c: e58d3048 str r3, [sp, #72] ; 0x48 16c10: e58d3044 str r3, [sp, #68] ; 0x44
* 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))
16c14: 0a000003 beq 16c28 <msdos_find_name_in_fat_file+0x68>
16c18: e59dc078 ldr ip, [sp, #120] ; 0x78 16c1c: e35c0001 cmp ip, #1
lfn_entries = 0;
16c20: 058d2028 streq r2, [sp, #40] ; 0x28
* 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))
16c24: 0a000006 beq 16c44 <msdos_find_name_in_fat_file+0x84>
lfn_entries = 0;
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
16c28: e59dc074 ldr ip, [sp, #116] ; 0x74
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
lfn_entries = 0;
else
lfn_entries =
16c2c: e59f2914 ldr r2, [pc, #2324] ; 17548 <msdos_find_name_in_fat_file+0x988>
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
16c30: e28c300c add r3, ip, #12
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
lfn_entries = 0;
else
lfn_entries =
16c34: e0c2e293 smull lr, r2, r3, r2 16c38: e1a03fc3 asr r3, r3, #31 16c3c: e0633142 rsb r3, r3, r2, asr #2 16c40: e58d3028 str r3, [sp, #40] ; 0x28
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
16c44: e59dc02c ldr ip, [sp, #44] ; 0x2c 16c48: e59c3020 ldr r3, [ip, #32] 16c4c: e3530001 cmp r3, #1
16c50: 0a00014f beq 17194 <msdos_find_name_in_fat_file+0x5d4>
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
16c54: e59dc020 ldr ip, [sp, #32] 16c58: e1dcc0b6 ldrh ip, [ip, #6] 16c5c: e58dc004 str ip, [sp, #4]
/*
* 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),
16c60: e3a0c000 mov ip, #0 16c64: e58dc01c str ip, [sp, #28]
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;
16c68: e1a0900c mov r9, ip
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;
16c6c: e1a0700c mov r7, ip
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;
16c70: e1a0500c mov r5, ip
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;
16c74: e1a0a00c mov sl, ip
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;
16c78: e58dc00c str ip, [sp, #12]
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;
16c7c: e58dc010 str ip, [sp, #16]
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;
16c80: e1a0b00c mov fp, ip
char *name_dir_entry
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_offset = 0;
16c84: e58dc030 str ip, [sp, #48] ; 0x30 16c88: e59dc020 ldr ip, [sp, #32] 16c8c: e59c80a0 ldr r8, [ip, #160] ; 0xa0
/*
* 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),
16c90: e59d0020 ldr r0, [sp, #32] 16c94: e59d102c ldr r1, [sp, #44] ; 0x2c 16c98: e59d201c ldr r2, [sp, #28] 16c9c: e59d3004 ldr r3, [sp, #4] 16ca0: e58d8000 str r8, [sp] 16ca4: ebffe9e4 bl 1143c <fat_file_read> 16ca8: e3500000 cmp r0, #0
16cac: 0a00014b beq 171e0 <msdos_find_name_in_fat_file+0x620>
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)
16cb0: e350001f cmp r0, #31
16cb4: da0001c9 ble 173e0 <msdos_find_name_in_fat_file+0x820>
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
16cb8: e59dc004 ldr ip, [sp, #4] 16cbc: e150000c cmp r0, ip
16cc0: 1a000216 bne 17520 <msdos_find_name_in_fat_file+0x960>
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
16cc4: e59d3028 ldr r3, [sp, #40] ; 0x28 16cc8: e59dc020 ldr ip, [sp, #32] 16ccc: e2833001 add r3, r3, #1 16cd0: e1a0200b mov r2, fp 16cd4: e59c80a0 ldr r8, [ip, #160] ; 0xa0 16cd8: e58d3024 str r3, [sp, #36] ; 0x24 16cdc: e59db030 ldr fp, [sp, #48] ; 0x30
#endif
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
16ce0: e3a04000 mov r4, #0
/*
* 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) ==
16ce4: e7d83004 ldrb r3, [r8, r4]
* 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)
16ce8: e3570000 cmp r7, #0 16cec: 01a05004 moveq r5, r4 16cf0: 01a0a00b moveq sl, fp
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
16cf4: e3530000 cmp r3, #0
#endif
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
16cf8: e59dc008 ldr ip, [sp, #8]
/* 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;
16cfc: e0886004 add r6, r8, r4
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
16d00: 0a0000b4 beq 16fd8 <msdos_find_name_in_fat_file+0x418>
printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif
}
break;
}
else if (entry_empty)
16d04: e35300e5 cmp r3, #229 ; 0xe5
16d08: 0a000040 beq 16e10 <msdos_find_name_in_fat_file+0x250>
* 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)
16d0c: e35c0000 cmp ip, #0
16d10: 0a000002 beq 16d20 <msdos_find_name_in_fat_file+0x160>
{
empty_space_entry = 0;
empty_space_count = 0;
16d14: e3590000 cmp r9, #0 16d18: 01a07009 moveq r7, r9 16d1c: 01a05009 moveq r5, r9
/*
* Check the attribute to see if the entry is for a long
* file name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
16d20: e5d6100b ldrb r1, [r6, #11] 16d24: e201103f and r1, r1, #63 ; 0x3f 16d28: e351000f cmp r1, #15
16d2c: 0a000050 beq 16e74 <msdos_find_name_in_fat_file+0x2b4>
* 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)
16d30: e3520000 cmp r2, #0
16d34: 0a000047 beq 16e58 <msdos_find_name_in_fat_file+0x298> * 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(
16d38: e3a01000 mov r1, #0
* 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)
16d3c: e1a02006 mov r2, r6
* 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(
16d40: e286c00a add ip, r6, #10
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;
16d44: e1a00001 mov r0, r1 16d48: ea000002 b 16d58 <msdos_find_name_in_fat_file+0x198> 16d4c: e2100001 ands r0, r0, #1 16d50: e5f23001 ldrb r3, [r2, #1]! 16d54: 13a00080 movne r0, #128 ; 0x80 16d58: e0830000 add r0, r3, r0 16d5c: e08000a1 add r0, r0, r1, 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++)
16d60: e152000c cmp r2, ip
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
16d64: e20010ff and r1, r0, #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++)
16d68: 1afffff7 bne 16d4c <msdos_find_name_in_fat_file+0x18c>
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entry || (lfn_checksum != cs))
16d6c: e28d000c add r0, sp, #12
16d70: e8901001 ldm r0, {r0, ip}
16d74: e3500000 cmp r0, #0
16d78: 015c0001 cmpeq ip, r1
16d7c: 1a000035 bne 16e58 <msdos_find_name_in_fat_file+0x298>
#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,
16d80: e59dc07c ldr ip, [sp, #124] ; 0x7c 16d84: e59d0020 ldr r0, [sp, #32] 16d88: e59d102c ldr r1, [sp, #44] ; 0x2c 16d8c: e3a02001 mov r2, #1 16d90: e59d301c ldr r3, [sp, #28] 16d94: e58dc000 str ip, [sp] 16d98: ebffea8c bl 117d0 <fat_file_ioctl>
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
16d9c: e2505000 subs r5, r0, #0
16da0: 1a000017 bne 16e04 <msdos_find_name_in_fat_file+0x244>
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
16da4: e59d3044 ldr r3, [sp, #68] ; 0x44
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
16da8: e59dc07c ldr ip, [sp, #124] ; 0x7c
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
16dac: e3730001 cmn r3, #1
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
16db0: e58c4004 str r4, [ip, #4]
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
16db4: 0a00000a beq 16de4 <msdos_find_name_in_fat_file+0x224>
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
16db8: e59dc004 ldr ip, [sp, #4] 16dbc: e59d0020 ldr r0, [sp, #32] 16dc0: e003039c mul r3, ip, r3 16dc4: e59d102c ldr r1, [sp, #44] ; 0x2c 16dc8: e28dc044 add ip, sp, #68 ; 0x44 16dcc: e3a02001 mov r2, #1 16dd0: e58dc000 str ip, [sp] 16dd4: ebffea7d bl 117d0 <fat_file_ioctl>
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
16dd8: e3500000 cmp r0, #0
16ddc: 1a0000fd bne 171d8 <msdos_find_name_in_fat_file+0x618>
16de0: e59d3044 ldr r3, [sp, #68] ; 0x44
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
16de4: e59dc07c ldr ip, [sp, #124] ; 0x7c 16de8: e58c3008 str r3, [ip, #8]
dir_pos->lname.ofs = lfn_start.ofs;
16dec: e59d3048 ldr r3, [sp, #72] ; 0x48
memcpy(name_dir_entry, entry,
16df0: e59d0080 ldr r0, [sp, #128] ; 0x80
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
16df4: e58c300c str r3, [ip, #12]
memcpy(name_dir_entry, entry,
16df8: e1a01006 mov r1, r6 16dfc: e3a02020 mov r2, #32 16e00: eb000d52 bl 1a350 <memcpy>
empty_space_entry = 0;
read_cluster = true;
}
return 0;
}
16e04: e1a00005 mov r0, r5
16e08: e28dd050 add sp, sp, #80 ; 0x50
16e0c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
}
break;
}
else if (entry_empty)
{
if (create_node)
16e10: e35c0000 cmp ip, #0
16e14: 0a000003 beq 16e28 <msdos_find_name_in_fat_file+0x268>
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
empty_space_found = true;
16e18: e59d3024 ldr r3, [sp, #36] ; 0x24
if (create_node)
{
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
16e1c: e2877001 add r7, r7, #1
if (empty_space_count == (lfn_entries + 1))
empty_space_found = true;
16e20: e1530007 cmp r3, r7 16e24: 03a09001 moveq r9, #1
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;
16e28: e59dc004 ldr ip, [sp, #4]
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
16e2c: e2844020 add r4, r4, #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;
16e30: e15c0004 cmp ip, r4
16e34: 8affffaa bhi 16ce4 <msdos_find_name_in_fat_file+0x124>
16e38: e59de01c ldr lr, [sp, #28] 16e3c: e08ee00c add lr, lr, ip
}
if (remainder_empty)
break;
dir_offset++;
16e40: e59dc030 ldr ip, [sp, #48] ; 0x30 16e44: e28cc001 add ip, ip, #1 16e48: e1a0b002 mov fp, r2
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;
16e4c: e58de01c str lr, [sp, #28]
}
if (remainder_empty)
break;
dir_offset++;
16e50: e58dc030 str ip, [sp, #48] ; 0x30 16e54: eaffff8d b 16c90 <msdos_find_name_in_fat_file+0xd0>
* 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 ||
16e58: e59dc078 ldr ip, [sp, #120] ; 0x78 16e5c: e35c0001 cmp ip, #1
16e60: 0a00000e beq 16ea0 <msdos_find_name_in_fat_file+0x2e0>
memcpy(name_dir_entry, entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
16e64: e3e00000 mvn r0, #0 16e68: e58d0044 str r0, [sp, #68] ; 0x44
lfn_matched = false;
16e6c: e3a02000 mov r2, #0 16e70: eaffffec b 16e28 <msdos_find_name_in_fat_file+0x268>
#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)
16e74: e59d1044 ldr r1, [sp, #68] ; 0x44 16e78: e3710001 cmn r1, #1
16e7c: 0a000011 beq 16ec8 <msdos_find_name_in_fat_file+0x308>
* 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) &
16e80: e59dc00c ldr ip, [sp, #12] 16e84: e203303f and r3, r3, #63 ; 0x3f 16e88: e153000c cmp r3, ip 16e8c: e58d3014 str r3, [sp, #20]
16e90: 0a000014 beq 16ee8 <msdos_find_name_in_fat_file+0x328>
(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;
16e94: e3e00000 mvn r0, #0 <== NOT EXECUTED 16e98: e58d0044 str r0, [sp, #68] ; 0x44 <== NOT EXECUTED
continue;
16e9c: eaffffe1 b 16e28 <msdos_find_name_in_fat_file+0x268> <== NOT EXECUTED
* 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 ||
((name_type == MSDOS_NAME_SHORT) &&
16ea0: e59d3044 ldr r3, [sp, #68] ; 0x44 16ea4: e3730001 cmn r3, #1
16ea8: 1affffed bne 16e64 <msdos_find_name_in_fat_file+0x2a4>
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
(memcmp(MSDOS_DIR_NAME(entry),
16eac: e1a00006 mov r0, r6 16eb0: e59d1080 ldr r1, [sp, #128] ; 0x80 16eb4: e3a0200b mov r2, #11 16eb8: eb000cf7 bl 1a29c <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) &&
16ebc: e3500000 cmp r0, #0
16ec0: 1affffe7 bne 16e64 <msdos_find_name_in_fat_file+0x2a4>
16ec4: eaffffad b 16d80 <msdos_find_name_in_fat_file+0x1c0>
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
16ec8: e2132040 ands r2, r3, #64 ; 0x40
16ecc: 0affffd5 beq 16e28 <msdos_find_name_in_fat_file+0x268>
* 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) &
16ed0: e59dc028 ldr ip, [sp, #40] ; 0x28 16ed4: e203303f and r3, r3, #63 ; 0x3f 16ed8: e153000c cmp r3, ip
16edc: 0a000099 beq 17148 <msdos_find_name_in_fat_file+0x588>
* 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;
16ee0: e3a02000 mov r2, #0 16ee4: eaffffcf b 16e28 <msdos_find_name_in_fat_file+0x268>
* 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) &
MSDOS_LAST_LONG_ENTRY_MASK)) ||
16ee8: e5d6300d ldrb r3, [r6, #13] 16eec: e59dc010 ldr ip, [sp, #16] 16ef0: e153000c cmp r3, ip
16ef4: 1affffe6 bne 16e94 <msdos_find_name_in_fat_file+0x2d4>
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
16ef8: e59dc00c ldr ip, [sp, #12]
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
p = entry + 1;
16efc: e2866001 add r6, r6, #1
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
16f00: e24cc001 sub ip, ip, #1
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
16f04: e08c308c add r3, ip, ip, lsl #1
{
#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')
16f08: e5d62000 ldrb r2, [r6]
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
16f0c: e08c3103 add r3, ip, r3, lsl #2
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
16f10: e58dc00c str ip, [sp, #12]
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
16f14: e58d3038 str r3, [sp, #56] ; 0x38
p = entry + 1;
16f18: e1a0c003 mov ip, r3
{
#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')
16f1c: e3520000 cmp r2, #0
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
p = entry + 1;
16f20: e3a03000 mov r3, #0 16f24: e58db03c str fp, [sp, #60] ; 0x3c 16f28: e58da040 str sl, [sp, #64] ; 0x40 16f2c: e1a0b005 mov fp, r5 16f30: e59da034 ldr sl, [sp, #52] ; 0x34 16f34: e59d5074 ldr r5, [sp, #116] ; 0x74 16f38: e1a01003 mov r1, r3
{
#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')
16f3c: 0a000011 beq 16f88 <msdos_find_name_in_fat_file+0x3c8>
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
16f40: e15c0005 cmp ip, r5
16f44: aa00009d bge 171c0 <msdos_find_name_in_fat_file+0x600>
16f48: e7da000c ldrb r0, [sl, ip] 16f4c: e1500002 cmp r0, r2 16f50: e2833001 add r3, r3, #1
16f54: 1a000099 bne 171c0 <msdos_find_name_in_fat_file+0x600>
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
switch (i)
16f58: e3510004 cmp r1, #4
16f5c: 0a00001a beq 16fcc <msdos_find_name_in_fat_file+0x40c>
16f60: e351000a cmp r1, #10
16f64: 0a000015 beq 16fc0 <msdos_find_name_in_fat_file+0x400>
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++)
16f68: e353000d cmp r3, #13
16f6c: 0a00007e beq 1716c <msdos_find_name_in_fat_file+0x5ac>
break;
case 10:
p += 4;
break;
default:
p += 2;
16f70: e2866002 add r6, r6, #2
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
p = entry + 1;
16f74: e28cc001 add ip, ip, #1
{
#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')
16f78: e5d62000 ldrb r2, [r6] 16f7c: e3520000 cmp r2, #0
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
p = entry + 1;
16f80: e1a01003 mov r1, r3
{
#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')
16f84: 1affffed bne 16f40 <msdos_find_name_in_fat_file+0x380>
/*
* 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) &&
16f88: e59dc028 ldr ip, [sp, #40] ; 0x28 16f8c: e59d0014 ldr r0, [sp, #20] 16f90: e15c0000 cmp ip, r0 16f94: e1a0500b mov r5, fp 16f98: e59da040 ldr sl, [sp, #64] ; 0x40 16f9c: e59db03c ldr fp, [sp, #60] ; 0x3c
16fa0: 1a000074 bne 17178 <msdos_find_name_in_fat_file+0x5b8>
((o + i) != name_len))
16fa4: e59d1038 ldr r1, [sp, #56] ; 0x38
/*
* 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) &&
16fa8: e59dc074 ldr ip, [sp, #116] ; 0x74
((o + i) != name_len))
16fac: 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) &&
16fb0: e153000c cmp r3, ip
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
16fb4: 13e00000 mvnne r0, #0 16fb8: 158d0044 strne r0, [sp, #68] ; 0x44 16fbc: ea00006d b 17178 <msdos_find_name_in_fat_file+0x5b8>
{
case 4:
p += 5;
break;
case 10:
p += 4;
16fc0: e2866004 add r6, r6, #4
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
p = entry + 1;
16fc4: e28cc001 add ip, ip, #1 16fc8: eaffffea b 16f78 <msdos_find_name_in_fat_file+0x3b8>
}
switch (i)
{
case 4:
p += 5;
16fcc: e2866005 add r6, r6, #5
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
p = entry + 1;
16fd0: e28cc001 add ip, ip, #1 16fd4: eaffffe7 b 16f78 <msdos_find_name_in_fat_file+0x3b8>
#endif
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
16fd8: e35c0000 cmp ip, #0
16fdc: 0a000082 beq 171ec <msdos_find_name_in_fat_file+0x62c>
* 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)
16fe0: e3590000 cmp r9, #0
{
empty_space_count +=
entries_per_block - (dir_entry / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
16fe4: 059dc004 ldreq ip, [sp, #4] 16fe8: 008772ac addeq r7, r7, ip, 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 +=
16fec: 004772a4 subeq r7, r7, r4, lsr #5
* 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)
16ff0: e59dc078 ldr ip, [sp, #120] ; 0x78 16ff4: e35c0002 cmp ip, #2
16ff8: 0a000110 beq 17440 <msdos_find_name_in_fat_file+0x880>
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)
16ffc: e59dc028 ldr ip, [sp, #40] ; 0x28 17000: e35c0000 cmp ip, #0
17004: 1a0000fa bne 173f4 <msdos_find_name_in_fat_file+0x834>
* 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;
17008: e59dc028 ldr ip, [sp, #40] ; 0x28 1700c: e58dc014 str ip, [sp, #20]
* 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)
17010: e3570000 cmp r7, #0
17014: 0a000137 beq 174f8 <msdos_find_name_in_fat_file+0x938>
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;
17018: e59dc030 ldr ip, [sp, #48] ; 0x30 1701c: e05a300c subs r3, sl, ip 17020: 13a03001 movne r3, #1
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
17024: e59dc028 ldr ip, [sp, #40] ; 0x28
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
17028: e3e02000 mvn r2, #0
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
1702c: e35c0000 cmp ip, #0
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
17030: e58d2048 str r2, [sp, #72] ; 0x48 17034: e58d2044 str r2, [sp, #68] ; 0x44
empty_space_offset++;
empty_space_entry = 0;
read_cluster = true;
}
return 0;
17038: b3a05000 movlt r5, #0
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
1703c: baffff70 blt 16e04 <msdos_find_name_in_fat_file+0x244>
17040: e59de004 ldr lr, [sp, #4] 17044: e00c0a9e mul ip, lr, sl
{
int length = 0;
if (read_cluster)
17048: e3530000 cmp r3, #0
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
1704c: e58dc00c str ip, [sp, #12]
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
lfn_entry = 0;
17050: e3a06000 mov r6, #0
*/
while (lfn_entry < (lfn_entries + 1))
{
int length = 0;
if (read_cluster)
17054: 1a0000b6 bne 17334 <msdos_find_name_in_fat_file+0x774>
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
17058: e59dc004 ldr ip, [sp, #4] 1705c: e15c0005 cmp ip, r5
17060: 9a00012b bls 17514 <msdos_find_name_in_fat_file+0x954>
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
17064: e59dc020 ldr ip, [sp, #32]
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
17068: e59d3028 ldr r3, [sp, #40] ; 0x28
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;
1706c: e59c40a0 ldr r4, [ip, #160] ; 0xa0
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
17070: e2833001 add r3, r3, #1
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
17074: e2867001 add r7, r6, #1
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
17078: e1530007 cmp r3, r7 1707c: e58d3008 str r3, [sp, #8]
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;
17080: e0844005 add r4, r4, r5
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
17084: 0a00011f beq 17508 <msdos_find_name_in_fat_file+0x948>
* 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(
17088: e59dc028 ldr ip, [sp, #40] ; 0x28 1708c: e1e02006 mvn r2, r6 17090: e082200c add r2, r2, ip
dir_pos->lname.ofs = lfn_start.ofs;
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
17094: e20c30ff and r3, ip, #255 ; 0xff 17098: e2833001 add r3, r3, #1
* 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(
1709c: e0821082 add r1, r2, r2, lsl #1 170a0: e59dc034 ldr ip, [sp, #52] ; 0x34
dir_pos->lname.ofs = lfn_start.ofs;
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
170a4: e0673003 rsb r3, r7, r3
* 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(
170a8: e0822101 add r2, r2, r1, lsl #2 170ac: e1a06005 mov r6, r5
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
170b0: e58da010 str sl, [sp, #16] 170b4: e58d5018 str r5, [sp, #24] 170b8: e59da014 ldr sl, [sp, #20] 170bc: e59d5020 ldr r5, [sp, #32]
dir_pos->lname.ofs = lfn_start.ofs;
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
170c0: e20380ff and r8, r3, #255 ; 0xff
* 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(
170c4: e08c9002 add r9, ip, r2
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
170c8: e3a0b020 mov fp, #32
* 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)
170cc: e59d3044 ldr r3, [sp, #68] ; 0x44 170d0: e3730001 cmn r3, #1
{
lfn_start.cln = empty_space_offset;
170d4: 059d3010 ldreq r3, [sp, #16]
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
170d8: e3a02020 mov r2, #32 170dc: e1a00004 mov r0, r4 170e0: e3a01000 mov r1, #0
* 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;
170e4: 058d3044 streq r3, [sp, #68] ; 0x44
lfn_start.ofs = dir_entry;
170e8: 058d6048 streq r6, [sp, #72] ; 0x48
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
170ec: eb000ccd bl 1a428 <memset>
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
170f0: e5c4a00d strb sl, [r4, #13]
p = entry + 1;
170f4: e2843001 add r3, r4, #1
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
170f8: e1a0c009 mov ip, r9 170fc: e3a02001 mov r2, #1
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
char* p;
const char* n;
int i;
char fill = 0;
17100: e3a0e000 mov lr, #0
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
if (*n != 0)
17104: e5dc0000 ldrb r0, [ip]
* 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(
17108: e2421001 sub r1, r2, #1
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
if (*n != 0)
1710c: e3500000 cmp r0, #0
*p = *n;
n++;
}
else
{
p [0] = fill;
17110: 05c3e000 strbeq lr, [r3]
p [1] = fill;
17114: 05c3e001 strbeq lr, [r3, #1]
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
if (*n != 0)
{
*p = *n;
17118: 15c30000 strbne r0, [r3]
n++;
1711c: 128cc001 addne ip, ip, #1
}
else
{
p [0] = fill;
p [1] = fill;
fill = 0xff;
17120: 03a0e0ff moveq lr, #255 ; 0xff
}
switch (i)
17124: e3510004 cmp r1, #4
17128: 0a0000ea beq 174d8 <msdos_find_name_in_fat_file+0x918>
1712c: e351000a cmp r1, #10
17130: 0a0000e5 beq 174cc <msdos_find_name_in_fat_file+0x90c>
*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++)
17134: e352000d cmp r2, #13
17138: 0a00002d beq 171f4 <msdos_find_name_in_fat_file+0x634>
break;
case 10:
p += 4;
break;
default:
p += 2;
1713c: e2833002 add r3, r3, #2
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;
17140: e2822001 add r2, r2, #1 17144: eaffffee b 17104 <msdos_find_name_in_fat_file+0x544>
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
lfn_start.ofs = dir_entry;
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
17148: e5d6c00d ldrb ip, [r6, #13]
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
1714c: e58db044 str fp, [sp, #68] ; 0x44
lfn_start.ofs = dir_entry;
17150: e58d4048 str r4, [sp, #72] ; 0x48
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
17154: e58dc010 str ip, [sp, #16] 17158: e59dc028 ldr ip, [sp, #40] ; 0x28 1715c: e5d63000 ldrb r3, [r6] 17160: e58dc00c str ip, [sp, #12]
* 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;
17164: e3a02000 mov r2, #0 17168: eaffff44 b 16e80 <msdos_find_name_in_fat_file+0x2c0> 1716c: e1a0500b mov r5, fp 17170: e59da040 ldr sl, [sp, #64] ; 0x40 17174: e59db03c ldr fp, [sp, #60] ; 0x3c
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
17178: e59dc00c ldr ip, [sp, #12] 1717c: e35c0000 cmp ip, #0
17180: 1affff56 bne 16ee0 <msdos_find_name_in_fat_file+0x320> * 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(
17184: e59d2044 ldr r2, [sp, #68] ; 0x44 17188: e2922001 adds r2, r2, #1 1718c: 13a02001 movne r2, #1 17190: eaffff24 b 16e28 <msdos_find_name_in_fat_file+0x268>
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) &&
17194: e59c3024 ldr r3, [ip, #36] ; 0x24 17198: e3530000 cmp r3, #0
1719c: 1afffeac bne 16c54 <msdos_find_name_in_fat_file+0x94>
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
171a0: e59dc020 ldr ip, [sp, #32] 171a4: e5dc300e ldrb r3, [ip, #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) &&
171a8: e3130003 tst r3, #3
171ac: 0afffea8 beq 16c54 <msdos_find_name_in_fat_file+0x94>
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
171b0: e59dc02c ldr ip, [sp, #44] ; 0x2c 171b4: e59cc018 ldr ip, [ip, #24] 171b8: e58dc004 str ip, [sp, #4] 171bc: eafffea7 b 16c60 <msdos_find_name_in_fat_file+0xa0>
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
171c0: e3e01000 mvn r1, #0 171c4: e1a0500b mov r5, fp 171c8: e59da040 ldr sl, [sp, #64] ; 0x40 171cc: e59db03c ldr fp, [sp, #60] ; 0x3c 171d0: e58d1044 str r1, [sp, #68] ; 0x44
break;
171d4: eaffffe7 b 17178 <msdos_find_name_in_fat_file+0x5b8>
}
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)
171d8: e1a05000 mov r5, r0 171dc: eaffff08 b 16e04 <msdos_find_name_in_fat_file+0x244>
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
171e0: e59dc008 ldr ip, [sp, #8] 171e4: e35c0000 cmp ip, #0
171e8: 1affff80 bne 16ff0 <msdos_find_name_in_fat_file+0x430>
return MSDOS_NAME_NOT_FOUND_ERR;
171ec: e59f5358 ldr r5, [pc, #856] ; 1754c <msdos_find_name_in_fat_file+0x98c> 171f0: eaffff03 b 16e04 <msdos_find_name_in_fat_file+0x244>
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
171f4: e3570001 cmp r7, #1
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
171f8: 03883040 orreq r3, r8, #64 ; 0x40
p += 2;
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
171fc: e5c48000 strb r8, [r4]
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
17200: e59dc004 ldr ip, [sp, #4]
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
17204: 05c43000 strbeq r3, [r4]
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
17208: e5d4300b ldrb r3, [r4, #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)
1720c: e2866020 add r6, r6, #32
}
*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;
17210: e383300f orr r3, r3, #15
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
17214: e15c0006 cmp ip, r6
}
*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;
17218: e5c4300b strb r3, [r4, #11]
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
1721c: 9a0000b0 bls 174e4 <msdos_find_name_in_fat_file+0x924>
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
17220: e59d3008 ldr r3, [sp, #8]
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;
17224: e59540a0 ldr r4, [r5, #160] ; 0xa0
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
17228: e2877001 add r7, r7, #1 1722c: e2488001 sub r8, r8, #1
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
17230: e1530007 cmp r3, r7
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;
17234: e0844006 add r4, r4, r6
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
17238: e28bb020 add fp, fp, #32
lfn_entry++;
1723c: e20880ff and r8, r8, #255 ; 0xff 17240: e249900d sub r9, r9, #13
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
17244: 1affffa0 bne 170cc <msdos_find_name_in_fat_file+0x50c>
17248: e59da010 ldr sl, [sp, #16] 1724c: e59d5018 ldr r5, [sp, #24]
{
/* get current cluster number */
int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
17250: e59dc07c ldr ip, [sp, #124] ; 0x7c 17254: e59d0020 ldr r0, [sp, #32] 17258: e59d102c ldr r1, [sp, #44] ; 0x2c 1725c: e3a02001 mov r2, #1 17260: e59d300c ldr r3, [sp, #12] 17264: e58dc000 str ip, [sp] 17268: ebffe958 bl 117d0 <fat_file_ioctl>
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
1726c: e3500000 cmp r0, #0
17270: 1affffd8 bne 171d8 <msdos_find_name_in_fat_file+0x618>
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
17274: e59d3044 ldr r3, [sp, #68] ; 0x44
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
17278: e59dc07c ldr ip, [sp, #124] ; 0x7c
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
1727c: e3730001 cmn r3, #1
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
17280: e58c6004 str r6, [ip, #4]
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
17284: 0a00000a beq 172b4 <msdos_find_name_in_fat_file+0x6f4>
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
17288: e59dc004 ldr ip, [sp, #4] 1728c: e59d0020 ldr r0, [sp, #32] 17290: e003039c mul r3, ip, r3 17294: e59d102c ldr r1, [sp, #44] ; 0x2c 17298: e28dc044 add ip, sp, #68 ; 0x44 1729c: e3a02001 mov r2, #1 172a0: e58dc000 str ip, [sp] 172a4: ebffe949 bl 117d0 <fat_file_ioctl>
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
172a8: e3500000 cmp r0, #0
172ac: 1affffc9 bne 171d8 <msdos_find_name_in_fat_file+0x618>
172b0: e59d3044 ldr r3, [sp, #68] ; 0x44
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
172b4: e59dc07c ldr ip, [sp, #124] ; 0x7c 172b8: e58c3008 str r3, [ip, #8]
dir_pos->lname.ofs = lfn_start.ofs;
172bc: e59d3048 ldr r3, [sp, #72] ; 0x48
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
172c0: e1a00004 mov r0, r4
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
172c4: e58c300c str r3, [ip, #12]
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
172c8: e59d1080 ldr r1, [sp, #128] ; 0x80 172cc: e3a02020 mov r2, #32 172d0: eb000c1e bl 1a350 <memcpy>
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
172d4: e1a06007 mov r6, r7
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
172d8: e1a0300b mov r3, fp
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,
172dc: e59de020 ldr lr, [sp, #32] 172e0: e59ec0a0 ldr ip, [lr, #160] ; 0xa0 172e4: e1a0000e mov r0, lr 172e8: e59de00c ldr lr, [sp, #12] 172ec: e08cc005 add ip, ip, r5 172f0: e59d102c ldr r1, [sp, #44] ; 0x2c 172f4: e08e2005 add r2, lr, r5 172f8: e58dc000 str ip, [sp] 172fc: ebffe9f4 bl 11ad4 <fat_file_write>
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
17300: e3700001 cmn r0, #1
17304: 0affffb3 beq 171d8 <msdos_find_name_in_fat_file+0x618>
return ret;
else if (ret != length)
17308: e150000b cmp r0, fp
1730c: 1a000033 bne 173e0 <msdos_find_name_in_fat_file+0x820>
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
17310: e59dc028 ldr ip, [sp, #40] ; 0x28
if (ret == -1)
return ret;
else if (ret != length)
rtems_set_errno_and_return_minus_one(EIO);
empty_space_offset++;
17314: e59d0004 ldr r0, [sp, #4]
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
17318: e15c0006 cmp ip, r6
if (ret == -1)
return ret;
else if (ret != length)
rtems_set_errno_and_return_minus_one(EIO);
empty_space_offset++;
1731c: e59dc00c ldr ip, [sp, #12] 17320: e08cc000 add ip, ip, r0
empty_space_entry = 0;
17324: e3a05000 mov r5, #0
if (ret == -1)
return ret;
else if (ret != length)
rtems_set_errno_and_return_minus_one(EIO);
empty_space_offset++;
17328: e28aa001 add sl, sl, #1 1732c: e58dc00c str ip, [sp, #12]
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
17330: bafffeb3 blt 16e04 <msdos_find_name_in_fat_file+0x244>
{
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,
17334: e59d0020 ldr r0, [sp, #32] 17338: e590c0a0 ldr ip, [r0, #160] ; 0xa0 1733c: e59d200c ldr r2, [sp, #12] 17340: e59d102c ldr r1, [sp, #44] ; 0x2c 17344: e59d3004 ldr r3, [sp, #4] 17348: e58dc000 str ip, [sp] 1734c: ebffe83a bl 1143c <fat_file_read>
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
17350: e59dc004 ldr ip, [sp, #4] 17354: e150000c cmp r0, ip
{
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,
17358: e1a02000 mov r2, r0
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
1735c: 0affff3d beq 17058 <msdos_find_name_in_fat_file+0x498>
{
if (ret != FAT_EOF)
17360: e3500000 cmp r0, #0
17364: 1a00001d bne 173e0 <msdos_find_name_in_fat_file+0x820>
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,
17368: e59d102c ldr r1, [sp, #44] ; 0x2c 1736c: e28dc04c add ip, sp, #76 ; 0x4c 17370: e59d0020 ldr r0, [sp, #32] 17374: e59d300c ldr r3, [sp, #12] 17378: e58dc000 str ip, [sp] 1737c: ebffe944 bl 11894 <fat_file_extend>
empty_space_offset * bts2rd, &new_length);
if (ret != RC_OK)
17380: e2501000 subs r1, r0, #0
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,
17384: 11a05001 movne r5, r1
empty_space_offset * bts2rd, &new_length);
if (ret != RC_OK)
17388: 1afffe9d bne 16e04 <msdos_find_name_in_fat_file+0x244>
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))
1738c: e59d304c ldr r3, [sp, #76] ; 0x4c 17390: e59dc00c ldr ip, [sp, #12] 17394: e153000c cmp r3, ip
17398: 1a000010 bne 173e0 <msdos_find_name_in_fat_file+0x820>
rtems_set_errno_and_return_minus_one(EIO);
memset(fs_info->cl_buf, 0, bts2rd);
1739c: e59dc020 ldr ip, [sp, #32] 173a0: e59d2004 ldr r2, [sp, #4] 173a4: e59c00a0 ldr r0, [ip, #160] ; 0xa0 173a8: eb000c1e bl 1a428 <memset>
ret = fat_file_write(&fs_info->fat, fat_fd,
173ac: e59de020 ldr lr, [sp, #32] 173b0: e59ec0a0 ldr ip, [lr, #160] ; 0xa0 173b4: e1a0000e mov r0, lr 173b8: e59d102c ldr r1, [sp, #44] ; 0x2c 173bc: e59d200c ldr r2, [sp, #12] 173c0: e59d3004 ldr r3, [sp, #4] 173c4: e58dc000 str ip, [sp] 173c8: ebffe9c1 bl 11ad4 <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)
173cc: e3700001 cmn r0, #1
173d0: 0affff80 beq 171d8 <msdos_find_name_in_fat_file+0x618>
return ret;
else if (ret != bts2rd)
173d4: e59dc004 ldr ip, [sp, #4] <== NOT EXECUTED 173d8: e150000c cmp r0, ip <== NOT EXECUTED 173dc: 0affff1d beq 17058 <msdos_find_name_in_fat_file+0x498> <== NOT EXECUTED
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
return ret;
else if (ret != length)
rtems_set_errno_and_return_minus_one(EIO);
173e0: eb000933 bl 198b4 <__errno> <== NOT EXECUTED 173e4: e3a03005 mov r3, #5 <== NOT EXECUTED 173e8: e5803000 str r3, [r0] <== NOT EXECUTED 173ec: e3e05000 mvn r5, #0 <== NOT EXECUTED 173f0: eafffe83 b 16e04 <msdos_find_name_in_fat_file+0x244> <== NOT EXECUTED
* RC_OK on success, or error code if error occured (errno set * appropriately) * */ #define MSDOS_FIND_PRINT 0 int msdos_find_name_in_fat_file(
173f4: e3a0c000 mov ip, #0 173f8: e58dc014 str ip, [sp, #20] 173fc: e59dc080 ldr ip, [sp, #128] ; 0x80
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
17400: e3a01000 mov r1, #0
* 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(
17404: e28c000b add r0, ip, #11 17408: e1a0200c mov r2, ip 1740c: e1a03001 mov r3, r1 17410: ea000001 b 1741c <msdos_find_name_in_fat_file+0x85c>
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
17414: e2111001 ands r1, r1, #1 17418: 13a01080 movne r1, #128 ; 0x80 1741c: e4d2c001 ldrb ip, [r2], #1 17420: e08c30a3 add r3, ip, r3, lsr #1 17424: e20330ff and r3, r3, #255 ; 0xff 17428: e0831001 add r1, r3, r1
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
1742c: e1520000 cmp r2, r0
lfn_checksum =
17430: e20130ff and r3, r1, #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++)
17434: 1afffff6 bne 17414 <msdos_find_name_in_fat_file+0x854>
17438: e58d3014 str r3, [sp, #20] 1743c: eafffef3 b 17010 <msdos_find_name_in_fat_file+0x450>
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
17440: e59dc004 ldr ip, [sp, #4] 17444: e0215a9c mla r1, ip, sl, r5
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
17448: e59dc080 ldr ip, [sp, #128] ; 0x80 1744c: e5dc3000 ldrb r3, [ip]
*/
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;
17450: e59dc028 ldr ip, [sp, #40] ; 0x28
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
17454: e3530020 cmp r3, #32 17458: 1353002e cmpne r3, #46 ; 0x2e
*c = '_';
1745c: 059d0080 ldreq r0, [sp, #128] ; 0x80 17460: 03a0305f moveq r3, #95 ; 0x5f
*/
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;
17464: e28c2001 add r2, ip, #1
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
17468: 05c03000 strbeq r3, [r0]
*/
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;
1746c: e082c2a1 add ip, r2, 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 == '.'))
17470: e59d1080 ldr r1, [sp, #128] ; 0x80 17474: e5d13001 ldrb r3, [r1, #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++)
17478: e59d2080 ldr r2, [sp, #128] ; 0x80
if ((*c == ' ') || (*c == '.'))
1747c: e3530020 cmp r3, #32 17480: 1353002e cmpne r3, #46 ; 0x2e
*c = '_';
17484: 03a0305f moveq r3, #95 ; 0x5f 17488: e59f00c0 ldr r0, [pc, #192] ; 17550 <msdos_find_name_in_fat_file+0x990> 1748c: 05c13001 strbeq r3, [r1, #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++)
17490: e2821002 add r1, r2, #2 17494: e3a0300c mov r3, #12
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
17498: e1a0235c asr r2, ip, r3 1749c: e202200f and r2, r2, #15 174a0: e7d02002 ldrb r2, [r0, r2]
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++)
174a4: e2433004 sub r3, r3, #4 174a8: e3730004 cmn r3, #4
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
174ac: e4c12001 strb r2, [r1], #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++)
174b0: 1afffff8 bne 17498 <msdos_find_name_in_fat_file+0x8d8>
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
*c++ = '~';
174b4: e59dc080 ldr ip, [sp, #128] ; 0x80 174b8: e3a0307e mov r3, #126 ; 0x7e 174bc: e5cc3006 strb r3, [ip, #6]
*c++ = '1';
174c0: e3a03031 mov r3, #49 ; 0x31 174c4: e5cc3007 strb r3, [ip, #7] 174c8: eafffecb b 16ffc <msdos_find_name_in_fat_file+0x43c>
{
case 4:
p += 5;
break;
case 10:
p += 4;
174cc: e2833004 add r3, r3, #4
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;
174d0: e2822001 add r2, r2, #1 174d4: eaffff0a b 17104 <msdos_find_name_in_fat_file+0x544>
}
switch (i)
{
case 4:
p += 5;
174d8: e2833005 add r3, r3, #5
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;
174dc: e2822001 add r2, r2, #1 174e0: eaffff07 b 17104 <msdos_find_name_in_fat_file+0x544>
174e4: e59da010 ldr sl, [sp, #16] <== NOT EXECUTED 174e8: e59d5018 ldr r5, [sp, #24] <== NOT EXECUTED
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
174ec: e1a0300b mov r3, fp <== NOT EXECUTED 174f0: e1a06007 mov r6, r7 <== NOT EXECUTED 174f4: eaffff78 b 172dc <msdos_find_name_in_fat_file+0x71c> <== NOT EXECUTED
* empty_space_count is a count of empty entries in the currently
* read cluster so if 0 there is no space. Note, dir_offset will
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
174f8: e59da030 ldr sl, [sp, #48] ; 0x30
{
read_cluster = true;
174fc: e3a03001 mov r3, #1
empty_space_offset = dir_offset;
empty_space_entry = 0;
17500: e1a05007 mov r5, r7 17504: eafffec6 b 17024 <msdos_find_name_in_fat_file+0x464>
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
17508: e1a06005 mov r6, r5
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
1750c: e3a0b020 mov fp, #32 17510: eaffff4e b 17250 <msdos_find_name_in_fat_file+0x690>
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
17514: e3a03000 mov r3, #0 <== NOT EXECUTED 17518: e1a0b003 mov fp, r3 <== NOT EXECUTED 1751c: eaffff6e b 172dc <msdos_find_name_in_fat_file+0x71c> <== NOT EXECUTED
#endif
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
17520: e59f002c ldr r0, [pc, #44] ; 17554 <msdos_find_name_in_fat_file+0x994><== NOT EXECUTED 17524: e59f102c ldr r1, [pc, #44] ; 17558 <msdos_find_name_in_fat_file+0x998><== NOT EXECUTED 17528: e59f202c ldr r2, [pc, #44] ; 1755c <msdos_find_name_in_fat_file+0x99c><== NOT EXECUTED 1752c: e59f302c ldr r3, [pc, #44] ; 17560 <msdos_find_name_in_fat_file+0x9a0><== NOT EXECUTED 17530: ebfff097 bl 13794 <__assert_func> <== NOT EXECUTED
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
17534: e59f0018 ldr r0, [pc, #24] ; 17554 <msdos_find_name_in_fat_file+0x994><== NOT EXECUTED 17538: e59f1024 ldr r1, [pc, #36] ; 17564 <msdos_find_name_in_fat_file+0x9a4><== NOT EXECUTED 1753c: e59f2018 ldr r2, [pc, #24] ; 1755c <msdos_find_name_in_fat_file+0x99c><== NOT EXECUTED 17540: e59f3020 ldr r3, [pc, #32] ; 17568 <msdos_find_name_in_fat_file+0x9a8><== NOT EXECUTED 17544: ebfff092 bl 13794 <__assert_func> <== NOT EXECUTED
0001756c <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
)
{
1756c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
17570: e1a0a001 mov sl, r1
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) &&
17574: e5911020 ldr r1, [r1, #32] 17578: e3510001 cmp r1, #1
fat_file_fd_t *fat_fd,
uint32_t cl4find,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
1757c: e24dd004 sub sp, sp, #4 17580: e1a07002 mov r7, r2 17584: e1a0b003 mov fp, r3
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
17588: e5908008 ldr r8, [r0, #8]
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
1758c: 0a000025 beq 17628 <msdos_find_node_by_cluster_num_in_fat_file+0xbc>
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
17590: e1d860b6 ldrh r6, [r8, #6]
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
17594: e598c0a0 ldr ip, [r8, #160] ; 0xa0
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
17598: e3a09000 mov r9, #0
(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,
1759c: e1a00008 mov r0, r8 175a0: e1a0100a mov r1, sl 175a4: e1a02009 mov r2, r9 175a8: e1a03006 mov r3, r6 175ac: e58dc000 str ip, [sp] 175b0: ebffe7a1 bl 1143c <fat_file_read> 175b4: e3500000 cmp r0, #0
175b8: 0a000016 beq 17618 <msdos_find_node_by_cluster_num_in_fat_file+0xac>
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
175bc: e350001f cmp r0, #31
175c0: da000031 ble 1768c <msdos_find_node_by_cluster_num_in_fat_file+0x120>
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
175c4: e1500006 cmp r0, r6
175c8: 1a000034 bne 176a0 <msdos_find_node_by_cluster_num_in_fat_file+0x134>
175cc: e598c0a0 ldr ip, [r8, #160] ; 0xa0 175d0: e3a04000 mov r4, #0 175d4: e1a0500c mov r5, ip
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
175d8: e7dc3004 ldrb r3, [ip, r4] 175dc: e3530000 cmp r3, #0
175e0: 0a00000c beq 17618 <msdos_find_node_by_cluster_num_in_fat_file+0xac>
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)) ==
175e4: e35300e5 cmp r3, #229 ; 0xe5
175e8: 0a000004 beq 17600 <msdos_find_node_by_cluster_num_in_fat_file+0x94>
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
175ec: e1d521b4 ldrh r2, [r5, #20] 175f0: e1d531ba ldrh r3, [r5, #26] 175f4: e1833802 orr r3, r3, r2, lsl #16 175f8: e1530007 cmp r3, r7
175fc: 0a000011 beq 17648 <msdos_find_node_by_cluster_num_in_fat_file+0xdc>
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)
17600: e2844020 add r4, r4, #32 17604: e1540006 cmp r4, r6 17608: e2855020 add r5, r5, #32
1760c: 3afffff1 bcc 175d8 <msdos_find_node_by_cluster_num_in_fat_file+0x6c>
17610: e0899006 add r9, r9, r6 <== NOT EXECUTED 17614: eaffffe0 b 1759c <msdos_find_node_by_cluster_num_in_fat_file+0x30><== NOT EXECUTED
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;
17618: e59f6094 ldr r6, [pc, #148] ; 176b4 <msdos_find_node_by_cluster_num_in_fat_file+0x148><== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
1761c: e1a00006 mov r0, r6
17620: e28dd004 add sp, sp, #4
17624: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
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) &&
17628: e59a3024 ldr r3, [sl, #36] ; 0x24 <== NOT EXECUTED 1762c: e3530000 cmp r3, #0 <== NOT EXECUTED 17630: 1affffd6 bne 17590 <msdos_find_node_by_cluster_num_in_fat_file+0x24><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
17634: e5d8300e ldrb r3, [r8, #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) &&
17638: e3130003 tst r3, #3 <== NOT EXECUTED 1763c: 0affffd3 beq 17590 <msdos_find_node_by_cluster_num_in_fat_file+0x24><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
17640: e59a6018 ldr r6, [sl, #24] <== NOT EXECUTED 17644: eaffffd2 b 17594 <msdos_find_node_by_cluster_num_in_fat_file+0x28><== NOT EXECUTED
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
{
/* on success fill aux structure and copy all 32 bytes */
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM, j * bts2rd,
17648: e1a00008 mov r0, r8 1764c: e1a0100a mov r1, sl 17650: e3a02001 mov r2, #1 17654: e1a03009 mov r3, r9 17658: e58db000 str fp, [sp] 1765c: ebffe85b bl 117d0 <fat_file_ioctl>
&dir_pos->sname.cln);
if (rc != RC_OK)
17660: e2506000 subs r6, r0, #0
17664: 1affffec bne 1761c <msdos_find_node_by_cluster_num_in_fat_file+0xb0>
return rc;
dir_pos->sname.ofs = i;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
17668: 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;
1766c: e58b4004 str r4, [fp, #4]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
17670: e58b3008 str r3, [fp, #8]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
17674: e58b300c str r3, [fp, #12]
memcpy(dir_entry, entry,
17678: e59d0028 ldr r0, [sp, #40] ; 0x28 1767c: e1a01005 mov r1, r5 17680: e3a02020 mov r2, #32 17684: eb000b31 bl 1a350 <memcpy>
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
17688: eaffffe3 b 1761c <msdos_find_node_by_cluster_num_in_fat_file+0xb0>
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 )
rtems_set_errno_and_return_minus_one( EIO );
1768c: eb000888 bl 198b4 <__errno> <== NOT EXECUTED 17690: e3a03005 mov r3, #5 <== NOT EXECUTED 17694: e5803000 str r3, [r0] <== NOT EXECUTED 17698: e3e06000 mvn r6, #0 <== NOT EXECUTED 1769c: eaffffde b 1761c <msdos_find_node_by_cluster_num_in_fat_file+0xb0><== NOT EXECUTED
assert(ret == bts2rd);
176a0: e59f0010 ldr r0, [pc, #16] ; 176b8 <msdos_find_node_by_cluster_num_in_fat_file+0x14c><== NOT EXECUTED 176a4: e59f1010 ldr r1, [pc, #16] ; 176bc <msdos_find_node_by_cluster_num_in_fat_file+0x150><== NOT EXECUTED 176a8: e59f2010 ldr r2, [pc, #16] ; 176c0 <msdos_find_node_by_cluster_num_in_fat_file+0x154><== NOT EXECUTED 176ac: e59f3010 ldr r3, [pc, #16] ; 176c4 <msdos_find_node_by_cluster_num_in_fat_file+0x158><== NOT EXECUTED 176b0: ebfff037 bl 13794 <__assert_func> <== NOT EXECUTED
0000c744 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
c744: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
c748: e1a04001 mov r4, r1
c74c: e24ddfb7 sub sp, sp, #732 ; 0x2dc
c750: e1a07000 mov r7, r0
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
c754: e3a01002 mov r1, #2
c758: e59f2f80 ldr r2, [pc, #3968] ; d6e0 <msdos_format+0xf9c>
c75c: e1a00004 mov r0, r4
c760: ebffff48 bl c488 <msdos_format_printf>
fd = open(devname, O_RDWR);
c764: e1a00007 mov r0, r7
c768: e3a01002 mov r1, #2
c76c: ebffe257 bl 50d0 <open>
if (fd == -1) {
c770: e3700001 cmn r0, #1
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
fd = open(devname, O_RDWR);
c774: e1a05000 mov r5, r0
if (fd == -1) {
c778: 0a00018c beq cdb0 <msdos_format+0x66c>
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
c77c: e59f2f60 ldr r2, [pc, #3936] ; d6e4 <msdos_format+0xfa0>
c780: e1a03007 mov r3, r7
c784: e3a01002 mov r1, #2
c788: e1a00004 mov r0, r4
c78c: ebffff3d bl c488 <msdos_format_printf>
"stat check: %s\n", devname);
if (ret_val == 0) {
ret_val = fstat(fd, &stat_buf);
c790: e28d1fa2 add r1, sp, #648 ; 0x288
c794: e1a00005 mov r0, r5
c798: ebffdf18 bl 4400 <fstat>
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
c79c: e3a01001 mov r1, #1
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"stat check: %s\n", devname);
if (ret_val == 0) {
ret_val = fstat(fd, &stat_buf);
c7a0: e1a06000 mov r6, r0
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
c7a4: e59f2f3c ldr r2, [pc, #3900] ; d6e8 <msdos_format+0xfa4>
c7a8: e1a00004 mov r0, r4
c7ac: e1a03007 mov r3, r7
c7b0: ebffff34 bl c488 <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))) {
c7b4: e3560000 cmp r6, #0
c7b8: 1a000007 bne c7dc <msdos_format+0x98>
c7bc: e59d3294 ldr r3, [sp, #660] ; 0x294
c7c0: e2033a0f and r3, r3, #61440 ; 0xf000
c7c4: e3530a06 cmp r3, #24576 ; 0x6000
c7c8: 0a00000e beq c808 <msdos_format+0xc4>
errno = ENOTTY;
c7cc: eb003438 bl 198b4 <__errno> <== NOT EXECUTED
c7d0: e3a03019 mov r3, #25 <== NOT EXECUTED
c7d4: e5803000 str r3, [r0] <== NOT EXECUTED
ret_val = -1;
c7d8: e3e06000 mvn r6, #0 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
"formating: %s\n", devname);
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {
errno = ENOTTY;
c7dc: e2940000 adds r0, r4, #0 <== NOT EXECUTED
c7e0: 13a00001 movne r0, #1 <== NOT EXECUTED
c7e4: e58d0020 str r0, [sp, #32] <== NOT EXECUTED
}
/*
* create master boot record
*/
if (ret_val == 0) {
c7e8: e3560000 cmp r6, #0
c7ec: 0a00008c beq ca24 <msdos_format+0x2e0>
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
c7f0: e3750001 cmn r5, #1
close(fd);
c7f4: 11a00005 movne r0, r5
c7f8: 1bffde2e blne 40b8 <close>
}
return ret_val;
}
c7fc: e1a00006 mov r0, r6
c800: e28ddfb7 add sp, sp, #732 ; 0x2dc
c804: 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));
c808: e1a01006 mov r1, r6
c80c: e3a02054 mov r2, #84 ; 0x54
c810: e28d0f8d add r0, sp, #564 ; 0x234
c814: eb003703 bl 1a428 <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);
c818: e1a00005 mov r0, r5
c81c: e59f1ec8 ldr r1, [pc, #3784] ; d6ec <msdos_format+0xfa8>
c820: e28d2f8d add r2, sp, #564 ; 0x234
c824: eb001caa bl 13ad4 <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) {
c828: e2506000 subs r6, r0, #0
c82c: 0a00016b beq cde0 <msdos_format+0x69c>
}
else if (rqdata->fat_num <= 6) {
fmt_params->fat_num = rqdata->fat_num;
}
else {
errno = EINVAL;
c830: e2941000 adds r1, r4, #0
c834: 13a01001 movne r1, #1
c838: e58d1020 str r1, [sp, #32]
c83c: e59d9238 ldr r9, [sp, #568] ; 0x238
}
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
c840: e3590000 cmp r9, #0
c844: 0a000251 beq d190 <msdos_format+0xa4c>
{
errno = EINVAL;
ret_val = -1;
}
if (0 == ret_val)
c848: e3560000 cmp r6, #0
c84c: 1a000253 bne d1a0 <msdos_format+0xa5c>
{
if (FAT_FAT32 != fmt_params->fattype)
c850: e5dd3266 ldrb r3, [sp, #614] ; 0x266
c854: e3530004 cmp r3, #4
c858: 0a000351 beq d5a4 <msdos_format+0xe60>
{
fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
fmt_params->sectors_per_cluster,
fmt_params->skip_alignment)
c85c: e5dd3284 ldrb r3, [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,
c860: e59d1250 ldr r1, [sp, #592] ; 0x250
c864: 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)
c868: e3530000 cmp r3, #0
return (sectors + clustersize - 1) & ~(clustersize - 1);
c86c: 00811002 addeq r1, r1, r2
c870: 02410001 subeq r0, r1, #1
c874: 02621000 rsbeq r1, r2, #0
c878: 00001001 andeq r1, r0, r1
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);
c87c: e59d0234 ldr r0, [sp, #564] ; 0x234
c880: e1a002a0 lsr r0, r0, #5
c884: e0010190 mul r1, r0, r1
if (0 == ret_val)
{
if (FAT_FAT32 != fmt_params->fattype)
{
fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
c888: e58d124c str r1, [sp, #588] ; 0x24c
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,
c88c: e59d723c ldr r7, [sp, #572] ; 0x23c
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
c890: e3530000 cmp r3, #0
return (sectors + clustersize - 1) & ~(clustersize - 1);
c894: 02477001 subeq r7, r7, #1
c898: 00877002 addeq r7, r7, r2
c89c: 02622000 rsbeq r2, r2, #0
c8a0: 00077002 andeq r7, r7, r2
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
c8a4: e3540000 cmp r4, #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,
c8a8: e58d723c str r7, [sp, #572] ; 0x23c
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
c8ac: 0a000281 beq d2b8 <msdos_format+0xb74>
(rqdata->media != 0)) {
c8b0: e5d48014 ldrb r8, [r4, #20]
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
c8b4: e3580000 cmp r8, #0
c8b8: 0a00027e beq d2b8 <msdos_format+0xb74>
(rqdata->media != 0)) {
const char valid_media_codes[] =
c8bc: e3a02009 mov r2, #9
c8c0: e59f1e28 ldr r1, [pc, #3624] ; d6f0 <msdos_format+0xfac>
c8c4: e28d0e2d add r0, sp, #720 ; 0x2d0
c8c8: eb0036a0 bl 1a350 <memcpy>
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
c8cc: e28d0e2d add r0, sp, #720 ; 0x2d0
c8d0: e1a01008 mov r1, r8
c8d4: e3a02009 mov r2, #9
c8d8: eb00362f bl 1a19c <memchr>
c8dc: e250a000 subs sl, r0, #0
c8e0: 0a000377 beq d6c4 <msdos_format+0xf80>
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
}
else {
fmt_params->media_code = rqdata->media;
c8e4: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
c8e8: e5cd8265 strb r8, [sp, #613] ; 0x265 <== NOT EXECUTED
c8ec: e2038001 and r8, r3, #1 <== NOT EXECUTED
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
c8f0: e59d3250 ldr r3, [sp, #592] ; 0x250
c8f4: e3530000 cmp r3, #0
c8f8: 0a00022d beq d1b4 <msdos_format+0xa70>
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
c8fc: e5dd2264 ldrb r2, [sp, #612] ; 0x264
c900: e59d1244 ldr r1, [sp, #580] ; 0x244
c904: e0277291 mla r7, r1, r2, r7
fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;
c908: e58d3258 str r3, [sp, #600] ; 0x258
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
fmt_params->root_dir_start_sec =
c90c: e58d7254 str r7, [sp, #596] ; 0x254
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
}
/*
* determine usable OEMName
*/
if (ret_val == 0) {
c910: e3560000 cmp r6, #0
c914: 1a000033 bne c9e8 <msdos_format+0x2a4>
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
c918: e3540000 cmp r4, #0
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
c91c: 059f0dd0 ldreq r0, [pc, #3536] ; d6f4 <msdos_format+0xfb0>
if ((rqdata != NULL) &&
c920: 0a000003 beq c934 <msdos_format+0x1f0>
(rqdata->OEMName != NULL)) {
c924: e5940000 ldr r0, [r4]
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
c928: e59f3dc4 ldr r3, [pc, #3524] ; d6f4 <msdos_format+0xfb0>
c92c: e3500000 cmp r0, #0
c930: 01a00003 moveq r0, r3
if ((rqdata != NULL) &&
c934: e59f3dbc ldr r3, [pc, #3516] ; d6f8 <msdos_format+0xfb4>
/*
* determine usable OEMName
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
c938: e28d2f99 add r2, sp, #612 ; 0x264
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
c93c: e593e000 ldr lr, [r3]
/*
* determine usable OEMName
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
c940: e2822003 add r2, r2, #3
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
c944: e3a03008 mov r3, #8
/* * non-printable character in given name, so keep stuck * at that character and replace all following characters * with a ' ' */ *to++=' ';
c948: e3a0a020 mov sl, #32
}
*to = '\0';
c94c: e3a07000 mov r7, #0
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
c950: e5d01000 ldrb r1, [r0]
c954: e08ec001 add ip, lr, r1
c958: e5dcc001 ldrb ip, [ip, #1]
c95c: e31c0097 tst ip, #151 ; 0x97
*to++ = *from++;
c960: 14c21001 strbne r1, [r2], #1
/* * non-printable character in given name, so keep stuck * at that character and replace all following characters * with a ' ' */ *to++=' ';
c964: 04c2a001 strbeq sl, [r2], #1
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
*to++ = *from++;
c968: 12800001 addne r0, r0, #1
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
(rqdata->OEMName != NULL)) {
from = rqdata->OEMName;
}
for (cnt = 0;
c96c: e2533001 subs r3, r3, #1
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
c970: e5c27000 strb r7, [r2]
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
(rqdata->OEMName != NULL)) {
from = rqdata->OEMName;
}
for (cnt = 0;
c974: 1afffff5 bne c950 <msdos_format+0x20c>
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) &&
c978: e3540000 cmp r4, #0
c97c: 0a00030b beq d5b0 <msdos_format+0xe6c>
(rqdata->VolLabel != NULL)) {
c980: e5940004 ldr r0, [r4, #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) &&
c984: e3500000 cmp r0, #0
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
c988: 13a03001 movne r3, #1
c98c: 15cd327c strbne r3, [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) &&
c990: 0a000306 beq d5b0 <msdos_format+0xe6c>
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
c994: e3a0200b mov r2, #11
/*
* determine usable Volume Label
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
c998: e28d3e27 add r3, sp, #624 ; 0x270
/* * non-printable character in given name, so keep stuck * at that character and replace all following characters * with a ' ' */ *to++=' ';
c99c: e3a0a020 mov sl, #32
}
*to = '\0';
c9a0: e3a07000 mov r7, #0
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
c9a4: e5d01000 ldrb r1, [r0]
c9a8: e08ec001 add ip, lr, r1
c9ac: e5dcc001 ldrb ip, [ip, #1]
c9b0: e31c0097 tst ip, #151 ; 0x97
*to++ = *from++;
c9b4: 14c31001 strbne r1, [r3], #1
/* * non-printable character in given name, so keep stuck * at that character and replace all following characters * with a ' ' */ *to++=' ';
c9b8: 04c3a001 strbeq sl, [r3], #1
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
*to++ = *from++;
c9bc: 12800001 addne r0, r0, #1
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
c9c0: e2522001 subs r2, r2, #1
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
c9c4: e5c37000 strb r7, [r3]
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
c9c8: 1afffff5 bne c9a4 <msdos_format+0x260>
{
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
c9cc: e28d0e2d add r0, sp, #720 ; 0x2d0
c9d0: eb001e71 bl 1439c <rtems_clock_get_tod_timeval>
if (rc == RTEMS_SUCCESSFUL) {
c9d4: e3500000 cmp r0, #0
c9d8: 1a0002e2 bne d568 <msdos_format+0xe24>
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
c9dc: e59d32d0 ldr r3, [sp, #720] ; 0x2d0 <== NOT EXECUTED
c9e0: e1a03083 lsl r3, r3, #1 <== NOT EXECUTED
c9e4: e58d3280 str r3, [sp, #640] ; 0x280 <== NOT EXECUTED
ret_val = msdos_format_determine_fmt_params(fd,rqdata,&fmt_params);
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
c9e8: e3580000 cmp r8, #0
c9ec: 0affff7d beq c7e8 <msdos_format+0xa4>
(rqdata != NULL) &&
c9f0: e5d42015 ldrb r2, [r4, #21]
c9f4: e3520000 cmp r2, #0
c9f8: 1a000009 bne ca24 <msdos_format+0x2e0>
!(rqdata->quick_format)) {
ret_val = msdos_format_fill_sectors
c9fc: e59dc234 ldr ip, [sp, #564] ; 0x234
ca00: e1a00004 mov r0, r4
ca04: e58dc000 str ip, [sp]
ca08: e1a01005 mov r1, r5
ca0c: e3a0c0e5 mov ip, #229 ; 0xe5
ca10: e59d3238 ldr r3, [sp, #568] ; 0x238
ca14: e58dc004 str ip, [sp, #4]
ca18: ebfffec7 bl c53c <msdos_format_fill_sectors>
ca1c: e1a06000 mov r6, r0
ca20: eaffff70 b c7e8 <msdos_format+0xa4>
*/
if (ret_val == 0) {
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ca24: e1a00004 mov r0, r4
ca28: e3a01002 mov r1, #2
ca2c: e59f2cc8 ldr r2, [pc, #3272] ; d6fc <msdos_format+0xfb8>
ca30: ebfffe94 bl c488 <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)) {
ca34: e3a02000 mov r2, #0
ca38: e1a00005 mov r0, r5
ca3c: e3a01000 mov r1, #0
ca40: 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,
ca44: e59d6234 ldr r6, [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)) {
ca48: eb001c41 bl 13b54 <lseek>
ca4c: e3500000 cmp r0, #0
ca50: e2d12000 sbcs r2, r1, #0
ca54: ba0000d3 blt cda8 <msdos_format+0x664>
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
ca58: e1a00005 mov r0, r5
ca5c: e28d1034 add r1, sp, #52 ; 0x34
ca60: e1a02006 mov r2, r6
ca64: eb001d00 bl 13e6c <read>
ca68: e3500000 cmp r0, #0
ca6c: ba0000cd blt cda8 <msdos_format+0x664>
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,
ca70: e1a00004 mov r0, r4
ca74: e3a01002 mov r1, #2
ca78: e59f2c80 ldr r2, [pc, #3200] ; d700 <msdos_format+0xfbc>
ca7c: ebfffe81 bl c488 <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) {
ca80: e59d3238 ldr r3, [sp, #568] ; 0x238
ca84: e3530801 cmp r3, #65536 ; 0x10000
ca88: 3a000233 bcc d35c <msdos_format+0xc18>
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
ca8c: e1a01803 lsl r1, r3, #16
ca90: e1a02823 lsr r2, r3, #16
{
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) {
ca94: e3a07000 mov r7, #0
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
ca98: e20300ff and r0, r3, #255 ; 0xff
ca9c: e1a01c21 lsr r1, r1, #24
caa0: e20220ff and r2, r2, #255 ; 0xff
caa4: e58d0010 str r0, [sp, #16]
caa8: e58d1014 str r1, [sp, #20]
caac: e58d2018 str r2, [sp, #24]
{
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) {
cab0: e58d700c str r7, [sp, #12]
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
cab4: e1a06c23 lsr r6, r3, #24
* 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);
cab8: e3a01000 mov r1, #0
cabc: e59f2c40 ldr r2, [pc, #3136] ; d704 <msdos_format+0xfc0>
cac0: e28d0034 add r0, sp, #52 ; 0x34
cac4: eb003657 bl 1a428 <memset>
memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
cac8: e3a0a000 mov sl, #0
cacc: e28d3c02 add r3, sp, #512 ; 0x200
* with 0xEB,.... */ /* * fill OEMName */ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
cad0: e28d1f99 add r1, sp, #612 ; 0x264
cad4: e2811003 add r1, r1, #3
cad8: e3a02008 mov r2, #8
* 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,
cadc: e1c3a3b2 strh sl, [r3, #50] ; 0x32
* with 0xEB,.... */ /* * fill OEMName */ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
cae0: e28d0037 add r0, sp, #55 ; 0x37
cae4: eb003619 bl 1a350 <memcpy>
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
cae8: e59d324c ldr r3, [sp, #588] ; 0x24c
caec: e1a0c423 lsr ip, r3, #8
caf0: e5cd3045 strb r3, [sp, #69] ; 0x45
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
caf4: e59d300c ldr r3, [sp, #12]
caf8: e5cd3047 strb r3, [sp, #71] ; 0x47
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
cafc: e3e03000 mvn r3, #0
cb00: e5cd304c strb r3, [sp, #76] ; 0x4c
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
cb04: e3a03006 mov r3, #6
cb08: 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);
cb0c: e59d3010 ldr r3, [sp, #16]
* fill OEMName */ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr), fmt_params->OEMName, FAT_BR_OEMNAME_SIZE); FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
cb10: e59d1234 ldr r1, [sp, #564] ; 0x234
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);
cb14: e5cd3054 strb r3, [sp, #84] ; 0x54
cb18: e59d3014 ldr r3, [sp, #20]
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr), fmt_params->OEMName, FAT_BR_OEMNAME_SIZE); FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector); FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster); FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
cb1c: e59d223c ldr r2, [sp, #572] ; 0x23c
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
cb20: e5dd0265 ldrb r0, [sp, #613] ; 0x265
* fill OEMName */ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr), fmt_params->OEMName, FAT_BR_OEMNAME_SIZE); FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
cb24: e1a08421 lsr r8, r1, #8
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
cb28: e5ddb266 ldrb fp, [sp, #614] ; 0x266
* fill OEMName */ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr), fmt_params->OEMName, FAT_BR_OEMNAME_SIZE); FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
cb2c: e5cd103f strb r1, [sp, #63] ; 0x3f
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
cb30: e59d1240 ldr r1, [sp, #576] ; 0x240
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);
cb34: e5cd3055 strb r3, [sp, #85] ; 0x55
cb38: e59d3018 ldr r3, [sp, #24]
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr), fmt_params->OEMName, FAT_BR_OEMNAME_SIZE); FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector); FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster); FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
cb3c: e1a0e422 lsr lr, r2, #8
*/ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr), fmt_params->OEMName, FAT_BR_OEMNAME_SIZE); FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector); FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
cb40: e5cd1041 strb r1, [sp, #65] ; 0x41
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
cb44: e5cd0049 strb r0, [sp, #73] ; 0x49
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 */
cb48: 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... */
cb4c: e3a00001 mov r0, #1
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
cb50: e35b0004 cmp fp, #4
* 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,
cb54: e1a0900a mov r9, sl
* fill OEMName */ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr), fmt_params->OEMName, FAT_BR_OEMNAME_SIZE); FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
cb58: e5cd8040 strb r8, [sp, #64] ; 0x40
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster); FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
cb5c: e5cd2042 strb r2, [sp, #66] ; 0x42
cb60: e5cde043 strb lr, [sp, #67] ; 0x43
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
cb64: e5cd1044 strb r1, [sp, #68] ; 0x44
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
cb68: e5cdc046 strb ip, [sp, #70] ; 0x46
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
cb6c: e5cd7048 strb r7, [sp, #72] ; 0x48
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... */
cb70: e5cd0050 strb r0, [sp, #80] ; 0x50
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
cb74: e5cd3056 strb r3, [sp, #86] ; 0x56
cb78: e5cd6057 strb r6, [sp, #87] ; 0x57
if (fmt_params->fattype != FAT_FAT32) {
cb7c: 0a000290 beq d5c4 <msdos_format+0xe80>
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 */
cb80: e59d3280 ldr r3, [sp, #640] ; 0x280
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
cb84: e59dc244 ldr ip, [sp, #580] ; 0x244
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 */
cb88: e1a06423 lsr r6, r3, #8
cb8c: e1a0e823 lsr lr, r3, #16
cb90: e1a08c23 lsr r8, r3, #24
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
cb94: e1a0742c lsr r7, ip, #8
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
cb98: e28d1e27 add r1, sp, #624 ; 0x270
cb9c: e3a0200b mov r2, #11
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
cba0: e5cdc04a strb ip, [sp, #74] ; 0x4a
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
cba4: e28d005f add r0, sp, #95 ; 0x5f
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
cba8: e3a0c029 mov ip, #41 ; 0x29
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
cbac: e5cd305b strb r3, [sp, #91] ; 0x5b
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
cbb0: e5cd704b strb r7, [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);
cbb4: e5cdc05a strb ip, [sp, #90] ; 0x5a
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
cbb8: e5cd605c strb r6, [sp, #92] ; 0x5c
cbbc: e5cde05d strb lr, [sp, #93] ; 0x5d
cbc0: e5cd805e strb r8, [sp, #94] ; 0x5e
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
cbc4: eb0035e1 bl 1a350 <memcpy>
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
cbc8: e59f3b38 ldr r3, [pc, #2872] ; d708 <msdos_format+0xfc4>
cbcc: e35b0001 cmp fp, #1
cbd0: e59f1b34 ldr r1, [pc, #2868] ; d70c <msdos_format+0xfc8>
cbd4: e28d006a add r0, sp, #106 ; 0x6a
cbd8: 01a01003 moveq r1, r3
cbdc: e3a02008 mov r2, #8
cbe0: eb0035da bl 1a350 <memcpy>
FAT_BR_FILSYSTYPE_SIZE); } /* * add boot record signature */ FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
cbe4: e3a03055 mov r3, #85 ; 0x55
cbe8: e5cd3232 strb r3, [sp, #562] ; 0x232
cbec: e3e03055 mvn r3, #85 ; 0x55
cbf0: e5cd3233 strb r3, [sp, #563] ; 0x233
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
cbf4: e3e03014 mvn r3, #20
cbf8: e5cd3034 strb r3, [sp, #52] ; 0x34
FAT_SET_VAL8(mbr,1,0x3c);
cbfc: e3a0303c mov r3, #60 ; 0x3c
/*
* 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,
cc00: e3a01002 mov r1, #2
cc04: e59f2b04 ldr r2, [pc, #2820] ; d710 <msdos_format+0xfcc>
cc08: e1a00004 mov r0, r4
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
FAT_SET_VAL8(mbr,1,0x3c);
cc0c: e5cd3035 strb r3, [sp, #53] ; 0x35
FAT_SET_VAL8(mbr,2,0x90);
cc10: e3e0306f mvn r3, #111 ; 0x6f
cc14: 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,
cc18: ebfffe1a bl c488 <msdos_format_printf>
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
cc1c: e1a00005 mov r0, r5
cc20: e3a01000 mov r1, #0
cc24: e59d2234 ldr r2, [sp, #564] ; 0x234
cc28: e28d3034 add r3, sp, #52 ; 0x34
cc2c: ebfffe2c bl c4e4 <msdos_format_write_sec>
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
cc30: e2506000 subs r6, r0, #0
cc34: 1afffeed bne c7f0 <msdos_format+0xac>
cc38: e59d325c ldr r3, [sp, #604] ; 0x25c
cc3c: e3530000 cmp r3, #0
cc40: 1a00024b bne d574 <msdos_format+0xe30>
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
cc44: e59d6260 ldr r6, [sp, #608] ; 0x260
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
cc48: e3560000 cmp r6, #0
cc4c: 1a0001e6 bne d3ec <msdos_format+0xca8>
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
cc50: e59dc244 ldr ip, [sp, #580] ; 0x244
(rqdata,
cc54: 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
cc58: e003039c mul r3, ip, r3
cc5c: e59dc234 ldr ip, [sp, #564] ; 0x234
cc60: e1a00004 mov r0, r4
cc64: e58dc000 str ip, [sp]
cc68: e1a01005 mov r1, r5
cc6c: e3a0c000 mov ip, #0
cc70: e59d223c ldr r2, [sp, #572] ; 0x23c
cc74: e58dc004 str ip, [sp, #4]
cc78: ebfffe2f bl c53c <msdos_format_fill_sectors>
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
cc7c: e2506000 subs r6, r0, #0
cc80: 1afffeda bne c7f0 <msdos_format+0xac>
ret_val = msdos_format_fill_sectors
cc84: e59dc234 ldr ip, [sp, #564] ; 0x234
cc88: e28d2f95 add r2, sp, #596 ; 0x254
cc8c: e892000c ldm r2, {r2, r3}
cc90: e1a00004 mov r0, r4
cc94: e1a01005 mov r1, r5
cc98: e58d6004 str r6, [sp, #4]
cc9c: e58dc000 str ip, [sp]
cca0: ebfffe25 bl c53c <msdos_format_fill_sectors>
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
cca4: e2506000 subs r6, r0, #0
cca8: 1afffed0 bne c7f0 <msdos_format+0xac>
ccac: e5dd327c ldrb r3, [sp, #636] ; 0x27c
ccb0: e3530000 cmp r3, #0
ccb4: 1a0001b6 bne d394 <msdos_format+0xc50>
uint32_t start_sector;
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
ccb8: e28d0034 add r0, sp, #52 ; 0x34
ccbc: e3a01000 mov r1, #0
ccc0: e3a02c02 mov r2, #512 ; 0x200
ccc4: eb0035d7 bl 1a428 <memset>
switch(fmt_params.fattype) {
ccc8: e5dd3266 ldrb r3, [sp, #614] ; 0x266
cccc: e3530002 cmp r3, #2
ccd0: 0a000203 beq d4e4 <msdos_format+0xda0>
ccd4: e3530004 cmp r3, #4
ccd8: 0a0001e8 beq d480 <msdos_format+0xd3c>
ccdc: e3530001 cmp r3, #1
cce0: 0a00020c beq d518 <msdos_format+0xdd4>
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
errno = EINVAL;
cce4: eb0032f2 bl 198b4 <__errno> <== NOT EXECUTED
cce8: e3a03016 mov r3, #22 <== NOT EXECUTED
ccec: e5803000 str r3, [r0] <== NOT EXECUTED
}
if (fmt_params.fattype == FAT_FAT32) {
ccf0: e5dd3266 ldrb r3, [sp, #614] ; 0x266 <== NOT EXECUTED
ccf4: e3530004 cmp r3, #4 <== NOT EXECUTED
ccf8: e3a03000 mov r3, #0 <== NOT EXECUTED
ccfc: e1a02003 mov r2, r3 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
cd00: e3e00000 mvn r0, #0 <== NOT EXECUTED
errno = EINVAL;
}
if (fmt_params.fattype == FAT_FAT32) {
cd04: 0a0001ee beq d4c4 <msdos_format+0xd80> <== NOT EXECUTED
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
cd08: e5dd1284 ldrb r1, [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,
cd0c: e59d823c ldr r8, [sp, #572] ; 0x23c
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
cd10: e3510000 cmp r1, #0
* 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,
cd14: e59d1240 ldr r1, [sp, #576] ; 0x240
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
cd18: 00888001 addeq r8, r8, r1
cd1c: 02488001 subeq r8, r8, #1
cd20: 02611000 rsbeq r1, r1, #0
cd24: 00088001 andeq r8, r8, r1
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
cd28: e3530000 cmp r3, #0
cd2c: 0a000221 beq d5b8 <msdos_format+0xe74>
cd30: e59d1244 ldr r1, [sp, #580] ; 0x244
cd34: e3a07000 mov r7, #0
cd38: ea000000 b cd40 <msdos_format+0x5fc>
cd3c: e59d1244 ldr r1, [sp, #580] ; 0x244
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
cd40: e0218197 mla r1, r7, r1, r8
cd44: e59d2234 ldr r2, [sp, #564] ; 0x234
cd48: e28d3034 add r3, sp, #52 ; 0x34
cd4c: e1a00005 mov r0, r5
cd50: ebfffde3 bl c4e4 <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);
cd54: e5dd3264 ldrb r3, [sp, #612] ; 0x264
cd58: e2702001 rsbs r2, r0, #1
cd5c: 33a02000 movcc r2, #0
i++) {
cd60: e2877001 add r7, r7, #1
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
cd64: e1530007 cmp r3, r7
cd68: d3a03000 movle r3, #0
cd6c: c2023001 andgt r3, r2, #1
cd70: e3530000 cmp r3, #0
cd74: 1afffff0 bne cd3c <msdos_format+0x5f8>
cd78: e59d3020 ldr r3, [sp, #32]
cd7c: e0022003 and r2, r2, r3
fmt_params.bytes_per_sector,
tmp_sec);
}
}
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
cd80: e3520000 cmp r2, #0
cd84: 0a000196 beq d3e4 <msdos_format+0xca0>
cd88: e5d43017 ldrb r3, [r4, #23]
cd8c: e3530000 cmp r3, #0
cd90: 0afffe96 beq c7f0 <msdos_format+0xac>
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
}
static inline int rtems_disk_fd_sync(int fd)
{
return ioctl(fd, RTEMS_BLKIO_SYNCDEV);
cd94: e1a00005 mov r0, r5
cd98: e59f1974 ldr r1, [pc, #2420] ; d714 <msdos_format+0xfd0>
cd9c: eb001b4c bl 13ad4 <ioctl>
cda0: e1a06000 mov r6, r0
cda4: eafffe91 b c7f0 <msdos_format+0xac>
/*
* 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) {
cda8: e3e06000 mvn r6, #0 <== NOT EXECUTED
cdac: eafffe8f b c7f0 <msdos_format+0xac> <== NOT EXECUTED
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
cdb0: e3a01002 mov r1, #2 <== NOT EXECUTED
cdb4: e59f2928 ldr r2, [pc, #2344] ; d6e4 <msdos_format+0xfa0> <== NOT EXECUTED
cdb8: e1a03007 mov r3, r7 <== NOT EXECUTED
cdbc: e1a00004 mov r0, r4 <== NOT EXECUTED
cdc0: ebfffdb0 bl c488 <msdos_format_printf> <== NOT EXECUTED
"stat check: %s\n", devname);
if (ret_val == 0) {
ret_val = fstat(fd, &stat_buf);
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
cdc4: e1a00004 mov r0, r4 <== NOT EXECUTED
cdc8: e3a01001 mov r1, #1 <== NOT EXECUTED
cdcc: e59f2914 ldr r2, [pc, #2324] ; d6e8 <msdos_format+0xfa4> <== NOT EXECUTED
cdd0: e1a03007 mov r3, r7 <== NOT EXECUTED
cdd4: ebfffdab bl c488 <msdos_format_printf> <== NOT EXECUTED
cdd8: e1a06005 mov r6, r5 <== NOT EXECUTED
cddc: eafffe7e b c7dc <msdos_format+0x98> <== 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);
cde0: e1a00005 mov r0, r5
cde4: e59f192c ldr r1, [pc, #2348] ; d718 <msdos_format+0xfd4>
cde8: e28d2f8e add r2, sp, #568 ; 0x238
cdec: eb001b38 bl 13ad4 <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) {
cdf0: e2506000 subs r6, r0, #0
cdf4: 1afffe8d bne c830 <msdos_format+0xec>
total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
cdf8: e28d3f8d add r3, sp, #564 ; 0x234
cdfc: e8931008 ldm r3, {r3, ip}
ce00: e0020c93 mul r2, r3, ip
ce04: e3a09000 mov r9, #0
ce08: e1a08002 mov r8, r2
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ce0c: e1a00004 mov r0, r4
ce10: e3a01002 mov r1, #2
ce14: e59f2900 ldr r2, [pc, #2304] ; d71c <msdos_format+0xfd8>
ce18: e58dc000 str ip, [sp]
ce1c: e98d0300 stmib sp, {r8, r9}
ce20: ebfffd98 bl c488 <msdos_format_printf>
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
ce24: e1540009 cmp r4, r9
ce28: 0a00020d beq d664 <msdos_format+0xf20>
(rqdata->fat_num == 0)) {
ce2c: e594c00c ldr ip, [r4, #12]
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
ce30: e15c0009 cmp ip, r9
ce34: 1a00013e bne d334 <msdos_format+0xbf0>
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
ce38: e3a0c002 mov ip, #2
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ce3c: e1a0100c mov r1, ip
ce40: e1a00004 mov r0, r4
ce44: e59f28d4 ldr r2, [pc, #2260] ; d720 <msdos_format+0xfdc>
ce48: e1a0300c mov r3, ip
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
ce4c: e5cdc264 strb ip, [sp, #612] ; 0x264
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ce50: ebfffd8c bl c488 <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) {
ce54: e5943008 ldr r3, [r4, #8]
ce58: e3530000 cmp r3, #0
ce5c: 10631403 rsbne r1, r3, r3, lsl #8
ce60: 10831101 addne r1, r3, r1, lsl #2
ce64: 059f18b8 ldreq r1, [pc, #2232] ; d724 <msdos_format+0xfe0>
ce68: 10831101 addne r1, r3, r1, lsl #2
* 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;
ce6c: 03a03020 moveq r3, #32
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) {
ce70: e59d2238 ldr r2, [sp, #568] ; 0x238
ce74: e1520001 cmp r2, r1
ce78: 2a000113 bcs d2cc <msdos_format+0xb88>
fmt_params->fattype = FAT_FAT12;
ce7c: e3a03001 mov r3, #1
ce80: e5cd3266 strb r3, [sp, #614] ; 0x266
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
ce84: e3a03002 mov r3, #2
ce88: e58d3240 str r3, [sp, #576] ; 0x240
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 );
ce8c: e1a00004 mov r0, r4
ce90: e28d1f8d add r1, sp, #564 ; 0x234
ce94: ebfffe0b bl c6c8 <msdos_set_sectors_per_cluster_from_request>
if (ret_val == 0) {
data_clusters_cnt =
fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
}
while( ret_val == 0
ce98: e2506000 subs r6, r0, #0
ce9c: 1a0001fa bne d68c <msdos_format+0xf48>
&& fmt_params->fattype != fat_type
cea0: e5dd3266 ldrb r3, [sp, #614] ; 0x266
cea4: e35300ff cmp r3, #255 ; 0xff
cea8: 0a0001fc beq d6a0 <msdos_format+0xf5c>
&& fmt_params->totl_sector_cnt > 0 ) {
ceac: e59d3238 ldr r3, [sp, #568] ; 0x238
ceb0: e3530000 cmp r3, #0
ceb4: 0a0001fe beq d6b4 <msdos_format+0xf70>
/* 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;
ceb8: e3a02101 mov r2, #1073741824 ; 0x40000000
cebc: e0922008 adds r2, r2, r8
cec0: e3a03000 mov r3, #0
cec4: e0a33009 adc r3, r3, r9
cec8: e1a02f22 lsr r2, r2, #30
fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
}
while( ret_val == 0
&& fmt_params->fattype != fat_type
&& fmt_params->totl_sector_cnt > 0 ) {
cecc: e2940000 adds r0, r4, #0
ced0: 13a00001 movne r0, #1
/* 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;
ced4: e1822103 orr r2, r2, r3, lsl #2
fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
}
while( ret_val == 0
&& fmt_params->fattype != fat_type
&& fmt_params->totl_sector_cnt > 0 ) {
ced8: e58d0020 str r0, [sp, #32]
/* 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;
cedc: e58d2030 str r2, [sp, #48] ; 0x30
cee0: e58d6018 str r6, [sp, #24]
cee4: e58d502c str r5, [sp, #44] ; 0x2c
cee8: e58d4024 str r4, [sp, #36] ; 0x24
&& fmt_params->fattype != fat_type
&& fmt_params->totl_sector_cnt > 0 ) {
/*
* Skip aligning structures or d align them
*/
if (ret_val == 0 && rqdata != NULL)
ceec: e59d1020 ldr r1, [sp, #32]
cef0: e3510000 cmp r1, #0
fmt_params->skip_alignment = rqdata->skip_alignment;
cef4: 159d2024 ldrne r2, [sp, #36] ; 0x24
cef8: 15d23016 ldrbne r3, [r2, #22]
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
cefc: e59d0024 ldr r0, [sp, #36] ; 0x24
&& 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;
cf00: 15cd3284 strbne r3, [sp, #644] ; 0x284
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
cf04: e3a01002 mov r1, #2
cf08: e59f2818 ldr r2, [pc, #2072] ; d728 <msdos_format+0xfe4>
cf0c: e59d3240 ldr r3, [sp, #576] ; 0x240
cf10: ebfffd5c bl c488 <msdos_format_printf>
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
cf14: e5dd5266 ldrb r5, [sp, #614] ; 0x266
cf18: e3550004 cmp r5, #4
cf1c: 0a0000da beq d28c <msdos_format+0xb48>
/* 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) &&
cf20: e59d3020 ldr r3, [sp, #32]
cf24: e3530000 cmp r3, #0
fmt_params->fsinfo_sec = 1;
}
else {
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
cf28: e3a03001 mov r3, #1
cf2c: e58d323c str r3, [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) &&
cf30: 0a000004 beq cf48 <msdos_format+0x804>
(rqdata->files_per_root_dir > 0)) {
cf34: e59d0024 ldr r0, [sp, #36] ; 0x24
cf38: e5904010 ldr r4, [r0, #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) &&
cf3c: e3540000 cmp r4, #0
cf40: 12444001 subne r4, r4, #1
cf44: 1a000002 bne cf54 <msdos_format+0x810>
(rqdata->files_per_root_dir > 0)) {
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
}
else {
if (fmt_params->fattype == FAT_FAT16) {
cf48: e3550002 cmp r5, #2
cf4c: e59f47d8 ldr r4, [pc, #2008] ; d72c <msdos_format+0xfe8>
cf50: 13a0403f movne r4, #63 ; 0x3f
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
(2*fmt_params->bytes_per_sector/
cf54: e59d8234 ldr r8, [sp, #564] ; 0x234
cf58: e1a01088 lsl r1, r8, #1
cf5c: 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 +
cf60: e0844001 add r4, r4, r1
(2*fmt_params->bytes_per_sector/
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
cf64: e1a00004 mov r0, r4
cf68: ebffd3ba bl 1e58 <__umodsi3>
cf6c: e3a02001 mov r2, #1
cf70: e0600004 rsb r0, r0, r4
cf74: e58d2010 str r2, [sp, #16]
cf78: e58d024c str r0, [sp, #588] ; 0x24c
cf7c: e1a00280 lsl r0, r0, #5
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
cf80: e248b001 sub fp, r8, #1
/ fmt_params->bytes_per_sector);
cf84: e1a01008 mov r1, r8
cf88: e08b0000 add r0, fp, r0
cf8c: ebffd36b bl 1d40 <__aeabi_uidiv>
cf90: e58d0014 str r0, [sp, #20]
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 =
cf94: e59d3014 ldr r3, [sp, #20]
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) {
cf98: e3a00902 mov r0, #32768 ; 0x8000
cf9c: e1a01008 mov r1, r8
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 =
cfa0: e58d3250 str r3, [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) {
cfa4: ebffd365 bl 1d40 <__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,
cfa8: e59d4240 ldr r4, [sp, #576] ; 0x240
fmt_params->bytes_per_sector,
fmt_params->totl_sector_cnt,
fmt_params->rsvd_sector_cnt,
fmt_params->root_dir_sectors,
fmt_params->fat_num,
cfac: e5dd2264 ldrb r2, [sp, #612] ; 0x264
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) {
cfb0: e1540000 cmp r4, r0
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,
cfb4: e59d9238 ldr r9, [sp, #568] ; 0x238
fmt_params->bytes_per_sector,
fmt_params->totl_sector_cnt,
fmt_params->rsvd_sector_cnt,
fmt_params->root_dir_sectors,
fmt_params->fat_num,
cfb8: e58d200c str r2, [sp, #12]
fmt_params->sectors_per_cluster,
fmt_params->skip_alignment,
cfbc: e5dda284 ldrb sl, [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) {
cfc0: 9a000002 bls cfd0 <msdos_format+0x88c>
sectors_per_cluster /= 2;
cfc4: e1a040a4 lsr r4, r4, #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) {
cfc8: e1540000 cmp r4, r0 <== NOT EXECUTED
cfcc: 8afffffc bhi cfc4 <msdos_format+0x880> <== NOT EXECUTED
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
cfd0: e59d3010 ldr r3, [sp, #16]
cfd4: e59d2014 ldr r2, [sp, #20]
cfd8: e2433001 sub r3, r3, #1
cfdc: e2422001 sub r2, r2, #1
cfe0: e58d301c str r3, [sp, #28]
cfe4: e58d2028 str r2, [sp, #40] ; 0x28
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
cfe8: e35a0000 cmp sl, #0
return (sectors + clustersize - 1) & ~(clustersize - 1);
cfec: 059d201c ldreq r2, [sp, #28]
cff0: 02640000 rsbeq r0, r4, #0
cff4: 00823004 addeq r3, r2, r4
else
return sectors;
cff8: 159d0010 ldrne r0, [sp, #16]
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
cffc: 00000003 andeq r0, r0, r3
* - compute storage size for FAT
* - subtract from total cluster count
*/
fatdata_sect_cnt = total_sector_cnt
- loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
if (fattype == FAT_FAT12) {
d000: e3550001 cmp r5, #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
d004: e0600009 rsb r0, r0, r9
- loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
if (fattype == FAT_FAT12) {
d008: 0a000086 beq d228 <msdos_format+0xae4>
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;
fat_capacity = fatdata_cluster_cnt * 3 / 2;
}
else if (fattype == FAT_FAT16) {
d00c: e3550002 cmp r5, #2
d010: 0a000091 beq d25c <msdos_format+0xb18>
- loc_align_object (root_dir_sector_cnt, sectors_per_cluster, skip_alignment);
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
fat_capacity = fatdata_cluster_cnt * 2;
}
else { /* FAT32 */
fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;
d014: e1a01004 mov r1, r4
d018: ebffd348 bl 1d40 <__aeabi_uidiv>
d01c: e1a06000 mov r6, r0
fat_capacity = fatdata_cluster_cnt * 4;
d020: e1a00100 lsl r0, r0, #2
}
sectors_per_fat = ((fat_capacity
d024: e1a01008 mov r1, r8
d028: e080000b add r0, r0, fp
d02c: ebffd343 bl 1d40 <__aeabi_uidiv>
+ (bytes_per_sector - 1))
/ bytes_per_sector);
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
d030: e59d300c ldr r3, [sp, #12]
d034: e0070093 mul r7, r3, r0
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
d038: e35a0000 cmp sl, #0
return (sectors + clustersize - 1) & ~(clustersize - 1);
d03c: e2440001 sub r0, r4, #1
d040: 00877000 addeq r7, r7, r0
d044: 02643000 rsbeq r3, r4, #0
d048: 00077003 andeq r7, r7, r3
skip_alignment);
*data_cluster_cnt = (fatdata_cluster_cnt -
((fat_sectors_cnt
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
d04c: e0800007 add r0, r0, r7
d050: e1a01004 mov r1, r4
d054: ebffd339 bl 1d40 <__aeabi_uidiv>
/*
* data cluster count too big? Then make clusters bigger
*/
if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
d058: e3550001 cmp r5, #1
fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,
sectors_per_cluster,
skip_alignment);
*data_cluster_cnt = (fatdata_cluster_cnt -
d05c: e0606006 rsb r6, r0, r6
+ (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)) ||
d060: 0a000065 beq d1fc <msdos_format+0xab8>
d064: e3550002 cmp r5, #2
d068: 0a000058 beq d1d0 <msdos_format+0xa8c>
*/
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)
d06c: e0020498 mul r2, r8, r4
d070: e3520902 cmp r2, #32768 ; 0x8000
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;
d074: 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)
d078: 9a00005c bls d1f0 <msdos_format+0xaac>
finished = true;
}
} while (!finished);
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
d07c: e59d100c ldr r1, [sp, #12]
d080: e1a00007 mov r0, r7
d084: ebffd32d bl 1d40 <__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 =
d088: e1a01008 mov r1, r8
finished = true;
}
} while (!finished);
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = fat_sectors_cnt / fat_num;
d08c: 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 =
d090: e59f0698 ldr r0, [pc, #1688] ; d730 <msdos_format+0xfec>
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;
d094: e58d4240 str r4, [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 =
d098: ebffd328 bl 1d40 <__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
d09c: e59f3690 ldr r3, [pc, #1680] ; d734 <msdos_format+0xff0>
d0a0: e1500004 cmp r0, r4
d0a4: 33a00000 movcc r0, #0
d0a8: 23a00001 movcs r0, #1
d0ac: e1560003 cmp r6, r3
d0b0: 83a00000 movhi r0, #0
d0b4: e3500000 cmp r0, #0
&& sectors_per_cluster <= ms_sectors_per_cluster_limit_FAT12 ) {
fattype = FAT_FAT12;
d0b8: 13a04001 movne r4, #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
d0bc: 1a00000b bne d0f0 <msdos_format+0x9ac>
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 =
d0c0: e59f0670 ldr r0, [pc, #1648] ; d738 <msdos_format+0xff4>
d0c4: e1a01008 mov r1, r8
d0c8: ebffd31c bl 1d40 <__aeabi_uidiv>
if ( number_of_clusters < FAT_FAT12_MAX_CLN
&& sectors_per_cluster <= ms_sectors_per_cluster_limit_FAT12 ) {
fattype = FAT_FAT12;
}
else if ( number_of_clusters < FAT_FAT16_MAX_CLN
d0cc: e59f3668 ldr r3, [pc, #1640] ; d73c <msdos_format+0xff8>
d0d0: e1500004 cmp r0, r4
d0d4: 33a04000 movcc r4, #0
d0d8: 23a04001 movcs r4, #1
d0dc: e1560003 cmp r6, r3
d0e0: 83a04000 movhi r4, #0
{
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 =
( MS_BYTES_PER_CLUSTER_LIMIT +1 ) / bytes_per_sector;
uint8_t fattype = FAT_FAT32;
d0e4: e3540000 cmp r4, #0
d0e8: 13a04002 movne r4, #2
d0ec: 03a04004 moveq r4, #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) {
d0f0: e1550004 cmp r5, r4
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(
d0f4: e5cd4266 strb r4, [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) {
d0f8: 0a000116 beq d558 <msdos_format+0xe14>
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
d0fc: e2444001 sub r4, r4, #1
d100: e3540001 cmp r4, #1
|| fmt_params->fattype == FAT_FAT16 ) {
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
d104: 93a03002 movls r3, #2
d108: 958d3240 strls r3, [sp, #576] ; 0x240
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
d10c: 9a000009 bls d138 <msdos_format+0x9f4>
d110: 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 )
d114: e3a01001 mov r1, #1
d118: e59d0030 ldr r0, [sp, #48] ; 0x30
d11c: ea000001 b d128 <msdos_format+0x9e4>
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-- ) {
d120: e2533001 subs r3, r3, #1
d124: 0a000105 beq d540 <msdos_format+0xdfc>
if ( (gigs & ( 1 << b) ) != 0 )
d128: e1a02311 lsl r2, r1, r3
d12c: e1120000 tst r2, r0
d130: 0afffffa beq d120 <msdos_format+0x9dc>
break;
}
fmt_params->sectors_per_cluster = 1 << b;
d134: e58d2240 str r2, [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,
d138: e28d1f8d add r1, sp, #564 ; 0x234
d13c: e59d0024 ldr r0, [sp, #36] ; 0x24
d140: ebfffd60 bl c6c8 <msdos_set_sectors_per_cluster_from_request>
fmt_params );
}
}
if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {
d144: e59d3018 ldr r3, [sp, #24]
d148: e5dd2266 ldrb r2, [sp, #614] ; 0x266
--fmt_params->totl_sector_cnt;
d14c: e59d9238 ldr r9, [sp, #568] ; 0x238
}
}
++iteration_cnt;
d150: e59d1018 ldr r1, [sp, #24]
total_size );
ret_val = msdos_set_sectors_per_cluster_from_request( rqdata,
fmt_params );
}
}
if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {
d154: e1520005 cmp r2, r5
d158: 13530001 cmpne r3, #1
--fmt_params->totl_sector_cnt;
d15c: 82499001 subhi r9, r9, #1
}
}
++iteration_cnt;
d160: e2813001 add r3, r1, #1
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;
d164: 858d9238 strhi r9, [sp, #568] ; 0x238
}
}
++iteration_cnt;
d168: e20330ff and r3, r3, #255 ; 0xff
if (ret_val == 0) {
data_clusters_cnt =
fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
}
while( ret_val == 0
d16c: e3500000 cmp r0, #0
--fmt_params->totl_sector_cnt;
}
}
++iteration_cnt;
d170: e58d3018 str r3, [sp, #24]
if (ret_val == 0) {
data_clusters_cnt =
fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
}
while( ret_val == 0
d174: 1a0000f3 bne d548 <msdos_format+0xe04>
&& fmt_params->fattype != fat_type
d178: e1520005 cmp r2, r5
d17c: 0a0000f5 beq d558 <msdos_format+0xe14>
&& fmt_params->totl_sector_cnt > 0 ) {
d180: e3590000 cmp r9, #0
d184: 1affff58 bne ceec <msdos_format+0x7a8>
d188: e59d502c ldr r5, [sp, #44] ; 0x2c <== NOT EXECUTED
d18c: e59d4024 ldr r4, [sp, #36] ; 0x24 <== NOT EXECUTED
++iteration_cnt;
}
}
if ( fmt_params->totl_sector_cnt == 0 )
{
errno = EINVAL;
d190: eb0031c7 bl 198b4 <__errno> <== NOT EXECUTED
d194: e3a03016 mov r3, #22 <== NOT EXECUTED
d198: e5803000 str r3, [r0] <== NOT EXECUTED
ret_val = -1;
d19c: e3e06000 mvn r6, #0 <== NOT EXECUTED
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
d1a0: e59d3250 ldr r3, [sp, #592] ; 0x250
d1a4: e3530000 cmp r3, #0
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
d1a8: e59d723c ldr r7, [sp, #572] ; 0x23c
}
}
if ( fmt_params->totl_sector_cnt == 0 )
{
errno = EINVAL;
ret_val = -1;
d1ac: e3a08000 mov r8, #0
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
d1b0: 1afffdd1 bne c8fc <msdos_format+0x1b8>
/*
* 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);
d1b4: e5dd3264 ldrb r3, [sp, #612] ; 0x264
d1b8: e59d2244 ldr r2, [sp, #580] ; 0x244
d1bc: e0277392 mla r7, r2, r3, r7
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
d1c0: e59d3240 ldr r3, [sp, #576] ; 0x240
}
else {
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
d1c4: e58d7254 str r7, [sp, #596] ; 0x254
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;
d1c8: e58d3258 str r3, [sp, #600] ; 0x258
d1cc: eafffdcf b c910 <msdos_format+0x1cc>
/ sectors_per_cluster));
/*
* 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))) {
d1d0: e59f1568 ldr r1, [pc, #1384] ; d740 <msdos_format+0xffc>
d1d4: e1560001 cmp r6, r1
sectors_per_cluster *= 2;
d1d8: 81a04084 lslhi r4, r4, #1
d1dc: 83a03000 movhi r3, #0
/ sectors_per_cluster));
/*
* 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))) {
d1e0: 9affffa1 bls d06c <msdos_format+0x928>
*/
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)
d1e4: e0020498 mul r2, r8, r4
d1e8: e3520902 cmp r2, #32768 ; 0x8000
d1ec: 8affffa2 bhi d07c <msdos_format+0x938>
> MS_BYTES_PER_CLUSTER_LIMIT) {
finished = true;
}
} while (!finished);
d1f0: e3530000 cmp r3, #0
d1f4: 0affff7b beq cfe8 <msdos_format+0x8a4>
d1f8: eaffff9f b d07c <msdos_format+0x938>
+ (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)) ||
d1fc: e59f0540 ldr r0, [pc, #1344] ; d744 <msdos_format+0x1000>
d200: e1560000 cmp r6, r0
((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
}
else {
finished = true;
d204: 91a03005 movls r3, r5
/*
* 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;
d208: 81a04084 lslhi r4, r4, #1
d20c: 83a03000 movhi r3, #0
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if (fattype == FAT_FAT12) {
if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
d210: e0020498 mul r2, r8, r4
d214: e3520a01 cmp r2, #4096 ; 0x1000
d218: 8affff97 bhi d07c <msdos_format+0x938>
}
} else if ((sectors_per_cluster * bytes_per_sector)
> MS_BYTES_PER_CLUSTER_LIMIT) {
finished = true;
}
} while (!finished);
d21c: e3530000 cmp r3, #0
d220: 0affff70 beq cfe8 <msdos_format+0x8a4>
d224: eaffff94 b d07c <msdos_format+0x938>
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
d228: e35a0000 cmp sl, #0
return (sectors + clustersize - 1) & ~(clustersize - 1);
d22c: 059d2028 ldreq r2, [sp, #40] ; 0x28
else
return sectors;
d230: 159d3014 ldrne r3, [sp, #20]
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
d234: 00823004 addeq r3, r2, r4
d238: 02642000 rsbeq r2, r4, #0
d23c: 00023003 andeq r3, r2, r3
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;
d240: e0630000 rsb r0, r3, r0
d244: e1a01004 mov r1, r4
d248: ebffd2bc bl 1d40 <__aeabi_uidiv>
d24c: e1a06000 mov r6, r0
fat_capacity = fatdata_cluster_cnt * 3 / 2;
d250: e0800080 add r0, r0, r0, lsl #1
d254: e1a000a0 lsr r0, r0, #1
d258: eaffff71 b d024 <msdos_format+0x8e0>
static uint32_t
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
d25c: e35a0000 cmp sl, #0
return (sectors + clustersize - 1) & ~(clustersize - 1);
d260: 059d2028 ldreq r2, [sp, #40] ; 0x28
else
return sectors;
d264: 159d3014 ldrne r3, [sp, #20]
loc_align_object (const uint32_t sectors,
const uint32_t clustersize,
const bool skip_alignment)
{
if (! skip_alignment)
return (sectors + clustersize - 1) & ~(clustersize - 1);
d268: 00823004 addeq r3, r2, r4
d26c: 02642000 rsbeq r2, r4, #0
d270: 00023003 andeq r3, r2, r3
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;
d274: e0630000 rsb r0, r3, r0
d278: e1a01004 mov r1, r4
d27c: ebffd2af bl 1d40 <__aeabi_uidiv>
d280: e1a06000 mov r6, r0
fat_capacity = fatdata_cluster_cnt * 2;
d284: e1a00080 lsl r0, r0, #1
d288: eaffff65 b d024 <msdos_format+0x8e0>
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
d28c: e3a02006 mov r2, #6
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
d290: e3a03020 mov r3, #32
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
d294: e3a00000 mov r0, #0
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
d298: e58d225c str r2, [sp, #604] ; 0x25c
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
d29c: e3a02001 mov r2, #1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
d2a0: e58d323c str r3, [sp, #572] ; 0x23c
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
d2a4: e58d024c str r0, [sp, #588] ; 0x24c
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
d2a8: e58d2260 str r2, [sp, #608] ; 0x260
d2ac: e59d8234 ldr r8, [sp, #564] ; 0x234
d2b0: e58d3010 str r3, [sp, #16]
d2b4: eaffff31 b cf80 <msdos_format+0x83c>
else {
fmt_params->media_code = rqdata->media;
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
d2b8: e59d0020 ldr r0, [sp, #32]
d2bc: e3e03007 mvn r3, #7
d2c0: e5cd3265 strb r3, [sp, #613] ; 0x265
d2c4: e2008001 and r8, r0, #1
d2c8: eafffd88 b c8f0 <msdos_format+0x1ac>
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) {
d2cc: e0631603 rsb r1, r3, r3, lsl #12
d2d0: e0831101 add r1, r3, r1, lsl #2
d2d4: e0833101 add r3, r3, r1, lsl #2
d2d8: e1520003 cmp r2, r3
fmt_params->fattype = FAT_FAT16;
d2dc: 33a03002 movcc r3, #2
d2e0: 35cd3266 strbcc r3, [sp, #614] ; 0x266
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
d2e4: 358d3240 strcc r3, [sp, #576] ; 0x240
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) {
d2e8: 3afffee7 bcc ce8c <msdos_format+0x748>
/* 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;
d2ec: e3a02101 mov r2, #1073741824 ; 0x40000000
d2f0: e0922008 adds r2, r2, r8
d2f4: e3a03000 mov r3, #0
d2f8: e0a33009 adc r3, r3, r9
d2fc: e1a00f22 lsr r0, r2, #30
int b;
fmt_params->fattype = FAT_FAT32;
d300: e3a02004 mov r2, #4
/* 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;
d304: e1800103 orr r0, r0, r3, lsl #2
int b;
fmt_params->fattype = FAT_FAT32;
d308: e5cd2266 strb r2, [sp, #614] ; 0x266
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
d30c: e3a0301f mov r3, #31
if ((gigs & (1 << b)) != 0)
d310: e3a01001 mov r1, #1
d314: ea000001 b d320 <msdos_format+0xbdc>
#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--)
d318: e2533001 subs r3, r3, #1
d31c: 0a0000cd beq d658 <msdos_format+0xf14>
if ((gigs & (1 << b)) != 0)
d320: e1a02311 lsl r2, r1, r3
d324: e1120000 tst r2, r0
d328: 0afffffa beq d318 <msdos_format+0xbd4>
break;
fmt_params->sectors_per_cluster = 1 << b;
d32c: e58d2240 str r2, [sp, #576] ; 0x240
d330: eafffed5 b ce8c <msdos_format+0x748>
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
}
else if (rqdata->fat_num <= 6) {
d334: e35c0006 cmp ip, #6
d338: 8a000010 bhi d380 <msdos_format+0xc3c>
fmt_params->fat_num = rqdata->fat_num;
d33c: e20cc0ff and ip, ip, #255 ; 0xff
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
d340: e1a00004 mov r0, r4
d344: e3a01002 mov r1, #2
d348: e59f23d0 ldr r2, [pc, #976] ; d720 <msdos_format+0xfdc>
d34c: e1a0300c mov r3, ip
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
}
else if (rqdata->fat_num <= 6) {
fmt_params->fat_num = rqdata->fat_num;
d350: e5cdc264 strb ip, [sp, #612] ; 0x264
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
d354: ebfffc4b bl c488 <msdos_format_printf>
d358: eafffebd b ce54 <msdos_format+0x710>
{
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) {
d35c: e3a06000 mov r6, #0
d360: e1a07423 lsr r7, r3, #8
d364: e20330ff and r3, r3, #255 ; 0xff
d368: e58d300c str r3, [sp, #12]
d36c: e20770ff and r7, r7, #255 ; 0xff
d370: e58d6018 str r6, [sp, #24]
d374: e58d6014 str r6, [sp, #20]
d378: e58d6010 str r6, [sp, #16]
d37c: eafffdcd b cab8 <msdos_format+0x374>
}
else if (rqdata->fat_num <= 6) {
fmt_params->fat_num = rqdata->fat_num;
}
else {
errno = EINVAL;
d380: eb00314b bl 198b4 <__errno>
d384: e3a03016 mov r3, #22
d388: e5803000 str r3, [r0]
ret_val = -1;
d38c: e3e06000 mvn r6, #0
d390: eafffd26 b c830 <msdos_format+0xec>
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
d394: e1a01006 mov r1, r6
d398: e3a02c02 mov r2, #512 ; 0x200
d39c: e28d0034 add r0, sp, #52 ; 0x34
d3a0: eb003420 bl 1a428 <memset>
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
d3a4: e28d3e27 add r3, sp, #624 ; 0x270
d3a8: e8930007 ldm r3, {r0, r1, r2}
d3ac: e28dc034 add ip, sp, #52 ; 0x34
d3b0: e8ac0003 stmia ip!, {r0, r1}
d3b4: e0cc20b2 strh r2, [ip], #2
d3b8: e1a0e822 lsr lr, r2, #16
d3bc: e5cce000 strb lr, [ip]
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
d3c0: e1a00005 mov r0, r5
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
d3c4: e3a0c008 mov ip, #8
ret_val = msdos_format_write_sec
d3c8: e59d1254 ldr r1, [sp, #596] ; 0x254
d3cc: e59d2234 ldr r2, [sp, #564] ; 0x234
d3d0: e28d3034 add r3, sp, #52 ; 0x34
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
d3d4: e5cdc03f strb ip, [sp, #63] ; 0x3f
ret_val = msdos_format_write_sec
d3d8: ebfffc41 bl c4e4 <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) {
d3dc: e3500000 cmp r0, #0
d3e0: 0afffe34 beq ccb8 <msdos_format+0x574>
fmt_params.bytes_per_sector,
tmp_sec);
}
}
if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {
d3e4: e1a06000 mov r6, r0
d3e8: eafffd00 b c7f0 <msdos_format+0xac>
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
d3ec: e3a01000 mov r1, #0
d3f0: e3a02c02 mov r2, #512 ; 0x200
d3f4: e28d0034 add r0, sp, #52 ; 0x34
d3f8: eb00340a bl 1a428 <memset>
/* * write LEADSIG, STRUCTSIG, TRAILSIG */ FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
d3fc: e3a0e052 mov lr, #82 ; 0x52
d400: e5cde034 strb lr, [sp, #52] ; 0x34
d404: e5cde035 strb lr, [sp, #53] ; 0x35
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE); FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
d408: e3a0e055 mov lr, #85 ; 0x55
/* * write "empty" values for free cluster count and next cluster number */ FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
d40c: e3e0c000 mvn ip, #0
*/ memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE); /* * write LEADSIG, STRUCTSIG, TRAILSIG */ FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
d410: e3a0a061 mov sl, #97 ; 0x61
d414: e3a08041 mov r8, #65 ; 0x41
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
d418: e3a07072 mov r7, #114 ; 0x72
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
d41c: e1a01006 mov r1, r6
/* * write LEADSIG, STRUCTSIG, TRAILSIG */ FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE ); FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE); FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
d420: e5cde232 strb lr, [sp, #562] ; 0x232
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
d424: e1a00005 mov r0, r5
/* * write LEADSIG, STRUCTSIG, TRAILSIG */ FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE ); FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE); FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
d428: e3e0e055 mvn lr, #85 ; 0x55
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
d42c: e59d2234 ldr r2, [sp, #564] ; 0x234
d430: e28d3034 add r3, sp, #52 ; 0x34
*/ memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE); /* * write LEADSIG, STRUCTSIG, TRAILSIG */ FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
d434: e5cda036 strb sl, [sp, #54] ; 0x36
d438: e5cd8037 strb r8, [sp, #55] ; 0x37
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
d43c: e5cd7218 strb r7, [sp, #536] ; 0x218
d440: e5cd7219 strb r7, [sp, #537] ; 0x219
d444: e5cd821a strb r8, [sp, #538] ; 0x21a
d448: e5cda21b strb sl, [sp, #539] ; 0x21b
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
d44c: e5cde233 strb lr, [sp, #563] ; 0x233
/* * write "empty" values for free cluster count and next cluster number */ FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
d450: e5cdc21c strb ip, [sp, #540] ; 0x21c
d454: e5cdc21d strb ip, [sp, #541] ; 0x21d
d458: e5cdc21e strb ip, [sp, #542] ; 0x21e
d45c: e5cdc21f strb ip, [sp, #543] ; 0x21f
0xffffffff); FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
d460: e5cdc220 strb ip, [sp, #544] ; 0x220
d464: e5cdc221 strb ip, [sp, #545] ; 0x221
d468: e5cdc222 strb ip, [sp, #546] ; 0x222
d46c: e5cdc223 strb ip, [sp, #547] ; 0x223
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
d470: ebfffc1b bl c4e4 <msdos_format_write_sec>
}
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
d474: e2506000 subs r6, r0, #0
d478: 1afffcdc bne c7f0 <msdos_format+0xac>
d47c: eafffdf3 b cc50 <msdos_format+0x50c>
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
d480: e5dd1265 ldrb r1, [sp, #613] ; 0x265
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
d484: e5dd3264 ldrb r3, [sp, #612] ; 0x264
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
d488: e3e02000 mvn r2, #0
d48c: e5cd1034 strb r1, [sp, #52] ; 0x34
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
d490: e3e01007 mvn r1, #7
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
d494: e5cd2035 strb r2, [sp, #53] ; 0x35
d498: e5cd2036 strb r2, [sp, #54] ; 0x36
d49c: e5cd2037 strb r2, [sp, #55] ; 0x37
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
d4a0: e5cd2039 strb r2, [sp, #57] ; 0x39
d4a4: e5cd203a strb r2, [sp, #58] ; 0x3a
d4a8: e2933000 adds r3, r3, #0
d4ac: e3a0200f mov r2, #15
d4b0: e5cd1038 strb r1, [sp, #56] ; 0x38
d4b4: e5cd203b strb r2, [sp, #59] ; 0x3b
d4b8: 13a03001 movne r3, #1
d4bc: e3a00000 mov r0, #0
d4c0: e3a02001 mov r2, #1
/*
* 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);
d4c4: e3e01000 mvn r1, #0
d4c8: e3e0c007 mvn ip, #7
d4cc: e5cd103d strb r1, [sp, #61] ; 0x3d
d4d0: e5cd103e strb r1, [sp, #62] ; 0x3e
d4d4: e3a0100f mov r1, #15
d4d8: e5cdc03c strb ip, [sp, #60] ; 0x3c
d4dc: e5cd103f strb r1, [sp, #63] ; 0x3f
d4e0: eafffe08 b cd08 <msdos_format+0x5c4>
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);
d4e4: e5dd1265 ldrb r1, [sp, #613] ; 0x265
FAT_SET_VAL8(tmp_sec,1,0xff);
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
d4e8: e5dd3264 ldrb r3, [sp, #612] ; 0x264
break;
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
FAT_SET_VAL8(tmp_sec,1,0xff);
d4ec: e3e02000 mvn r2, #0
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);
d4f0: e5cd1034 strb r1, [sp, #52] ; 0x34
FAT_SET_VAL8(tmp_sec,1,0xff);
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
d4f4: e3e01007 mvn r1, #7
d4f8: e2933000 adds r3, r3, #0
break;
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
FAT_SET_VAL8(tmp_sec,1,0xff);
d4fc: e5cd2035 strb r2, [sp, #53] ; 0x35
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
d500: e5cd1036 strb r1, [sp, #54] ; 0x36
d504: e5cd2037 strb r2, [sp, #55] ; 0x37
d508: 13a03001 movne r3, #1
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
d50c: e3a00000 mov r0, #0
d510: e3a02001 mov r2, #1
d514: eafffdfb b cd08 <msdos_format+0x5c4>
memset(tmp_sec,0,sizeof(tmp_sec));
switch(fmt_params.fattype) {
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
d518: e5dd2265 ldrb r2, [sp, #613] ; 0x265
/* 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)));
/* MSBits of FAT entry 1: MSBits of EOC */
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
d51c: e5dd3264 ldrb r3, [sp, #612] ; 0x264
memset(tmp_sec,0,sizeof(tmp_sec));
switch(fmt_params.fattype) {
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
d520: e5cd2034 strb r2, [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)));
d524: e3e02070 mvn r2, #112 ; 0x70
d528: e5cd2035 strb r2, [sp, #53] ; 0x35
/* MSBits of FAT entry 1: MSBits of EOC */
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
d52c: e2933000 adds r3, r3, #0
d530: e3e02000 mvn r2, #0
d534: e5cd2036 strb r2, [sp, #54] ; 0x36
d538: 13a03001 movne r3, #1
break;
d53c: eafffff2 b d50c <msdos_format+0xdc8>
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-- ) {
d540: e3a02001 mov r2, #1 <== NOT EXECUTED
d544: eafffefa b d134 <msdos_format+0x9f0> <== NOT EXECUTED
d548: e1a06000 mov r6, r0 <== NOT EXECUTED
d54c: e59d502c ldr r5, [sp, #44] ; 0x2c <== NOT EXECUTED
d550: e59d4024 ldr r4, [sp, #36] ; 0x24 <== NOT EXECUTED
d554: eafffcb9 b c840 <msdos_format+0xfc> <== NOT EXECUTED
d558: e59d502c ldr r5, [sp, #44] ; 0x2c
d55c: e59d4024 ldr r4, [sp, #36] ; 0x24
d560: e3a06000 mov r6, #0
d564: eafffcb5 b c840 <msdos_format+0xfc>
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();
d568: eb003635 bl 1ae44 <rand>
d56c: e58d0280 str r0, [sp, #640] ; 0x280
d570: eafffd1c b c9e8 <msdos_format+0x2a4>
if ((ret_val == 0) &&
(fmt_params.mbr_copy_sec != 0)) {
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
d574: e3a01002 mov r1, #2
d578: e59f21c8 ldr r2, [pc, #456] ; d748 <msdos_format+0x1004>
d57c: e1a00004 mov r0, r4
d580: ebfffbc0 bl c488 <msdos_format_printf>
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
d584: e1a00005 mov r0, r5
d588: e59d125c ldr r1, [sp, #604] ; 0x25c
d58c: e59d2234 ldr r2, [sp, #564] ; 0x234
d590: e28d3034 add r3, sp, #52 ; 0x34
d594: ebfffbd2 bl c4e4 <msdos_format_write_sec>
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
d598: e2506000 subs r6, r0, #0
d59c: 0afffda8 beq cc44 <msdos_format+0x500>
d5a0: eafffc92 b c7f0 <msdos_format+0xac> <== NOT EXECUTED
ret_val = -1;
}
if (0 == ret_val)
{
if (FAT_FAT32 != fmt_params->fattype)
d5a4: e59d2240 ldr r2, [sp, #576] ; 0x240
d5a8: e5dd3284 ldrb r3, [sp, #644] ; 0x284
d5ac: eafffcb6 b c88c <msdos_format+0x148>
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
d5b0: e59f0194 ldr r0, [pc, #404] ; d74c <msdos_format+0x1008>
d5b4: eafffcf6 b c994 <msdos_format+0x250>
}
start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,
fmt_params.sectors_per_cluster,
fmt_params.skip_alignment);
for (i = 0;
d5b8: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED
d5bc: e0022001 and r2, r2, r1 <== NOT EXECUTED
d5c0: eafffdee b cd80 <msdos_format+0x63c> <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
d5c4: e59d3244 ldr r3, [sp, #580] ; 0x244
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 */
d5c8: e59dc25c ldr ip, [sp, #604] ; 0x25c
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
d5cc: e1a08423 lsr r8, r3, #8
d5d0: e1a07823 lsr r7, r3, #16
d5d4: e1a06c23 lsr r6, r3, #24
d5d8: e5cd3058 strb r3, [sp, #88] ; 0x58
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 */
d5dc: e3a03002 mov r3, #2
d5e0: e5cd3060 strb r3, [sp, #96] ; 0x60
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
d5e4: e3a03001 mov r3, #1
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
d5e8: e1a0e42c lsr lr, ip, #8
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
d5ec: e5cd3064 strb r3, [sp, #100] ; 0x64
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
d5f0: e28d0086 add r0, sp, #134 ; 0x86
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);
d5f4: 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);
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
d5f8: e59f1150 ldr r1, [pc, #336] ; d750 <msdos_format+0x100c>
d5fc: e3a02008 mov r2, #8
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
d600: e5cd8059 strb r8, [sp, #89] ; 0x59
d604: e5cd705a strb r7, [sp, #90] ; 0x5a
d608: e5cd605b strb r6, [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 */
d60c: e5cdc066 strb ip, [sp, #102] ; 0x66
d610: e5cde067 strb lr, [sp, #103] ; 0x67
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
d614: e58da068 str sl, [sp, #104] ; 0x68
d618: e58da06c str sl, [sp, #108] ; 0x6c
d61c: e58da070 str sl, [sp, #112] ; 0x70
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);
d620: 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);
d624: e5cda07b strb sl, [sp, #123] ; 0x7b
d628: e5cda07c strb sl, [sp, #124] ; 0x7c
d62c: e5cda07d strb sl, [sp, #125] ; 0x7d
d630: e5cda07e strb sl, [sp, #126] ; 0x7e
d634: e5cda07f strb sl, [sp, #127] ; 0x7f
d638: e5cda080 strb sl, [sp, #128] ; 0x80
d63c: e5cda081 strb sl, [sp, #129] ; 0x81
d640: e5cda082 strb sl, [sp, #130] ; 0x82
d644: e5cda083 strb sl, [sp, #131] ; 0x83
d648: e5cda084 strb sl, [sp, #132] ; 0x84
d64c: e5cda085 strb sl, [sp, #133] ; 0x85
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
d650: eb00333e bl 1a350 <memcpy>
d654: eafffd62 b cbe4 <msdos_format+0x4a0>
#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--)
d658: e3a02001 mov r2, #1
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
d65c: e58d2240 str r2, [sp, #576] ; 0x240
d660: eafffe09 b ce8c <msdos_format+0x748>
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
d664: e3a0c002 mov ip, #2
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
d668: e1a0100c mov r1, ip
d66c: e1a0300c mov r3, ip
d670: e1a00004 mov r0, r4
d674: e59f20a4 ldr r2, [pc, #164] ; d720 <msdos_format+0xfdc>
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
d678: e5cdc264 strb ip, [sp, #612] ; 0x264
ret_val = -1;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
d67c: ebfffb81 bl c488 <msdos_format_printf>
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
d680: e59f109c ldr r1, [pc, #156] ; d724 <msdos_format+0xfe0>
* 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;
d684: e3a03020 mov r3, #32
d688: eafffdf8 b ce70 <msdos_format+0x72c>
fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
}
while( ret_val == 0
&& fmt_params->fattype != fat_type
&& fmt_params->totl_sector_cnt > 0 ) {
d68c: e2942000 adds r2, r4, #0 <== NOT EXECUTED
d690: 13a02001 movne r2, #1 <== NOT EXECUTED
d694: e59d9238 ldr r9, [sp, #568] ; 0x238 <== NOT EXECUTED
d698: e58d2020 str r2, [sp, #32] <== NOT EXECUTED
d69c: eafffc67 b c840 <msdos_format+0xfc> <== NOT EXECUTED
data_clusters_cnt =
fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
}
while( ret_val == 0
&& fmt_params->fattype != fat_type
d6a0: e2942000 adds r2, r4, #0 <== NOT EXECUTED
d6a4: 13a02001 movne r2, #1 <== NOT EXECUTED
d6a8: e58d2020 str r2, [sp, #32] <== NOT EXECUTED
d6ac: e59d9238 ldr r9, [sp, #568] ; 0x238 <== NOT EXECUTED
d6b0: eafffc62 b c840 <msdos_format+0xfc> <== 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) {
d6b4: e2940000 adds r0, r4, #0 <== NOT EXECUTED
d6b8: 13a00001 movne r0, #1 <== NOT EXECUTED
d6bc: e58d0020 str r0, [sp, #32] <== NOT EXECUTED
d6c0: eafffeb2 b d190 <msdos_format+0xa4c> <== NOT EXECUTED
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
d6c4: eb00307a bl 198b4 <__errno>
d6c8: e3a03016 mov r3, #22
d6cc: e5803000 str r3, [r0]
d6d0: e59d723c ldr r7, [sp, #572] ; 0x23c
d6d4: e1a0800a mov r8, sl
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;
d6d8: e3e06000 mvn r6, #0
d6dc: eafffc83 b c8f0 <msdos_format+0x1ac>
0000c53c <msdos_format_fill_sectors>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
c53c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
c540: e24dd008 sub sp, sp, #8
c544: e59db02c ldr fp, [sp, #44] ; 0x2c
c548: e58d0004 str r0, [sp, #4]
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
c54c: e1a0000b mov r0, fp
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
c550: e58d1000 str r1, [sp]
c554: e1a04002 mov r4, r2
c558: e1a0a003 mov sl, r3
c55c: e5dd5030 ldrb r5, [sp, #48] ; 0x30
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
c560: ebffe0bf bl 4864 <malloc>
if (fill_buffer == NULL) {
c564: e2509000 subs r9, r0, #0
c568: 0a000038 beq c650 <msdos_format_fill_sectors+0x114>
errno = ENOMEM;
ret_val = -1;
}
else {
memset(fill_buffer,fill_byte,sector_size);
c56c: e1a01005 mov r1, r5
c570: e1a0200b mov r2, fp
c574: eb0037ab bl 1a428 <memset>
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
c578: e59d0004 ldr r0, [sp, #4]
c57c: e3a01002 mov r1, #2
c580: e59f2130 ldr r2, [pc, #304] ; c6b8 <msdos_format_fill_sectors+0x17c>
c584: ebffffbf bl c488 <msdos_format_printf>
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
c588: e35a0000 cmp sl, #0
c58c: 0a000043 beq c6a0 <msdos_format_fill_sectors+0x164>
c590: e08a610a add r6, sl, sl, lsl #2
c594: e0866106 add r6, r6, r6, lsl #2
c598: e1a06106 lsl r6, r6, #2
c59c: e1a0500a mov r5, sl
\*=========================================================================*/
{
int ret_val = 0;
char *fill_buffer = NULL;
uint32_t total_sectors = sector_cnt;
int last_percent = -1;
c5a0: e3e08000 mvn r8, #0
c5a4: ea00000f b c5e8 <msdos_format_fill_sectors+0xac>
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);
c5a8: e1a01004 mov r1, r4
c5ac: e1a03009 mov r3, r9
c5b0: e59d0000 ldr r0, [sp]
c5b4: e1a0200b mov r2, fp
c5b8: ebffffc9 bl c4e4 <msdos_format_write_sec>
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
(sector_cnt > 0)) {
c5bc: e2555001 subs r5, r5, #1
c5c0: 03a03000 moveq r3, #0
c5c4: 13a03001 movne r3, #1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
c5c8: e3500000 cmp r0, #0
c5cc: 13a03000 movne r3, #0
c5d0: 02033001 andeq r3, r3, #1
c5d4: e3530000 cmp r3, #0
c5d8: e1a07000 mov r7, r0
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
c5dc: e2844001 add r4, r4, #1
sector_cnt--;
c5e0: e2466064 sub r6, r6, #100 ; 0x64
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
c5e4: 0a00000e beq c624 <msdos_format_fill_sectors+0xe8>
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
c5e8: e1a0100a mov r1, sl
c5ec: e1a00006 mov r0, r6
c5f0: ebffd5d2 bl 1d40 <__aeabi_uidiv>
if (percent != last_percent) {
c5f4: e1500008 cmp r0, r8
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
c5f8: e1a07000 mov r7, r0
if (percent != last_percent) {
c5fc: 0affffe9 beq c5a8 <msdos_format_fill_sectors+0x6c>
if ((percent & 1) == 0)
c600: e3100001 tst r0, #1
c604: 11a08000 movne r8, r0
c608: 1affffe6 bne c5a8 <msdos_format_fill_sectors+0x6c>
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
c60c: e59d0004 ldr r0, [sp, #4]
c610: e3a01002 mov r1, #2
c614: e59f20a0 ldr r2, [pc, #160] ; c6bc <msdos_format_fill_sectors+0x180>
c618: ebffff9a bl c488 <msdos_format_printf>
c61c: e1a08007 mov r8, r7
c620: eaffffe0 b c5a8 <msdos_format_fill_sectors+0x6c>
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");
c624: e59d0004 ldr r0, [sp, #4]
c628: e3a01002 mov r1, #2
c62c: e59f208c ldr r2, [pc, #140] ; c6c0 <msdos_format_fill_sectors+0x184>
c630: ebffff94 bl c488 <msdos_format_printf>
if (ret_val)
c634: e3570000 cmp r7, #0
c638: 1a000010 bne c680 <msdos_format_fill_sectors+0x144>
/*
* cleanup
*/
if (fill_buffer != NULL) {
free(fill_buffer);
c63c: e1a00009 mov r0, r9
c640: ebffdf45 bl 435c <free>
fill_buffer = NULL;
}
return ret_val;
}
c644: e1a00007 mov r0, r7
c648: e28dd008 add sp, sp, #8
c64c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
if (fill_buffer == NULL) {
errno = ENOMEM;
c650: eb003497 bl 198b4 <__errno> <== NOT EXECUTED
c654: e3a0300c mov r3, #12 <== NOT EXECUTED
c658: e5803000 str r3, [r0] <== NOT EXECUTED
else {
memset(fill_buffer,fill_byte,sector_size);
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
c65c: e3a01002 mov r1, #2 <== NOT EXECUTED
c660: e59f2050 ldr r2, [pc, #80] ; c6b8 <msdos_format_fill_sectors+0x17c><== NOT EXECUTED
c664: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
c668: ebffff86 bl c488 <msdos_format_printf> <== NOT EXECUTED
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
c66c: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
c670: e3a01002 mov r1, #2 <== NOT EXECUTED
c674: e59f2044 ldr r2, [pc, #68] ; c6c0 <msdos_format_fill_sectors+0x184><== NOT EXECUTED
c678: ebffff82 bl c488 <msdos_format_printf> <== NOT EXECUTED
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
if (fill_buffer == NULL) {
errno = ENOMEM;
ret_val = -1;
c67c: e3e07000 mvn r7, #0 <== NOT EXECUTED
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
if (ret_val)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
c680: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
c684: e3a01001 mov r1, #1 <== NOT EXECUTED
c688: e59f2034 ldr r2, [pc, #52] ; c6c4 <msdos_format_fill_sectors+0x188><== NOT EXECUTED
c68c: e1a03004 mov r3, r4 <== NOT EXECUTED
c690: ebffff7c bl c488 <msdos_format_printf> <== NOT EXECUTED
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
c694: e3590000 cmp r9, #0 <== NOT EXECUTED
c698: 0affffe9 beq c644 <msdos_format_fill_sectors+0x108> <== NOT EXECUTED
c69c: eaffffe6 b c63c <msdos_format_fill_sectors+0x100> <== NOT EXECUTED
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
c6a0: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
c6a4: e3a01002 mov r1, #2 <== NOT EXECUTED
c6a8: e59f2010 ldr r2, [pc, #16] ; c6c0 <msdos_format_fill_sectors+0x184><== NOT EXECUTED
c6ac: ebffff75 bl c488 <msdos_format_printf> <== NOT EXECUTED
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
c6b0: e1a0700a mov r7, sl <== NOT EXECUTED
c6b4: eaffffe0 b c63c <msdos_format_fill_sectors+0x100> <== NOT EXECUTED
0000c488 <msdos_format_printf>:
*/
static void
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
c488: e92d000c push {r2, r3}
c48c: e92d4010 push {r4, lr}
c490: e24dd004 sub sp, sp, #4
va_list args; va_start (args, format);
c494: e28d2010 add r2, sp, #16
if (rqdata != NULL && rqdata->info_level >= info_level)
c498: 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);
c49c: e58d2000 str r2, [sp]
if (rqdata != NULL && rqdata->info_level >= info_level)
c4a0: 0a00000a beq c4d0 <msdos_format_printf+0x48>
c4a4: e5903018 ldr r3, [r0, #24]
c4a8: e1530001 cmp r3, r1
c4ac: ba000007 blt c4d0 <msdos_format_printf+0x48>
{
vfprintf (stdout, format, args);
c4b0: e59f4028 ldr r4, [pc, #40] ; c4e0 <msdos_format_printf+0x58><== NOT EXECUTED
c4b4: e5943000 ldr r3, [r4] <== NOT EXECUTED
c4b8: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED
c4bc: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
c4c0: eb005857 bl 22624 <vfprintf> <== NOT EXECUTED
fflush (stdout);
c4c4: e5943000 ldr r3, [r4] <== NOT EXECUTED
c4c8: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
c4cc: eb0035f5 bl 19ca8 <fflush> <== NOT EXECUTED
} va_end (args); }
c4d0: e28dd004 add sp, sp, #4
c4d4: e8bd4010 pop {r4, lr}
c4d8: e28dd008 add sp, sp, #8
c4dc: e12fff1e bx lr
0000c4e4 <msdos_format_write_sec>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
c4e4: e92d40f0 push {r4, r5, r6, r7, lr}
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
c4e8: e0876291 umull r6, r7, r1, r2
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
c4ec: e1a04002 mov r4, r2
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
c4f0: e1a01006 mov r1, r6
c4f4: e1a02007 mov r2, r7
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
c4f8: e1a05003 mov r5, r3
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
c4fc: e3a03000 mov r3, #0
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
c500: e1a06000 mov r6, r0
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
c504: eb001d92 bl 13b54 <lseek>
c508: e3500000 cmp r0, #0
c50c: e2d17000 sbcs r7, r1, #0
c510: ba000007 blt c534 <msdos_format_write_sec+0x50>
ret_val = -1;
}
if (ret_val == 0) {
if (0 > write(fd,buffer,sector_size)) {
c514: e1a00006 mov r0, r6
c518: e1a01005 mov r1, r5
c51c: e1a02004 mov r2, r4
c520: ebffeefb bl 8114 <write>
c524: e3500000 cmp r0, #0
c528: b3e00000 mvnlt r0, #0
c52c: a3a00000 movge r0, #0
c530: e8bd80f0 pop {r4, r5, r6, r7, 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)) {
c534: e3e00000 mvn r0, #0 <== NOT EXECUTED
ret_val = -1;
}
}
return ret_val;
}
c538: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
000176c8 <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
)
{
176c8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
176cc: e24dd058 sub sp, sp, #88 ; 0x58
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
176d0: e5906008 ldr r6, [r0, #8]
fat_file_fd_t *fat_fd = NULL;
176d4: e28d5058 add r5, sp, #88 ; 0x58
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
176d8: e1a08000 mov r8, r0
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
176dc: e3a00000 mov r0, #0 176e0: e5250004 str r0, [r5, #-4]!
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
176e4: e1a07002 mov r7, r2 176e8: e1a0a001 mov sl, r1
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
176ec: e1a00006 mov r0, r6 176f0: e1a01002 mov r1, r2 176f4: e1a02005 mov r2, r5
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
176f8: e1a09003 mov r9, r3
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
176fc: ebffe6b0 bl 111c4 <fat_file_open>
if (rc != RC_OK)
17700: e2504000 subs r4, r0, #0
17704: 0a000002 beq 17714 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x4c>
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
rc = fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
17708: e1a00004 mov r0, r4
1770c: e28dd058 add sp, sp, #88 ; 0x58
17710: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
*/
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
17714: e59d1054 ldr r1, [sp, #84] ; 0x54
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
17718: 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;
1771c: e5814010 str r4, [r1, #16]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
17720: 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;
17724: e581a01c str sl, [r1, #28]
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
17728: e5813014 str r3, [r1, #20]
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
1772c: e581a038 str sl, [r1, #56] ; 0x38
rc = fat_file_size(&fs_info->fat, fat_fd);
17730: e1a00006 mov r0, r6 17734: ebffe993 bl 11d88 <fat_file_size>
if (rc != RC_OK)
17738: e2504000 subs r4, r0, #0
1773c: 1a000068 bne 178e4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x21c>
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
17740: e28da014 add sl, sp, #20
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
17744: e3a01001 mov r1, #1 17748: e1a0200a mov r2, sl 1774c: e3a0300b mov r3, #11 17750: e59f01a4 ldr r0, [pc, #420] ; 178fc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x234>
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
17754: e58d4014 str r4, [sp, #20] 17758: e58d4018 str r4, [sp, #24] 1775c: e58d401c str r4, [sp, #28] 17760: e58d4020 str r4, [sp, #32] 17764: e58d4024 str r4, [sp, #36] ; 0x24 17768: e58d4028 str r4, [sp, #40] ; 0x28 1776c: e58d402c str r4, [sp, #44] ; 0x2c 17770: e58d4030 str r4, [sp, #48] ; 0x30
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
17774: e3a0b001 mov fp, #1
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
17778: ebfffb5f bl 164fc <msdos_long_to_short>
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
1777c: e1a02004 mov r2, r4 17780: e1a00008 mov r0, r8 17784: e59d1054 ldr r1, [sp, #84] ; 0x54 17788: e59f316c ldr r3, [pc, #364] ; 178fc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x234> 1778c: e58db000 str fp, [sp] 17790: e58db004 str fp, [sp, #4] 17794: e58d7008 str r7, [sp, #8] 17798: e58da00c str sl, [sp, #12] 1779c: ebfffd07 bl 16bc0 <msdos_find_name_in_fat_file>
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
177a0: e2504000 subs r4, r0, #0
177a4: 1a00004e bne 178e4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x21c>
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
177a8: e3a01002 mov r1, #2 177ac: e28d2034 add r2, sp, #52 ; 0x34 177b0: e3a0300b mov r3, #11 177b4: e59f0144 ldr r0, [pc, #324] ; 17900 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x238>
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
177b8: e58d4034 str r4, [sp, #52] ; 0x34 177bc: e58d4038 str r4, [sp, #56] ; 0x38 177c0: e58d403c str r4, [sp, #60] ; 0x3c 177c4: e58d4040 str r4, [sp, #64] ; 0x40 177c8: e58d4044 str r4, [sp, #68] ; 0x44 177cc: e58d4048 str r4, [sp, #72] ; 0x48 177d0: e58d404c str r4, [sp, #76] ; 0x4c 177d4: e58d4050 str r4, [sp, #80] ; 0x50
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
177d8: ebfffb47 bl 164fc <msdos_long_to_short>
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
177dc: e3a0c002 mov ip, #2 177e0: e1a02004 mov r2, r4 177e4: e59d1054 ldr r1, [sp, #84] ; 0x54 177e8: e58dc000 str ip, [sp] 177ec: e1a00008 mov r0, r8 177f0: e28dc034 add ip, sp, #52 ; 0x34 177f4: e59f3104 ldr r3, [pc, #260] ; 17900 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x238> 177f8: e58db004 str fp, [sp, #4] 177fc: e58d7008 str r7, [sp, #8] 17800: e58dc00c str ip, [sp, #12] 17804: ebfffced bl 16bc0 <msdos_find_name_in_fat_file>
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
17808: e2504000 subs r4, r0, #0
{
fat_file_close(&fs_info->fat, fat_fd);
1780c: e59d1054 ldr r1, [sp, #84] ; 0x54 17810: e1a00006 mov r0, r6
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
17814: 1a000036 bne 178f4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x22c>
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
17818: e1da31ba ldrh r3, [sl, #26] 1781c: e1daa1b4 ldrh sl, [sl, #20] 17820: e58d3010 str r3, [sp, #16]
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(&fs_info->fat, fat_fd);
17824: ebffe7c0 bl 1172c <fat_file_close>
if ( rc != RC_OK )
17828: e2504000 subs r4, r0, #0
1782c: 1affffb5 bne 17708 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x40>
return rc;
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
17830: e1dd24b8 ldrh r2, [sp, #72] ; 0x48 17834: e1dd34be ldrh r3, [sp, #78] ; 0x4e 17838: e1933802 orrs r3, r3, r2, lsl #16
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
1783c: 03e01000 mvneq r1, #0 17840: 05871008 streq r1, [r7, #8]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
17844: 0587100c streq r1, [r7, #12]
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
17848: 05873004 streq r3, [r7, #4]
/*
* 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;
1784c: 0587b000 streq fp, [r7]
}
/* open fat-file corresponded to second ".." */
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
17850: e1a00006 mov r0, r6 17854: e1a01007 mov r1, r7 17858: e1a02005 mov r2, r5 1785c: ebffe658 bl 111c4 <fat_file_open>
if (rc != RC_OK)
17860: e2504000 subs r4, r0, #0
17864: 1affffa7 bne 17708 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x40>
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
17868: e1dd24b8 ldrh r2, [sp, #72] ; 0x48 1786c: e1dd34be ldrh r3, [sp, #78] ; 0x4e 17870: e1933802 orrs r3, r3, r2, lsl #16
fat_fd->cln = fs_info->fat.vol.rdir_cl;
17874: 0596303c ldreq r3, [r6, #60] ; 0x3c 17878: e59d1054 ldr r1, [sp, #84] ; 0x54
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
1787c: e581301c str r3, [r1, #28]
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
17880: e591201c ldr r2, [r1, #28]
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
17884: e3a03000 mov r3, #0
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
17888: e3a00602 mov r0, #2097152 ; 0x200000 1788c: e5810014 str r0, [r1, #20]
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
17890: e5813010 str r3, [r1, #16]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
17894: e5813034 str r3, [r1, #52] ; 0x34
fat_fd->map.disk_cln = fat_fd->cln;
17898: e5812038 str r2, [r1, #56] ; 0x38
rc = fat_file_size(&fs_info->fat, fat_fd);
1789c: e1a00006 mov r0, r6 178a0: ebffe938 bl 11d88 <fat_file_size>
if (rc != RC_OK)
178a4: e2504000 subs r4, r0, #0
178a8: 1a00000d bne 178e4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x21c>
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
178ac: e59dc010 ldr ip, [sp, #16] 178b0: e59d1054 ldr r1, [sp, #84] ; 0x54 178b4: e1a00008 mov r0, r8 178b8: e18c280a orr r2, ip, sl, lsl #16 178bc: e1a03007 mov r3, r7 178c0: e58d9000 str r9, [sp] 178c4: ebffff28 bl 1756c <msdos_find_node_by_cluster_num_in_fat_file>
dir_pos, dir_entry);
if (rc != RC_OK)
178c8: e2504000 subs r4, r0, #0
{
fat_file_close(&fs_info->fat, fat_fd);
178cc: e59d1054 ldr r1, [sp, #84] ; 0x54 178d0: e1a00006 mov r0, r6
}
/* 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)
178d4: 1a000006 bne 178f4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x22c>
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
rc = fat_file_close(&fs_info->fat, fat_fd);
178d8: ebffe793 bl 1172c <fat_file_close> 178dc: e1a04000 mov r4, r0
return rc;
178e0: eaffff88 b 17708 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x40>
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(&fs_info->fat, fat_fd);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
178e4: e1a00006 mov r0, r6 <== NOT EXECUTED 178e8: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED 178ec: ebffe78e bl 1172c <fat_file_close> <== NOT EXECUTED
return rc;
178f0: eaffff84 b 17708 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x40><== NOT EXECUTED
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
dir_pos, dir_entry);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
178f4: ebffe78c bl 1172c <fat_file_close> <== NOT EXECUTED
return rc;
178f8: eaffff82 b 17708 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x40><== NOT EXECUTED
0000d7c8 <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
)
{
d7c8: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
d7cc: e1a06000 mov r6, r0
d7d0: e24dd018 sub sp, sp, #24
d7d4: e1a08001 mov r8, r1
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));
d7d8: e3a00001 mov r0, #1
d7dc: 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
)
{
d7e0: e1a07003 mov r7, r3
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
d7e4: e3a03000 mov r3, #0
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
)
{
d7e8: 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;
d7ec: 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));
d7f0: ebffda1e bl 4070 <calloc>
if (!fs_info)
d7f4: e2504000 subs r4, r0, #0
d7f8: 0a000051 beq d944 <msdos_initialize_support+0x17c>
rtems_set_errno_and_return_minus_one(ENOMEM);
temp_mt_entry->fs_info = fs_info;
d7fc: e5864008 str r4, [r6, #8]
rc = fat_init_volume_info(&fs_info->fat, temp_mt_entry->dev);
d800: e5961038 ldr r1, [r6, #56] ; 0x38
d804: eb001326 bl 124a4 <fat_init_volume_info>
if (rc != RC_OK)
d808: e2505000 subs r5, r0, #0
d80c: 1a000032 bne d8dc <msdos_initialize_support+0x114>
/*
* 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;
d810: e28d1018 add r1, sp, #24
d814: e3a03001 mov r3, #1
d818: e5213014 str r3, [r1, #-20]!
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
d81c: e584a098 str sl, [r4, #152] ; 0x98
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
d820: e3e03000 mvn r3, #0
fs_info->directory_handlers = directory_handlers;
d824: 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;
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
d828: e1a00004 mov r0, r4
d82c: 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;
d830: e58d5008 str r5, [sp, #8]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
d834: e58d300c str r3, [sp, #12]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
d838: e58d3010 str r3, [sp, #16]
d83c: eb000e60 bl 111c4 <fat_file_open>
if (rc != RC_OK)
d840: e2505000 subs r5, r0, #0
d844: 1a000022 bne d8d4 <msdos_initialize_support+0x10c>
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->cln = fs_info->fat.vol.rdir_cl;
d848: e594303c ldr r3, [r4, #60] ; 0x3c
free(fs_info);
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
d84c: e59d1014 ldr r1, [sp, #20]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
d850: e3a02602 mov r2, #2097152 ; 0x200000
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
d854: 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;
d858: e5815010 str r5, [r1, #16]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
d85c: e5812014 str r2, [r1, #20]
fat_fd->cln = fs_info->fat.vol.rdir_cl;
d860: e581301c str r3, [r1, #28]
fat_fd->map.file_cln = 0;
d864: e5815034 str r5, [r1, #52] ; 0x34
fat_fd->map.disk_cln = fat_fd->cln;
d868: e5813038 str r3, [r1, #56] ; 0x38
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
d86c: 1a00001f bne d8f0 <msdos_initialize_support+0x128>
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
d870: 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 :
d874: 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;
d878: e5813018 str r3, [r1, #24]
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
d87c: e1500003 cmp r0, r3
d880: 31a00003 movcc r0, r3
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
d884: e3a01001 mov r1, #1
d888: ebffd9f8 bl 4070 <calloc>
if (fs_info->cl_buf == NULL)
d88c: 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));
d890: e58400a0 str r0, [r4, #160] ; 0xa0
if (fs_info->cl_buf == NULL)
d894: 0a000023 beq d928 <msdos_initialize_support+0x160>
fat_shutdown_drive(&fs_info->fat);
free(fs_info);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
sc = rtems_semaphore_create(3,
d898: e284c09c add ip, r4, #156 ; 0x9c
d89c: e3a00003 mov r0, #3
d8a0: e3a01001 mov r1, #1
d8a4: e3a02010 mov r2, #16
d8a8: e3a03000 mov r3, #0
d8ac: e58dc000 str ip, [sp]
d8b0: ebffeb47 bl 85d4 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
d8b4: e3500000 cmp r0, #0
d8b8: 1a000026 bne d958 <msdos_initialize_support+0x190>
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;
d8bc: e5963024 ldr r3, [r6, #36] ; 0x24
d8c0: e59d2014 ldr r2, [sp, #20]
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
d8c4: 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;
d8c8: e5832008 str r2, [r3, #8]
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
temp_mt_entry->ops = op_table;
d8cc: e586800c str r8, [r6, #12]
return rc;
d8d0: ea000003 b d8e4 <msdos_initialize_support+0x11c>
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
if (rc != RC_OK)
{
fat_shutdown_drive(&fs_info->fat);
d8d4: e1a00004 mov r0, r4 <== NOT EXECUTED
d8d8: eb0014f3 bl 12cac <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
d8dc: e1a00004 mov r0, r4 <== NOT EXECUTED
d8e0: ebffda9d bl 435c <free> <== NOT EXECUTED
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
temp_mt_entry->ops = op_table;
return rc;
}
d8e4: e1a00005 mov r0, r5
d8e8: e28dd018 add sp, sp, #24
d8ec: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
fs_info->fat.vol.bpc :
fs_info->fat.vol.rdir_size;
}
else
{
rc = fat_file_size(&fs_info->fat, fat_fd);
d8f0: e1a00004 mov r0, r4
d8f4: eb001123 bl 11d88 <fat_file_size>
if ( rc != RC_OK )
d8f8: 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;
d8fc: 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 )
d900: 0affffdf beq d884 <msdos_initialize_support+0xbc>
{
fat_file_close(&fs_info->fat, fat_fd);
d904: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED
d908: e1a00004 mov r0, r4 <== NOT EXECUTED
d90c: eb000f86 bl 1172c <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
d910: e1a00004 mov r0, r4 <== NOT EXECUTED
d914: eb0014e4 bl 12cac <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
d918: e1a00004 mov r0, r4 <== NOT EXECUTED
d91c: ebffda8e bl 435c <free> <== NOT EXECUTED
return rc;
d920: e1a0500a mov r5, sl <== NOT EXECUTED
d924: eaffffee b d8e4 <msdos_initialize_support+0x11c> <== NOT EXECUTED
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
if (fs_info->cl_buf == NULL)
{
fat_file_close(&fs_info->fat, fat_fd);
d928: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED
d92c: e1a00004 mov r0, r4 <== NOT EXECUTED
d930: eb000f7d bl 1172c <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
d934: e1a00004 mov r0, r4 <== NOT EXECUTED
d938: eb0014db bl 12cac <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
d93c: e1a00004 mov r0, r4 <== NOT EXECUTED
d940: ebffda85 bl 435c <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
d944: eb002fda bl 198b4 <__errno> <== NOT EXECUTED
d948: e3a0300c mov r3, #12 <== NOT EXECUTED
d94c: e5803000 str r3, [r0] <== NOT EXECUTED
d950: e3e05000 mvn r5, #0 <== NOT EXECUTED
d954: eaffffe2 b d8e4 <msdos_initialize_support+0x11c> <== NOT EXECUTED
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
{
fat_file_close(&fs_info->fat, fat_fd);
d958: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED
d95c: e1a00004 mov r0, r4 <== NOT EXECUTED
d960: eb000f71 bl 1172c <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
d964: e1a00004 mov r0, r4 <== NOT EXECUTED
d968: eb0014cf bl 12cac <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info->cl_buf);
d96c: e59400a0 ldr r0, [r4, #160] ; 0xa0 <== NOT EXECUTED
d970: ebffda79 bl 435c <free> <== NOT EXECUTED
free(fs_info);
d974: e1a00004 mov r0, r4 <== NOT EXECUTED
d978: ebffda77 bl 435c <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
d97c: eb002fcc bl 198b4 <__errno> <== NOT EXECUTED
d980: e3a03005 mov r3, #5 <== NOT EXECUTED
d984: e5803000 str r3, [r0] <== NOT EXECUTED
d988: e3e05000 mvn r5, #0 <== NOT EXECUTED
d98c: eaffffd4 b d8e4 <msdos_initialize_support+0x11c> <== NOT EXECUTED
0000d79c <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,
d79c: 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(
d7a0: 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)
{
d7a4: e52de004 push {lr} ; (str lr, [sp, #-4]!)
msdos_fs_info_t *fs_info = mt_entry->fs_info; rtems_status_code sc = rtems_semaphore_obtain(
d7a8: e593009c ldr r0, [r3, #156] ; 0x9c
d7ac: e1a02001 mov r2, r1
d7b0: ebffec20 bl 8838 <rtems_semaphore_obtain>
fs_info->vol_sema,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if (sc != RTEMS_SUCCESSFUL) {
d7b4: e3500000 cmp r0, #0
d7b8: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_fatal_error_occurred(0xdeadbeef);
d7bc: e59f0000 ldr r0, [pc] ; d7c4 <msdos_lock+0x28> <== NOT EXECUTED
d7c0: ebffee05 bl 8fdc <rtems_fatal_error_occurred> <== NOT EXECUTED
000164fc <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)
{
164fc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
16500: e24dd008 sub sp, sp, #8
16504: e58d2000 str r2, [sp]
16508: e1a05000 mov r5, r0
1650c: e1a04001 mov r4, r1
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
16510: e1a00002 mov r0, r2 16514: e3a01020 mov r1, #32 16518: e1a02003 mov r2, r3 1651c: eb000fc1 bl 1a428 <memset>
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
16520: e5d56000 ldrb r6, [r5] 16524: e246202e sub r2, r6, #46 ; 0x2e 16528: e2723000 rsbs r3, r2, #0 1652c: e0a33002 adc r3, r3, r2 16530: e3540001 cmp r4, #1 16534: 0356002e cmpeq r6, #46 ; 0x2e
16538: 0a000059 beq 166a4 <msdos_long_to_short+0x1a8>
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))
1653c: e3530000 cmp r3, #0
16540: 1a000060 bne 166c8 <msdos_long_to_short+0x1cc>
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
16544: e3540000 cmp r4, #0
16548: da00006c ble 16700 <msdos_long_to_short+0x204>
if ((lfn[i] != ' ') && (lfn[i] != '.'))
1654c: e356002e cmp r6, #46 ; 0x2e 16550: 13560020 cmpne r6, #32 16554: 03a03000 moveq r3, #0 16558: 13a03001 movne r3, #1 1655c: 01a01005 moveq r1, r5
16560: 0a000017 beq 165c4 <msdos_long_to_short+0xc8>
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
16564: e3560000 cmp r6, #0 16568: 13540000 cmpne r4, #0
1656c: da00005f ble 166f0 <msdos_long_to_short+0x1f4> * true the name is long, else the name is 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)
16570: e3a03000 mov r3, #0 16574: e58d3004 str r3, [sp, #4]
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
16578: e1a08005 mov r8, r5
* true the name is long, else the name is 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)
1657c: e1a0b003 mov fp, r3 16580: e1a07003 mov r7, r3 16584: e3e09000 mvn r9, #0
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
16588: e59f017c ldr r0, [pc, #380] ; 1670c <msdos_long_to_short+0x210> 1658c: e1a01006 mov r1, r6 16590: eb001330 bl 1b258 <strchr> 16594: e3500000 cmp r0, #0
16598: 0a000010 beq 165e0 <msdos_long_to_short+0xe4>
return MSDOS_NAME_LONG;
1659c: e3a06002 mov r6, #2
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
}
msdos_filename_unix2dos (lfn, lfn_len, sfn);
165a0: e1a00005 mov r0, r5 165a4: e1a01004 mov r1, r4 165a8: e59d2000 ldr r2, [sp] 165ac: eb000984 bl 18bc4 <msdos_filename_unix2dos> 165b0: ea000007 b 165d4 <msdos_long_to_short+0xd8>
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
165b4: e5f12001 ldrb r2, [r1, #1]! 165b8: e352002e cmp r2, #46 ; 0x2e 165bc: 13520020 cmpne r2, #32
165c0: 1affffe7 bne 16564 <msdos_long_to_short+0x68>
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
165c4: e2833001 add r3, r3, #1 165c8: e1530004 cmp r3, r4
165cc: 1afffff8 bne 165b4 <msdos_long_to_short+0xb8>
if (i == lfn_len)
{
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: INVALID[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
165d0: e3a06000 mov r6, #0 <== NOT EXECUTED
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
}
165d4: e1a00006 mov r0, r6
165d8: e28dd008 add sp, sp, #8
165dc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
165e0: e246302e sub r3, r6, #46 ; 0x2e 165e4: e273a000 rsbs sl, r3, #0 165e8: e0aaa003 adc sl, sl, r3
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
165ec: e35a0000 cmp sl, #0
165f0: 1a00000a bne 16620 <msdos_long_to_short+0x124>
165f4: e59f2114 ldr r2, [pc, #276] ; 16710 <msdos_long_to_short+0x214> 165f8: e5923000 ldr r3, [r2] 165fc: e0833006 add r3, r3, r6 16600: e5d33001 ldrb r3, [r3, #1] 16604: e3130007 tst r3, #7
16608: 1a000004 bne 16620 <msdos_long_to_short+0x124>
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
1660c: e59f0100 ldr r0, [pc, #256] ; 16714 <msdos_long_to_short+0x218> 16610: e1a01006 mov r1, r6 16614: eb00130f bl 1b258 <strchr>
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
16618: e3500000 cmp r0, #0
1661c: 0a000035 beq 166f8 <msdos_long_to_short+0x1fc>
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
return type;
if (dot_at >= 0)
16620: e3790001 cmn r9, #1
16624: 0a000018 beq 1668c <msdos_long_to_short+0x190>
{
if (is_dot || ((count - dot_at) > 3))
16628: e35a0000 cmp sl, #0
1662c: 1affffda bne 1659c <msdos_long_to_short+0xa0>
16630: e0693007 rsb r3, r9, r7 16634: e3530003 cmp r3, #3
16638: caffffd7 bgt 1659c <msdos_long_to_short+0xa0>
}
}
if (is_dot)
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
1663c: e2463041 sub r3, r6, #65 ; 0x41 16640: e3530019 cmp r3, #25
uppercase = true;
16644: 93a03001 movls r3, #1 16648: 958d3004 strls r3, [sp, #4]
}
}
if (is_dot)
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
1664c: 9a000002 bls 1665c <msdos_long_to_short+0x160>
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
16650: e2466061 sub r6, r6, #97 ; 0x61
lowercase = true;
16654: e3560019 cmp r6, #25 16658: 93a0b001 movls fp, #1
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
1665c: e5f86001 ldrb r6, [r8, #1]!
else if ((*name >= 'A') && (*name <= 'Z'))
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
lowercase = true;
count++;
16660: e2877001 add r7, r7, #1
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
16664: e3560000 cmp r6, #0 16668: 11540007 cmpne r4, r7
1666c: caffffc5 bgt 16588 <msdos_long_to_short+0x8c>
count++;
name++;
}
if (lowercase && uppercase)
16670: e35b0000 cmp fp, #0
16674: 0a00001d beq 166f0 <msdos_long_to_short+0x1f4>
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
16678: e59d2004 ldr r2, [sp, #4] 1667c: e3520000 cmp r2, #0 16680: 13a06002 movne r6, #2 16684: 03a06001 moveq r6, #1 16688: eaffffc4 b 165a0 <msdos_long_to_short+0xa4>
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
1668c: e3570008 cmp r7, #8
16690: 0a000008 beq 166b8 <msdos_long_to_short+0x1bc>
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
16694: e35a0000 cmp sl, #0
16698: 0affffe7 beq 1663c <msdos_long_to_short+0x140>
1669c: e1a09007 mov r9, r7 166a0: eaffffed b 1665c <msdos_long_to_short+0x160>
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
{
sfn[0] = '.';
166a4: e59d2000 ldr r2, [sp] 166a8: e3a0302e mov r3, #46 ; 0x2e 166ac: e5c23000 strb r3, [r2]
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
166b0: e3a06001 mov r6, #1 166b4: eaffffc6 b 165d4 <msdos_long_to_short+0xd8>
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
166b8: e35a0000 cmp sl, #0
166bc: 0affffb6 beq 1659c <msdos_long_to_short+0xa0>
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
166c0: e1a09007 mov r9, r7 <== NOT EXECUTED 166c4: eaffffe4 b 1665c <msdos_long_to_short+0x160> <== NOT EXECUTED
printf ("MSDOS_L2S: SHORT[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
166c8: e5d53001 ldrb r3, [r5, #1] 166cc: e3540002 cmp r4, #2 166d0: 0353002e cmpeq r3, #46 ; 0x2e
166d4: 1affff9a bne 16544 <msdos_long_to_short+0x48>
{
sfn[0] = sfn[1] = '.';
166d8: e59d2000 ldr r2, [sp] 166dc: e3a0302e mov r3, #46 ; 0x2e 166e0: e5c23001 strb r3, [r2, #1] 166e4: e5c23000 strb r3, [r2]
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
166e8: e3a06001 mov r6, #1 166ec: eaffffb8 b 165d4 <msdos_long_to_short+0xd8>
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
166f0: e3a06001 mov r6, #1 166f4: eaffffa9 b 165a0 <msdos_long_to_short+0xa4>
if (type == MSDOS_NAME_INVALID)
{
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
166f8: e1a06000 mov r6, r0 <== NOT EXECUTED 166fc: eaffffb4 b 165d4 <msdos_long_to_short+0xd8> <== NOT EXECUTED
if (i == lfn_len)
{
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: INVALID[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
16700: 01a06004 moveq r6, r4 <== NOT EXECUTED
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
16704: 1affff96 bne 16564 <msdos_long_to_short+0x68> <== NOT EXECUTED 16708: eaffffb1 b 165d4 <msdos_long_to_short+0xd8> <== NOT EXECUTED
0000d990 <msdos_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
d990: e92d4030 push {r4, r5, lr}
msdos_node_type_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
d994: e2034a0f and r4, r3, #61440 ; 0xf000
d998: e3540901 cmp r4, #16384 ; 0x4000
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
d99c: e1a0c003 mov ip, r3
d9a0: e1a05001 mov r5, r1
d9a4: e1a03002 mov r3, r2
msdos_node_type_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
d9a8: 0a000008 beq d9d0 <msdos_mknod+0x40>
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
d9ac: e3540902 cmp r4, #32768 ; 0x8000
{
type = MSDOS_REGULAR_FILE;
d9b0: 03a01004 moveq r1, #4
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
d9b4: 1a000007 bne d9d8 <msdos_mknod+0x48>
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
/* Create an MSDOS node */
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
d9b8: e58dc00c str ip, [sp, #12]
d9bc: e1a02005 mov r2, r5
d9c0: e3a0c000 mov ip, #0
d9c4: e58dc010 str ip, [sp, #16]
return rc;
}
d9c8: e8bd4030 pop {r4, r5, lr}
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
/* Create an MSDOS node */
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
d9cc: ea002194 b 16024 <msdos_creat_node>
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
d9d0: e3a01000 mov r1, #0
d9d4: eafffff7 b d9b8 <msdos_mknod+0x28>
else if (S_ISREG(mode))
{
type = MSDOS_REGULAR_FILE;
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
d9d8: eb002fb5 bl 198b4 <__errno> <== NOT EXECUTED
d9dc: e3a03016 mov r3, #22 <== NOT EXECUTED
d9e0: e5803000 str r3, [r0] <== NOT EXECUTED
/* Create an MSDOS node */
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
return rc;
}
d9e4: e3e00000 mvn r0, #0 <== NOT EXECUTED
d9e8: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
0000d9f8 <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
)
{
d9f8: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
int rc = RC_OK;
fat_file_fd_t *old_fat_fd = old_loc->node_access;
d9fc: 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
)
{
da00: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
/*
* create new directory entry as "hard link", copying relevant info from
* existing file
*/
rc = msdos_creat_node(new_parent_loc,
da04: e1a00002 mov r0, r2 <== NOT EXECUTED
da08: e3a0c902 mov ip, #32768 ; 0x8000 <== NOT EXECUTED
da0c: e1a02003 mov r2, r3 <== 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
)
{
da10: 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,
da14: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED
da18: e3a01002 mov r1, #2 <== NOT EXECUTED
da1c: e58dc000 str ip, [sp] <== NOT EXECUTED
da20: e58d4004 str r4, [sp, #4] <== NOT EXECUTED
da24: eb00217e bl 16024 <msdos_creat_node> <== NOT EXECUTED
MSDOS_HARD_LINK,new_name,new_namelen,S_IFREG,
old_fat_fd);
if (rc != RC_OK)
da28: e3500000 cmp r0, #0 <== NOT EXECUTED
da2c: 0a000001 beq da38 <msdos_rename+0x40> <== NOT EXECUTED
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
return rc;
}
da30: e28dd008 add sp, sp, #8 <== NOT EXECUTED
da34: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
da38: e5950014 ldr r0, [r5, #20] <== NOT EXECUTED
da3c: e2841020 add r1, r4, #32 <== NOT EXECUTED
da40: e3a020e5 mov r2, #229 ; 0xe5 <== NOT EXECUTED
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
return rc;
}
da44: e28dd008 add sp, sp, #8 <== NOT EXECUTED
da48: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
da4c: ea0023b7 b 16930 <msdos_set_first_char4file_name> <== NOT EXECUTED
0000da50 <msdos_rmnod>:
#include "msdos.h"
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
da50: e92d40f0 push {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;
da54: e5914008 ldr r4, [r1, #8]
if (fat_fd->fat_file_type == MSDOS_DIRECTORY)
da58: 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;
da5c: e5910014 ldr r0, [r1, #20]
fat_file_fd_t *fat_fd = pathloc->node_access;
if (fat_fd->fat_file_type == MSDOS_DIRECTORY)
da60: 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)
{
da64: e24dd004 sub sp, sp, #4
da68: e1a05001 mov r5, r1
int rc = RC_OK;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
da6c: e5906008 ldr r6, [r0, #8]
fat_file_fd_t *fat_fd = pathloc->node_access;
if (fat_fd->fat_file_type == MSDOS_DIRECTORY)
da70: 1a00000c bne daa8 <msdos_rmnod+0x58>
{
bool is_empty = false;
da74: e28d2004 add r2, sp, #4
da78: 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);
da7c: e1a01004 mov r1, r4
da80: eb002400 bl 16a88 <msdos_dir_is_empty>
if (rc != RC_OK)
da84: e2507000 subs r7, r0, #0
da88: 1a00000b bne dabc <msdos_rmnod+0x6c>
{
return rc;
}
if (!is_empty)
da8c: e5dd3003 ldrb r3, [sp, #3]
da90: e3530000 cmp r3, #0
da94: 0a000014 beq daec <msdos_rmnod+0x9c>
/*
* We deny attempts to delete open directory (if directory is current
* directory we assume it is open one)
*/
if (fat_fd->links_num > 1)
da98: e5943008 ldr r3, [r4, #8]
da9c: e3530001 cmp r3, #1
daa0: 95950014 ldrls r0, [r5, #20]
daa4: 8a00000b bhi dad8 <msdos_rmnod+0x88>
* not used - mount() not implemenetd yet.
*/
}
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
daa8: e2841020 add r1, r4, #32
daac: e3a020e5 mov r2, #229 ; 0xe5
dab0: eb00239e bl 16930 <msdos_set_first_char4file_name>
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
dab4: e2507000 subs r7, r0, #0
dab8: 0a000002 beq dac8 <msdos_rmnod+0x78>
}
fat_file_mark_removed(&fs_info->fat, fat_fd);
return rc;
}
dabc: e1a00007 mov r0, r7
dac0: e28dd004 add sp, sp, #4
dac4: e8bd80f0 pop {r4, r5, r6, r7, pc}
if (rc != RC_OK)
{
return rc;
}
fat_file_mark_removed(&fs_info->fat, fat_fd);
dac8: e1a00006 mov r0, r6
dacc: e1a01004 mov r1, r4
dad0: eb001087 bl 11cf4 <fat_file_mark_removed>
return rc;
dad4: eafffff8 b dabc <msdos_rmnod+0x6c>
* We deny attempts to delete open directory (if directory is current
* directory we assume it is open one)
*/
if (fat_fd->links_num > 1)
{
rtems_set_errno_and_return_minus_one(EBUSY);
dad8: eb002f75 bl 198b4 <__errno> <== NOT EXECUTED
dadc: e3a03010 mov r3, #16 <== NOT EXECUTED
dae0: e5803000 str r3, [r0] <== NOT EXECUTED
dae4: e3e07000 mvn r7, #0 <== NOT EXECUTED
dae8: eafffff3 b dabc <msdos_rmnod+0x6c> <== NOT EXECUTED
return rc;
}
if (!is_empty)
{
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
daec: eb002f70 bl 198b4 <__errno>
daf0: e3a0305a mov r3, #90 ; 0x5a
daf4: e5803000 str r3, [r0]
daf8: e3e07000 mvn r7, #0
dafc: eaffffee b dabc <msdos_rmnod+0x6c>
00016930 <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
)
{
16930: e92d43f0 push {r4, r5, r6, r7, r8, r9, lr}
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
16934: e5904008 ldr r4, [r0, #8]
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
16938: e5916000 ldr r6, [r1]
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
1693c: e594303c ldr r3, [r4, #60] ; 0x3c
)
{
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;
16940: e2819008 add r9, r1, #8
16944: e8990300 ldm r9, {r8, r9}
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
16948: e24dd010 sub sp, sp, #16
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) &&
1694c: e1560003 cmp r6, r3
)
{
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;
16950: e58d8008 str r8, [sp, #8] 16954: e58d900c str r9, [sp, #12]
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
16958: 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;
fat_pos_t end = dir_pos->sname;
1695c: e5918004 ldr r8, [r1, #4]
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
16960: 0a00003d beq 16a5c <msdos_set_first_char4file_name+0x12c>
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
else
dir_block_size = fs_info->fat.vol.bpc;
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
16964: e5913008 ldr r3, [r1, #8] <== NOT EXECUTED 16968: e3730001 cmn r3, #1 <== NOT EXECUTED
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
else
dir_block_size = fs_info->fat.vol.bpc;
1696c: e1d450b6 ldrh r5, [r4, #6] <== NOT EXECUTED
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
16970: 0a000040 beq 16a78 <msdos_set_first_char4file_name+0x148> <== NOT EXECUTED
start = dir_pos->sname;
16974: e59dc00c ldr ip, [sp, #12] 16978: e5d4e002 ldrb lr, [r4, #2] 1697c: e1d420b0 ldrh r2, [r4] 16980: e28d7004 add r7, sp, #4 16984: e59d1008 ldr r1, [sp, #8] 16988: ea000005 b 169a4 <msdos_set_first_char4file_name+0x74>
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
1698c: e28cc020 add ip, ip, #32
if (start.ofs >= dir_block_size)
16990: e155000c cmp r5, ip
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
16994: e58dc00c str ip, [sp, #12]
if (start.ofs >= dir_block_size)
16998: 9a00001e bls 16a18 <msdos_set_first_char4file_name+0xe8>
1699c: e5d4e002 ldrb lr, [r4, #2] 169a0: e1d420b0 ldrh r2, [r4]
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)) )
169a4: e3510000 cmp r1, #0
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
169a8: e2411002 sub r1, r1, #2
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)) )
169ac: 1a000003 bne 169c0 <msdos_set_first_char4file_name+0x90>
169b0: e5d4300e ldrb r3, [r4, #14] 169b4: e3130003 tst r3, #3
return fs_info->vol.rdir_loc;
169b8: 15941020 ldrne r1, [r4, #32]
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)) )
169bc: 1a000002 bne 169cc <msdos_set_first_char4file_name+0x9c>
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
169c0: e5d40005 ldrb r0, [r4, #5] <== NOT EXECUTED 169c4: e5943034 ldr r3, [r4, #52] ; 0x34 <== NOT EXECUTED 169c8: e0831011 add r1, r3, r1, lsl r0 <== NOT EXECUTED
*/
while (true)
{
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));
169cc: e2422001 sub r2, r2, #1
ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
169d0: e002200c and r2, r2, ip 169d4: e1a00004 mov r0, r4 169d8: e3a03001 mov r3, #1 169dc: e0811e3c add r1, r1, ip, lsr lr 169e0: e58d7000 str r7, [sp] 169e4: ebffedd1 bl 12130 <fat_sector_write>
1, &fchar);
if (ret < 0)
169e8: e3500000 cmp r0, #0
169ec: ba000018 blt 16a54 <msdos_set_first_char4file_name+0x124>
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
169f0: e28d1008 add r1, sp, #8
169f4: e8911002 ldm r1, {r1, ip}
169f8: e1560001 cmp r6, r1
169fc: 1affffe2 bne 1698c <msdos_set_first_char4file_name+0x5c>
16a00: e15c0008 cmp ip, r8
16a04: 1affffe0 bne 1698c <msdos_set_first_char4file_name+0x5c>
return rc;
start.ofs = 0;
}
}
return RC_OK;
16a08: e3a0c000 mov ip, #0
}
16a0c: e1a0000c mov r0, ip
16a10: e28dd010 add sp, sp, #16
16a14: e8bd83f0 pop {r4, r5, r6, r7, r8, r9, pc}
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
if (start.ofs >= dir_block_size)
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
16a18: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED 16a1c: e1560003 cmp r6, r3 <== NOT EXECUTED 16a20: 1a000002 bne 16a30 <msdos_set_first_char4file_name+0x100> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
16a24: 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) &&
16a28: e3130003 tst r3, #3 <== NOT EXECUTED 16a2c: 1afffff5 bne 16a08 <msdos_set_first_char4file_name+0xd8> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
break;
rc = fat_get_fat_cluster(&fs_info->fat, start.cln, &start.cln);
16a30: e1a00004 mov r0, r4 <== NOT EXECUTED 16a34: e28d2008 add r2, sp, #8 <== NOT EXECUTED 16a38: eb0004bb bl 17d2c <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
16a3c: e250c000 subs ip, r0, #0 <== NOT EXECUTED 16a40: 1afffff1 bne 16a0c <msdos_set_first_char4file_name+0xdc> <== NOT EXECUTED
return rc;
start.ofs = 0;
16a44: e58dc00c str ip, [sp, #12] <== NOT EXECUTED 16a48: e1d420b0 ldrh r2, [r4] <== NOT EXECUTED 16a4c: e5d4e002 ldrb lr, [r4, #2] <== NOT EXECUTED 16a50: eaffffcb b 16984 <msdos_set_first_char4file_name+0x54> <== 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;
16a54: e3e0c000 mvn ip, #0 <== NOT EXECUTED 16a58: eaffffeb b 16a0c <msdos_set_first_char4file_name+0xdc> <== NOT EXECUTED
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
16a5c: 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) &&
16a60: e3130003 tst r3, #3
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
16a64: 1594502c ldrne r5, [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) &&
16a68: 0affffbd beq 16964 <msdos_set_first_char4file_name+0x34>
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
else
dir_block_size = fs_info->fat.vol.bpc;
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
16a6c: e5913008 ldr r3, [r1, #8] 16a70: e3730001 cmn r3, #1
16a74: 1affffbe bne 16974 <msdos_set_first_char4file_name+0x44>
start = dir_pos->sname;
16a78: e891000c ldm r1, {r2, r3}
16a7c: e58d2008 str r2, [sp, #8]
16a80: e58d300c str r3, [sp, #12]
16a84: eaffffba b 16974 <msdos_set_first_char4file_name+0x44>
0000c6c8 <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 ) {
c6c8: 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 )
{
c6cc: e92d4070 push {r4, r5, r6, lr}
c6d0: e1a06001 mov r6, r1
int ret_val = -1;
uint32_t onebit;
if ( rqdata != NULL && rqdata->sectors_per_cluster > 0 ) {
c6d4: 0a00000f beq c718 <msdos_set_sectors_per_cluster_from_request+0x50>
c6d8: e5903008 ldr r3, [r0, #8]
c6dc: e3530000 cmp r3, #0
fmt_params->sectors_per_cluster = rqdata->sectors_per_cluster;
c6e0: 1581300c strne r3, [r1, #12]
msdos_format_param_t *fmt_params )
{
int ret_val = -1;
uint32_t onebit;
if ( rqdata != NULL && rqdata->sectors_per_cluster > 0 ) {
c6e4: 0a00000b beq c718 <msdos_set_sectors_per_cluster_from_request+0x50>
static int
msdos_set_sectors_per_cluster_from_request(
const msdos_format_request_param_t *rqdata,
msdos_format_param_t *fmt_params )
{
c6e8: e3a05008 mov r5, #8
c6ec: e3a04080 mov r4, #128 ; 0x80
* 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 ) {
c6f0: e1530004 cmp r3, r4
fmt_params->sectors_per_cluster = onebit;
if ( fmt_params->sectors_per_cluster
<= 32768L / fmt_params->bytes_per_sector ) {
c6f4: e3a00902 mov r0, #32768 ; 0x8000
* 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 ) {
c6f8: 3a000008 bcc c720 <msdos_set_sectors_per_cluster_from_request+0x58>
fmt_params->sectors_per_cluster = onebit;
c6fc: e586400c str r4, [r6, #12]
if ( fmt_params->sectors_per_cluster
<= 32768L / fmt_params->bytes_per_sector ) {
c700: e5961000 ldr r1, [r6]
c704: ebffd58d bl 1d40 <__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
c708: e1500004 cmp r0, r4
c70c: 3a000003 bcc c720 <msdos_set_sectors_per_cluster_from_request+0x58>
<= 32768L / fmt_params->bytes_per_sector ) {
/* value is small enough so this value is ok */
onebit = 1;
ret_val = 0;
c710: e3a00000 mov r0, #0
if (ret_val != 0) {
errno = EINVAL;
}
return ret_val;
}
c714: e8bd8070 pop {r4, r5, r6, pc}
msdos_format_param_t *fmt_params )
{
int ret_val = -1;
uint32_t onebit;
if ( rqdata != NULL && rqdata->sectors_per_cluster > 0 ) {
c718: e596300c ldr r3, [r6, #12]
c71c: eafffff1 b c6e8 <msdos_set_sectors_per_cluster_from_request+0x20>
* 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 ) {
c720: e2555001 subs r5, r5, #1
c724: e1a040a4 lsr r4, r4, #1
c728: 1596300c ldrne r3, [r6, #12]
c72c: 1affffef bne c6f0 <msdos_set_sectors_per_cluster_from_request+0x28>
}
}
}
if (ret_val != 0) {
errno = EINVAL;
c730: eb00345f bl 198b4 <__errno> <== NOT EXECUTED
c734: e3a03016 mov r3, #22 <== NOT EXECUTED
c738: e5803000 str r3, [r0] <== NOT EXECUTED
c73c: e3e00000 mvn r0, #0 <== NOT EXECUTED
c740: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00017ba4 <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;
17ba4: e5903024 ldr r3, [r0, #36] ; 0x24
return MSDOS_NAME_NOT_FOUND_ERR;
}
int
msdos_sync(rtems_libio_t *iop)
{
17ba8: 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;
17bac: e5934008 ldr r4, [r3, #8]
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
17bb0: e3a01000 mov r1, #0 17bb4: e594009c ldr r0, [r4, #156] ; 0x9c 17bb8: e1a02001 mov r2, r1 17bbc: ebffc31d bl 8838 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
17bc0: e3500000 cmp r0, #0
17bc4: 1a000006 bne 17be4 <msdos_sync+0x40>
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_sync(&fs_info->fat);
17bc8: e1a00004 mov r0, r4 17bcc: ebffec06 bl 12bec <fat_sync> 17bd0: e1a05000 mov r5, r0
rtems_semaphore_release(fs_info->vol_sema);
17bd4: e594009c ldr r0, [r4, #156] ; 0x9c 17bd8: ebffc35f bl 895c <rtems_semaphore_release>
return rc;
}
17bdc: e1a00005 mov r0, r5
17be0: e8bd8030 pop {r4, r5, pc}
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
17be4: eb000732 bl 198b4 <__errno> <== NOT EXECUTED 17be8: e3a03005 mov r3, #5 <== NOT EXECUTED 17bec: e5803000 str r3, [r0] <== NOT EXECUTED 17bf0: e3e05000 mvn r5, #0 <== NOT EXECUTED 17bf4: eafffff8 b 17bdc <msdos_sync+0x38> <== NOT EXECUTED
0000d778 <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);
d778: e5903008 ldr r3, [r0, #8]
rtems_fatal_error_occurred(0xdeadbeef);
}
}
void msdos_unlock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
d77c: 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);
d780: e593009c ldr r0, [r3, #156] ; 0x9c
d784: ebffec74 bl 895c <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL) {
d788: e3500000 cmp r0, #0
d78c: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_fatal_error_occurred(0xdeadbeef);
d790: e59f0000 ldr r0, [pc] ; d798 <msdos_unlock+0x20> <== NOT EXECUTED
d794: ebffee10 bl 8fdc <rtems_fatal_error_occurred> <== NOT EXECUTED
00002dcc <newlib_free_buffers>:
* task.
*/
int newlib_free_buffers(
FILE *fp
)
{
2dcc: e92d4010 push {r4, lr}
2dd0: e1a04000 mov r4, r0
switch ( fileno(fp) ) {
2dd4: eb002b8c bl dc0c <fileno>
2dd8: e3500002 cmp r0, #2
2ddc: 9a000003 bls 2df0 <newlib_free_buffers+0x24>
fp->_flags &= ~__SMBF;
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
2de0: e1a00004 mov r0, r4 <== NOT EXECUTED
2de4: eb002acb bl d918 <fclose> <== NOT EXECUTED
} return 0; }
2de8: e3a00000 mov r0, #0
2dec: e8bd8010 pop {r4, pc}
{
switch ( fileno(fp) ) {
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
2df0: e1d430bc ldrh r3, [r4, #12]
2df4: e3130080 tst r3, #128 ; 0x80
2df8: 0afffffa beq 2de8 <newlib_free_buffers+0x1c>
free( fp->_bf._base );
2dfc: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
2e00: ebfffdc3 bl 2514 <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
2e04: e1d420bc ldrh r2, [r4, #12] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
2e08: e3a03000 mov r3, #0 <== NOT EXECUTED
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
2e0c: e3c22080 bic r2, r2, #128 ; 0x80 <== NOT EXECUTED
2e10: e1c420bc strh r2, [r4, #12] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
2e14: e5843000 str r3, [r4] <== NOT EXECUTED
2e18: e5843010 str r3, [r4, #16] <== NOT EXECUTED
break;
default:
fclose(fp);
}
return 0;
}
2e1c: e3a00000 mov r0, #0 <== NOT EXECUTED
2e20: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00005bd4 <null_op_fsmount_me>:
rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data
)
{
return -1;
}
5bd4: e3e00000 mvn r0, #0 <== NOT EXECUTED
5bd8: e12fff1e bx lr <== NOT EXECUTED
00005be4 <null_op_fsunmount_me>:
static void null_op_fsunmount_me(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
/* Do nothing */
}
5be4: e12fff1e bx lr <== NOT EXECUTED
00005bac <null_op_link>:
const char *name,
size_t namelen
)
{
return -1;
}
5bac: e3e00000 mvn r0, #0 <== NOT EXECUTED
5bb0: e12fff1e bx lr <== NOT EXECUTED
00005bcc <null_op_mount>:
static int null_op_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
return -1;
}
5bcc: e3e00000 mvn r0, #0 <== NOT EXECUTED
5bd0: e12fff1e bx lr <== NOT EXECUTED
00005bf8 <null_op_readlink>:
char *buf,
size_t bufsize
)
{
return -1;
}
5bf8: e3e00000 mvn r0, #0 <== NOT EXECUTED
5bfc: e12fff1e bx lr <== NOT EXECUTED
00005c00 <null_op_rename>:
const char *name,
size_t namelen
)
{
return -1;
}
5c00: e3e00000 mvn r0, #0 <== NOT EXECUTED
5c04: e12fff1e bx lr <== NOT EXECUTED
00005ba4 <null_op_rmnod>:
const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *loc
)
{
return -1;
}
5ba4: e3e00000 mvn r0, #0 <== NOT EXECUTED
5ba8: e12fff1e bx lr <== NOT EXECUTED
00004cf4 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
4cf4: e92d4010 push {r4, lr}
int i;
if (tty->termios.c_oflag & OPOST) {
4cf8: e5913034 ldr r3, [r1, #52] ; 0x34
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
4cfc: e24dd004 sub sp, sp, #4
int i;
if (tty->termios.c_oflag & OPOST) {
4d00: e3130001 tst r3, #1
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
4d04: e1a04001 mov r4, r1
4d08: e5cd0000 strb r0, [sp]
int i;
if (tty->termios.c_oflag & OPOST) {
4d0c: 0a00001b beq 4d80 <oproc+0x8c>
switch (c) {
4d10: e20010ff and r1, r0, #255 ; 0xff
4d14: e2412008 sub r2, r1, #8
4d18: e3520005 cmp r2, #5
4d1c: 979ff102 ldrls pc, [pc, r2, lsl #2]
4d20: ea000005 b 4d3c <oproc+0x48>
4d24: 00004e38 .word 0x00004e38
4d28: 00004dd0 .word 0x00004dd0 <== NOT EXECUTED
4d2c: 00004e08 .word 0x00004e08 <== NOT EXECUTED
4d30: 00004d3c .word 0x00004d3c <== NOT EXECUTED
4d34: 00004d3c .word 0x00004d3c <== NOT EXECUTED
4d38: 00004d98 .word 0x00004d98 <== NOT EXECUTED
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
4d3c: e3130002 tst r3, #2
c = toupper(c);
4d40: e59f3104 ldr r3, [pc, #260] ; 4e4c <oproc+0x158>
4d44: e5933000 ldr r3, [r3]
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
4d48: 0a000006 beq 4d68 <oproc+0x74>
c = toupper(c);
4d4c: e0832001 add r2, r3, r1 <== NOT EXECUTED
4d50: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED
4d54: e2022003 and r2, r2, #3 <== NOT EXECUTED
4d58: e3520002 cmp r2, #2 <== NOT EXECUTED
4d5c: 02411020 subeq r1, r1, #32 <== NOT EXECUTED
4d60: e20110ff and r1, r1, #255 ; 0xff <== NOT EXECUTED
4d64: e5cd1000 strb r1, [sp] <== NOT EXECUTED
if (!iscntrl(c))
4d68: e0831001 add r1, r3, r1
4d6c: e5d13001 ldrb r3, [r1, #1]
4d70: e3130020 tst r3, #32
tty->column++;
4d74: 05943028 ldreq r3, [r4, #40] ; 0x28
4d78: 02833001 addeq r3, r3, #1
4d7c: 05843028 streq r3, [r4, #40] ; 0x28
break;
}
}
rtems_termios_puts (&c, 1, tty);
4d80: e1a0000d mov r0, sp
4d84: e3a01001 mov r1, #1
4d88: e1a02004 mov r2, r4
4d8c: ebffff92 bl 4bdc <rtems_termios_puts>
}
4d90: e28dd004 add sp, sp, #4
4d94: e8bd8010 pop {r4, pc}
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
4d98: e3130010 tst r3, #16 <== NOT EXECUTED
4d9c: 0a000002 beq 4dac <oproc+0xb8> <== NOT EXECUTED
4da0: e5942028 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED
4da4: e3520000 cmp r2, #0 <== NOT EXECUTED
4da8: 0afffff8 beq 4d90 <oproc+0x9c> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
4dac: e2132008 ands r2, r3, #8 <== NOT EXECUTED
c = '\n';
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
break;
}
tty->column = 0;
4db0: 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) {
4db4: 0afffff1 beq 4d80 <oproc+0x8c> <== NOT EXECUTED
c = '\n';
if (tty->termios.c_oflag & ONLRET)
4db8: 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';
4dbc: e3a0300a mov r3, #10 <== NOT EXECUTED
4dc0: e5cd3000 strb r3, [sp] <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
4dc4: 13a03000 movne r3, #0 <== NOT EXECUTED
4dc8: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
4dcc: eaffffeb b 4d80 <oproc+0x8c> <== NOT EXECUTED
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
4dd0: e5942028 ldr r2, [r4, #40] ; 0x28
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
4dd4: e2033b06 and r3, r3, #6144 ; 0x1800
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
4dd8: e2021007 and r1, r2, #7
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
4ddc: e3530b06 cmp r3, #6144 ; 0x1800
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
4de0: e2611008 rsb r1, r1, #8
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
rtems_termios_puts ( " ", i, tty);
return;
}
tty->column += i;
4de4: 10821001 addne r1, r2, r1
4de8: 15841028 strne r1, [r4, #40] ; 0x28
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
4dec: 1affffe3 bne 4d80 <oproc+0x8c>
tty->column += i;
4df0: e0822001 add r2, r2, r1
4df4: e5842028 str r2, [r4, #40] ; 0x28
rtems_termios_puts ( " ", i, tty);
4df8: e59f0050 ldr r0, [pc, #80] ; 4e50 <oproc+0x15c>
4dfc: e1a02004 mov r2, r4
4e00: ebffff75 bl 4bdc <rtems_termios_puts>
return;
4e04: eaffffe1 b 4d90 <oproc+0x9c>
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
4e08: e3130020 tst r3, #32
tty->column = 0;
4e0c: 13a02000 movne r2, #0
4e10: 15842028 strne r2, [r4, #40] ; 0x28
if (tty->termios.c_oflag & ONLCR) {
4e14: e3130004 tst r3, #4
4e18: 0affffd8 beq 4d80 <oproc+0x8c>
rtems_termios_puts ("\r", 1, tty);
4e1c: e59f0030 ldr r0, [pc, #48] ; 4e54 <oproc+0x160>
4e20: e3a01001 mov r1, #1
4e24: e1a02004 mov r2, r4
4e28: ebffff6b bl 4bdc <rtems_termios_puts>
tty->column = 0;
4e2c: e3a03000 mov r3, #0
4e30: e5843028 str r3, [r4, #40] ; 0x28
4e34: eaffffd1 b 4d80 <oproc+0x8c>
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
4e38: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
4e3c: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
4e40: c2433001 subgt r3, r3, #1 <== NOT EXECUTED
4e44: c5843028 strgt r3, [r4, #40] ; 0x28 <== NOT EXECUTED
4e48: eaffffcc b 4d80 <oproc+0x8c> <== NOT EXECUTED
00003960 <partition_free>:
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
{
3960: e92d4070 push {r4, r5, r6, lr}
int part_num;
if (part_desc == NULL)
3964: e2506000 subs r6, r0, #0
3968: 08bd8070 popeq {r4, r5, r6, pc}
return;
if (is_extended(part_desc->sys_type))
396c: e5d63001 ldrb r3, [r6, #1]
3970: e3530005 cmp r3, #5
3974: 13530085 cmpne r3, #133 ; 0x85
3978: 1a000005 bne 3994 <partition_free+0x34>
*
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
397c: e2865014 add r5, r6, #20 <== NOT EXECUTED
3980: e3a04004 mov r4, #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]);
3984: e5b50004 ldr r0, [r5, #4]! <== NOT EXECUTED
3988: ebfffff4 bl 3960 <partition_free> <== NOT EXECUTED
if (part_desc == NULL)
return;
if (is_extended(part_desc->sys_type))
{
for (part_num = 0;
398c: e2544001 subs r4, r4, #1 <== NOT EXECUTED
3990: 1afffffb bne 3984 <partition_free+0x24> <== NOT EXECUTED
{
partition_free(part_desc->sub_part[part_num]);
}
}
free(part_desc);
3994: e1a00006 mov r0, r6
}
3998: e8bd4070 pop {r4, r5, r6, lr}
{
partition_free(part_desc->sub_part[part_num]);
}
}
free(part_desc);
399c: ea0003e0 b 4924 <free>
00003c44 <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)
{
3c44: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
3c48: e1a06001 mov r6, r1
3c4c: e24dd050 sub sp, sp, #80 ; 0x50
struct stat dev_stat;
rtems_status_code rc;
int fd;
fd = open(dev_name, O_RDONLY);
3c50: 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)
{
3c54: e1a07000 mov r7, r0
struct stat dev_stat;
rtems_status_code rc;
int fd;
fd = open(dev_name, O_RDONLY);
3c58: eb0006cb bl 578c <open>
if (fd < 0)
3c5c: e2505000 subs r5, r0, #0
{
return RTEMS_INTERNAL_ERROR;
3c60: b3a04019 movlt r4, #25
struct stat dev_stat;
rtems_status_code rc;
int fd;
fd = open(dev_name, O_RDONLY);
if (fd < 0)
3c64: aa000002 bge 3c74 <partition_table_get+0x30>
rc = read_mbr(fd, disk_desc);
close(fd);
return rc;
}
3c68: e1a00004 mov r0, r4
3c6c: e28dd050 add sp, sp, #80 ; 0x50
3c70: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
if (fd < 0)
{
return RTEMS_INTERNAL_ERROR;
}
rc = fstat(fd, &dev_stat);
3c74: e1a0100d mov r1, sp
3c78: eb000352 bl 49c8 <fstat>
if (rc != RTEMS_SUCCESSFUL)
3c7c: e2504000 subs r4, r0, #0
3c80: 0a000003 beq 3c94 <partition_table_get+0x50>
{
close(fd);
3c84: e1a00005 mov r0, r5 <== NOT EXECUTED
3c88: eb00027c bl 4680 <close> <== NOT EXECUTED
return RTEMS_INTERNAL_ERROR;
3c8c: e3a04019 mov r4, #25 <== NOT EXECUTED
3c90: eafffff4 b 3c68 <partition_table_get+0x24> <== NOT EXECUTED
}
strncpy (disk_desc->dev_name, dev_name, 15);
3c94: e1a01007 mov r1, r7
3c98: e3a0200f mov r2, #15
3c9c: e2860008 add r0, r6, #8
3ca0: eb0043e5 bl 14c3c <strncpy>
disk_desc->dev = dev_stat.st_rdev;
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
3ca4: e59d3040 ldr r3, [sp, #64] ; 0x40
close(fd);
return RTEMS_INTERNAL_ERROR;
}
strncpy (disk_desc->dev_name, dev_name, 15);
disk_desc->dev = dev_stat.st_rdev;
3ca8: e28d1018 add r1, sp, #24
3cac: e8910003 ldm r1, {r0, r1}
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
3cb0: e3530000 cmp r3, #0
3cb4: 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;
3cb8: e28d2050 add r2, sp, #80 ; 0x50
close(fd);
return RTEMS_INTERNAL_ERROR;
}
strncpy (disk_desc->dev_name, dev_name, 15);
disk_desc->dev = dev_stat.st_rdev;
3cbc: e8860003 stm r6, {r0, r1}
*/
static rtems_status_code
read_mbr(int fd, rtems_disk_desc_t *disk_desc)
{
int part_num;
rtems_sector_data_t *sector = NULL;
3cc0: 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);
3cc4: 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 :
3cc8: e5863018 str r3, [r6, #24]
rtems_part_desc_t *part_desc;
uint8_t *data;
rtems_status_code rc;
/* get MBR sector */
rc = get_sector(fd, 0, §or);
3ccc: e1a00005 mov r0, r5
3cd0: ebffff32 bl 39a0 <get_sector>
if (rc != RTEMS_SUCCESSFUL)
3cd4: e2504000 subs r4, r0, #0
{
if (sector)
3cd8: e59d0048 ldr r0, [sp, #72] ; 0x48
uint8_t *data;
rtems_status_code rc;
/* get MBR sector */
rc = get_sector(fd, 0, §or);
if (rc != RTEMS_SUCCESSFUL)
3cdc: 0a000004 beq 3cf4 <partition_table_get+0xb0>
{
if (sector)
3ce0: e3500000 cmp r0, #0 <== NOT EXECUTED
part_num++)
{
rc = data_to_part_desc(data, &part_desc);
if (rc != RTEMS_SUCCESSFUL)
{
free(sector);
3ce4: 1b00030e blne 4924 <free> <== NOT EXECUTED
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
RTEMS_IDE_SECTOR_SIZE;
rc = read_mbr(fd, disk_desc);
close(fd);
3ce8: e1a00005 mov r0, r5
3cec: eb000263 bl 4680 <close>
return rc;
3cf0: eaffffdc b 3c68 <partition_table_get+0x24>
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) &&
3cf4: e5d03202 ldrb r3, [r0, #514] ; 0x202
3cf8: e3530055 cmp r3, #85 ; 0x55
3cfc: 0a000002 beq 3d0c <partition_table_get+0xc8>
}
/* check if the partition table structure is MS-DOS style */
if (!msdos_signature_check(sector))
{
free(sector);
3d00: eb000307 bl 4924 <free> <== NOT EXECUTED
return RTEMS_INTERNAL_ERROR;
3d04: e3a04019 mov r4, #25 <== NOT EXECUTED
3d08: eafffff6 b 3ce8 <partition_table_get+0xa4> <== 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) &&
3d0c: e5d03203 ldrb r3, [r0, #515] ; 0x203
3d10: e35300aa cmp r3, #170 ; 0xaa
3d14: 1afffff9 bne 3d00 <partition_table_get+0xbc>
return RTEMS_INTERNAL_ERROR;
}
/* read and process 4 primary partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
3d18: e2800d07 add r0, r0, #448 ; 0x1c0
3d1c: e2808002 add r8, r0, #2
3d20: e1a0a006 mov sl, r6
3d24: e3a07001 mov r7, #1
3d28: e1a00008 mov r0, r8
3d2c: e28d104c add r1, sp, #76 ; 0x4c
3d30: ebffff3e bl 3a30 <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)
3d34: e2504000 subs r4, r0, #0
3d38: 1a000029 bne 3de4 <partition_table_get+0x1a0>
{
free(sector);
return rc;
}
if (part_desc != NULL)
3d3c: e59d304c ldr r3, [sp, #76] ; 0x4c
3d40: 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;
3d44: 19930006 ldmibne r3, {r1, r2}
3d48: 10812002 addne r2, r1, r2
return rc;
}
if (part_desc != NULL)
{
part_desc->log_id = part_num + 1;
3d4c: 15c37002 strbne r7, [r3, #2]
else
{
disk_desc->partitions[part_num] = NULL;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
3d50: e2877001 add r7, r7, #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;
3d54: 12422001 subne r2, r2, #1
else
{
disk_desc->partitions[part_num] = NULL;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
3d58: e20770ff and r7, r7, #255 ; 0xff
}
if (part_desc != NULL)
{
part_desc->log_id = part_num + 1;
part_desc->disk_desc = disk_desc;
3d5c: 15836010 strne r6, [r3, #16]
part_desc->end = part_desc->start + part_desc->size - 1;
3d60: 1583200c strne r2, [r3, #12]
disk_desc->partitions[part_num] = part_desc;
}
else
{
disk_desc->partitions[part_num] = NULL;
3d64: 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;
3d68: 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;
3d6c: e3570005 cmp r7, #5
else
{
disk_desc->partitions[part_num] = NULL;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
3d70: e2888010 add r8, r8, #16
3d74: e28aa004 add sl, sl, #4
/* read and process 4 primary partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (part_num = 0;
3d78: 1affffea bne 3d28 <partition_table_get+0xe4>
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
3d7c: e59d0048 ldr r0, [sp, #72] ; 0x48
3d80: eb0002e7 bl 4924 <free>
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;
3d84: e3a07000 mov r7, #0
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
3d88: e3a03004 mov r3, #4
3d8c: e5863024 str r3, [r6, #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;
3d90: e1a08007 mov r8, r7
* 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)
3d94: e2866028 add r6, r6, #40 ; 0x28
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];
3d98: e4962004 ldr r2, [r6], #4
if (part_desc != NULL && is_extended(part_desc->sys_type))
3d9c: e3520000 cmp r2, #0
/* There cannot be more than one extended partition,
but we are to process each primary partition */
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
3da0: e2877001 add r7, r7, #1
{
part_desc = disk_desc->partitions[part_num];
3da4: e58d204c str r2, [sp, #76] ; 0x4c
if (part_desc != NULL && is_extended(part_desc->sys_type))
3da8: 0a000003 beq 3dbc <partition_table_get+0x178>
3dac: e5d23001 ldrb r3, [r2, #1]
3db0: e3530005 cmp r3, #5
3db4: 13530085 cmpne r3, #133 ; 0x85
3db8: 0a000002 beq 3dc8 <partition_table_get+0x184>
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;
3dbc: e3570004 cmp r7, #4
3dc0: 1afffff4 bne 3d98 <partition_table_get+0x154>
3dc4: eaffffc7 b 3ce8 <partition_table_get+0xa4>
part_num++)
{
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);
3dc8: e5921004 ldr r1, [r2, #4]
3dcc: e1a00005 mov r0, r5
3dd0: ebffff46 bl 3af0 <read_extended_partition>
free(part_desc);
3dd4: e59d004c ldr r0, [sp, #76] ; 0x4c
3dd8: eb0002d1 bl 4924 <free>
disk_desc->partitions[part_num] = NULL;
3ddc: e5068004 str r8, [r6, #-4]
3de0: eafffff5 b 3dbc <partition_table_get+0x178>
part_num++)
{
rc = data_to_part_desc(data, &part_desc);
if (rc != RTEMS_SUCCESSFUL)
{
free(sector);
3de4: e59d0048 ldr r0, [sp, #72] ; 0x48 <== NOT EXECUTED
3de8: eb0002cd bl 4924 <free> <== NOT EXECUTED
3dec: eaffffbd b 3ce8 <partition_table_get+0xa4> <== NOT EXECUTED
00003a78 <pathconf>:
*/
long pathconf(
const char *path,
int name
)
{
3a78: e92d4030 push {r4, r5, lr}
3a7c: e1a05001 mov r5, r1
int status;
int fd;
fd = open( path, O_RDONLY );
3a80: e3a01000 mov r1, #0
3a84: ebffff76 bl 3864 <open>
if ( fd == -1 )
3a88: e3700001 cmn r0, #1
)
{
int status;
int fd;
fd = open( path, O_RDONLY );
3a8c: e1a04000 mov r4, r0
if ( fd == -1 )
return -1;
3a90: 01a05000 moveq r5, r0
{
int status;
int fd;
fd = open( path, O_RDONLY );
if ( fd == -1 )
3a94: 0a000004 beq 3aac <pathconf+0x34>
return -1;
status = fpathconf( fd, name );
3a98: e1a01005 mov r1, r5 <== NOT EXECUTED
3a9c: eb0013e6 bl 8a3c <fpathconf> <== NOT EXECUTED
3aa0: e1a05000 mov r5, r0 <== NOT EXECUTED
(void) close( fd );
3aa4: e1a00004 mov r0, r4 <== NOT EXECUTED
3aa8: eb0013c5 bl 89c4 <close> <== NOT EXECUTED
return status;
}
3aac: e1a00005 mov r0, r5
3ab0: e8bd8030 pop {r4, r5, pc}
0000bd84 <pipe_create>:
static uint16_t rtems_pipe_no = 0;
int pipe_create(
int filsdes[2]
)
{
bd84: e92d4030 push {r4, r5, lr}
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
bd88: e59f1120 ldr r1, [pc, #288] ; beb0 <pipe_create+0x12c>
static uint16_t rtems_pipe_no = 0;
int pipe_create(
int filsdes[2]
)
{
bd8c: e24dd010 sub sp, sp, #16
bd90: e1a04000 mov r4, r0
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
bd94: e59f0118 ldr r0, [pc, #280] ; beb4 <pipe_create+0x130>
bd98: eb000565 bl d334 <rtems_mkdir>
bd9c: e3500000 cmp r0, #0
return -1;
bda0: 13e03000 mvnne r3, #0
)
{
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
bda4: 1a00002d bne be60 <pipe_create+0xdc>
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
bda8: e59f3108 ldr r3, [pc, #264] ; beb8 <pipe_create+0x134>
bdac: e8930007 ldm r3, {r0, r1, r2}
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
bdb0: e59fc104 ldr ip, [pc, #260] ; bebc <pipe_create+0x138>
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
bdb4: e1a0300d mov r3, sp
bdb8: e8a30003 stmia r3!, {r0, r1}
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
bdbc: e1dc00b0 ldrh r0, [ip]
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
bdc0: e1c320b0 strh r2, [r3]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
bdc4: e59f10f4 ldr r1, [pc, #244] ; bec0 <pipe_create+0x13c>
bdc8: e2803001 add r3, r0, #1
bdcc: e1a02000 mov r2, r0
bdd0: e28d000a add r0, sp, #10
bdd4: e1cc30b0 strh r3, [ip]
bdd8: eb000ec8 bl f900 <sprintf>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
bddc: e1a0000d mov r0, sp
bde0: e3a01d06 mov r1, #384 ; 0x180
bde4: eb0004a5 bl d080 <mkfifo>
bde8: e2505000 subs r5, r0, #0
bdec: 1a000028 bne be94 <pipe_create+0x110>
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);
bdf0: e1a0000d mov r0, sp
bdf4: e3a01901 mov r1, #16384 ; 0x4000
bdf8: ebffdf62 bl 3b88 <open>
if (filsdes[0] < 0) {
bdfc: 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);
be00: e5840000 str r0, [r4]
if (filsdes[0] < 0) {
be04: ba000018 blt be6c <pipe_create+0xe8>
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]);
be08: e59f30b4 ldr r3, [pc, #180] ; bec4 <pipe_create+0x140>
be0c: e5933000 ldr r3, [r3]
be10: e1500003 cmp r0, r3
be14: 359f30ac ldrcc r3, [pc, #172] ; bec8 <pipe_create+0x144>
be18: 35933000 ldrcc r3, [r3]
be1c: 30800080 addcc r0, r0, r0, lsl #1
be20: 30835200 addcc r5, r3, r0, lsl #4
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
be24: e595300c ldr r3, [r5, #12]
be28: e3c33001 bic r3, r3, #1
be2c: e585300c str r3, [r5, #12]
filsdes[1] = open(fifopath, O_WRONLY);
be30: e1a0000d mov r0, sp
be34: e3a01001 mov r1, #1
be38: ebffdf52 bl 3b88 <open>
if (filsdes[1] < 0) {
be3c: 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);
be40: e5840004 str r0, [r4, #4]
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
be44: 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) {
be48: ba00000c blt be80 <pipe_create+0xfc>
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
be4c: e1a0000d mov r0, sp
be50: ebffeb0f bl 6a94 <unlink>
} if(err != 0)
be54: e3550000 cmp r5, #0
rtems_set_errno_and_return_minus_one(err);
return 0;
be58: 01a03005 moveq r3, r5
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
be5c: 1a00000f bne bea0 <pipe_create+0x11c>
rtems_set_errno_and_return_minus_one(err);
return 0;
}
be60: e1a00003 mov r0, r3
be64: e28dd010 add sp, sp, #16
be68: e8bd8030 pop {r4, r5, pc}
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
if (filsdes[0] < 0) {
err = errno;
be6c: eb000b69 bl ec18 <__errno>
be70: e5905000 ldr r5, [r0]
/* Delete file at errors, or else if pipe is successfully created
the file node will be deleted after it is closed by all. */
unlink(fifopath);
be74: e1a0000d mov r0, sp
be78: ebffeb05 bl 6a94 <unlink>
be7c: eafffff4 b be54 <pipe_create+0xd0>
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
if (filsdes[1] < 0) {
err = errno;
be80: eb000b64 bl ec18 <__errno>
be84: e5905000 ldr r5, [r0]
close(filsdes[0]);
be88: e5940000 ldr r0, [r4]
be8c: ebffdb5e bl 2c0c <close>
be90: eaffffed b be4c <pipe_create+0xc8>
memcpy(fifopath, "/tmp/.fifo", 10);
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
if (errno != EEXIST){
be94: eb000b5f bl ec18 <__errno> <== NOT EXECUTED
return -1;
be98: e3e03000 mvn r3, #0 <== NOT EXECUTED
be9c: eaffffef b be60 <pipe_create+0xdc> <== NOT EXECUTED
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
bea0: eb000b5c bl ec18 <__errno>
bea4: e3e03000 mvn r3, #0
bea8: e5805000 str r5, [r0]
beac: eaffffeb b be60 <pipe_create+0xdc>
0000d278 <pipe_ioctl>:
ioctl_command_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
d278: e59f3058 ldr r3, [pc, #88] ; d2d8 <pipe_ioctl+0x60>
d27c: e1510003 cmp r1, r3
pipe_control_t *pipe,
ioctl_command_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
d280: e92d4070 push {r4, r5, r6, lr}
d284: e1a04000 mov r4, r0
d288: e1a05002 mov r5, r2
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
d28c: 13e00015 mvnne r0, #21
ioctl_command_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
d290: 18bd8070 popne {r4, r5, r6, pc}
if (buffer == NULL)
d294: e3520000 cmp r2, #0
return -EFAULT;
d298: 03e0000d mvneq r0, #13
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
d29c: 08bd8070 popeq {r4, r5, r6, pc}
return -EFAULT;
if (! PIPE_LOCK(pipe))
d2a0: e3a01000 mov r1, #0
d2a4: e5940028 ldr r0, [r4, #40] ; 0x28
d2a8: e1a02001 mov r2, r1
d2ac: ebffeafb bl 7ea0 <rtems_semaphore_obtain>
d2b0: e2506000 subs r6, r0, #0
d2b4: 1a000005 bne d2d0 <pipe_ioctl+0x58>
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
d2b8: e594300c ldr r3, [r4, #12]
PIPE_UNLOCK(pipe);
d2bc: e5940028 ldr r0, [r4, #40] ; 0x28
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
d2c0: e5853000 str r3, [r5]
PIPE_UNLOCK(pipe);
d2c4: ebffeb3e bl 7fc4 <rtems_semaphore_release>
return 0;
d2c8: e1a00006 mov r0, r6
d2cc: e8bd8070 pop {r4, r5, r6, pc}
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
if (! PIPE_LOCK(pipe))
return -EINTR;
d2d0: e3e00003 mvn r0, #3 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
}
d2d4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
0000cf0c <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
cf0c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
cf10: e1a09001 mov r9, r1
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
cf14: e3a01000 mov r1, #0
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
cf18: e24dd004 sub sp, sp, #4
cf1c: e1a04000 mov r4, r0
cf20: e1a05002 mov r5, r2
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
cf24: e5900028 ldr r0, [r0, #40] ; 0x28
cf28: e1a02001 mov r2, r1
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
cf2c: e1a07003 mov r7, r3
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
cf30: ebffebda bl 7ea0 <rtems_semaphore_obtain>
cf34: e250a000 subs sl, r0, #0
return -EINTR;
cf38: 13e08003 mvnne r8, #3
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
cf3c: 1a000026 bne cfdc <pipe_read+0xd0>
return -EINTR;
while (read < count) {
cf40: e3550000 cmp r5, #0
cf44: 01a08005 moveq r8, r5
cf48: 01a06008 moveq r6, r8
cf4c: 0a00001e beq cfcc <pipe_read+0xc0>
cf50: e1a0800a mov r8, sl
while (PIPE_EMPTY(pipe)) {
cf54: e594200c ldr r2, [r4, #12]
cf58: e3520000 cmp r2, #0
cf5c: 1a000021 bne cfe8 <pipe_read+0xdc>
/* Not an error */
if (pipe->Writers == 0)
cf60: e5946014 ldr r6, [r4, #20]
cf64: e3560000 cmp r6, #0
cf68: 0a000017 beq cfcc <pipe_read+0xc0>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
cf6c: e597600c ldr r6, [r7, #12]
cf70: e2166001 ands r6, r6, #1
cf74: 1a000040 bne d07c <pipe_read+0x170>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
cf78: e5943018 ldr r3, [r4, #24]
cf7c: e2833001 add r3, r3, #1
cf80: e5843018 str r3, [r4, #24]
PIPE_UNLOCK(pipe);
cf84: e5940028 ldr r0, [r4, #40] ; 0x28
cf88: ebffec0d bl 7fc4 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
cf8c: e1a01006 mov r1, r6
cf90: e594002c ldr r0, [r4, #44] ; 0x2c
cf94: eb0003b7 bl de78 <rtems_barrier_wait>
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
cf98: e1a01006 mov r1, r6
cf9c: e1a02001 mov r2, r1
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
cfa0: e2506000 subs r6, r0, #0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
cfa4: e5940028 ldr r0, [r4, #40] ; 0x28
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
cfa8: 13e06003 mvnne r6, #3
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
cfac: ebffebbb bl 7ea0 <rtems_semaphore_obtain>
cfb0: e3500000 cmp r0, #0
cfb4: 1a000032 bne d084 <pipe_read+0x178>
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
cfb8: e5943018 ldr r3, [r4, #24]
if (ret != 0)
cfbc: e3560000 cmp r6, #0
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
cfc0: e2433001 sub r3, r3, #1
cfc4: e5843018 str r3, [r4, #24]
if (ret != 0)
cfc8: 0affffe1 beq cf54 <pipe_read+0x48>
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
cfcc: e5940028 ldr r0, [r4, #40] ; 0x28
cfd0: ebffebfb bl 7fc4 <rtems_semaphore_release>
out_nolock:
if (read > 0)
return read;
return ret;
cfd4: e3580000 cmp r8, #0
cfd8: d1a08006 movle r8, r6
}
cfdc: e1a00008 mov r0, r8
cfe0: e28dd004 add sp, sp, #4
cfe4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
cfe8: e5943008 ldr r3, [r4, #8]
cfec: e594b004 ldr fp, [r4, #4]
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
cff0: e06a6005 rsb r6, sl, r5
cff4: e1520006 cmp r2, r6
cff8: 31a06002 movcc r6, r2
chunk1 = pipe->Size - pipe->Start;
cffc: e063b00b rsb fp, r3, fp
if (chunk > chunk1) {
d000: e156000b cmp r6, fp
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
d004: e5941000 ldr r1, [r4]
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
d008: da00001f ble d08c <pipe_read+0x180>
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
d00c: e1a0200b mov r2, fp
d010: e0811003 add r1, r1, r3
d014: e089000a add r0, r9, sl
d018: eb000cdf bl 1039c <memcpy>
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
d01c: e08a000b add r0, sl, fp
d020: e0890000 add r0, r9, r0
d024: e5941000 ldr r1, [r4]
d028: e06b2006 rsb r2, fp, r6
d02c: eb000cda bl 1039c <memcpy>
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
d030: e5940008 ldr r0, [r4, #8]
pipe->Start %= pipe->Size;
d034: e5941004 ldr r1, [r4, #4]
d038: e0860000 add r0, r6, r0
d03c: eb003d00 bl 1c444 <__umodsi3>
pipe->Length -= chunk;
d040: e594300c ldr r3, [r4, #12]
d044: e0663003 rsb r3, r6, r3
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
d048: e3530000 cmp r3, #0
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
d04c: e5840008 str r0, [r4, #8]
pipe->Length -= chunk;
d050: e584300c str r3, [r4, #12]
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
d054: 05843008 streq r3, [r4, #8]
if (pipe->waitingWriters > 0)
d058: e594301c ldr r3, [r4, #28]
d05c: e3530000 cmp r3, #0
d060: 1a00000e bne d0a0 <pipe_read+0x194>
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
d064: e0888006 add r8, r8, r6
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
d068: e1580005 cmp r8, r5
d06c: e1a0a008 mov sl, r8
d070: 3affffb7 bcc cf54 <pipe_read+0x48>
d074: e3a06000 mov r6, #0
d078: eaffffd3 b cfcc <pipe_read+0xc0>
/* Not an error */
if (pipe->Writers == 0)
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
d07c: e3e0600a mvn r6, #10
d080: eaffffd1 b cfcc <pipe_read+0xc0>
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
d084: e3e06003 mvn r6, #3 <== NOT EXECUTED
d088: eaffffd1 b cfd4 <pipe_read+0xc8> <== NOT EXECUTED
if (chunk > chunk1) {
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
d08c: e089000a add r0, r9, sl
d090: e0811003 add r1, r1, r3
d094: e1a02006 mov r2, r6
d098: eb000cbf bl 1039c <memcpy>
d09c: eaffffe3 b d030 <pipe_read+0x124>
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
d0a0: e5940030 ldr r0, [r4, #48] ; 0x30
d0a4: e1a0100d mov r1, sp
d0a8: eb00035a bl de18 <rtems_barrier_release>
d0ac: eaffffec b d064 <pipe_read+0x158>
0000d0b0 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
d0b0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
d0b4: e2525000 subs r5, r2, #0
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
d0b8: e24dd004 sub sp, sp, #4
d0bc: e1a04000 mov r4, r0
d0c0: e1a09001 mov r9, r1
d0c4: e1a08003 mov r8, r3
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
d0c8: 01a07005 moveq r7, r5
)
{
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
d0cc: 1a000002 bne d0dc <pipe_write+0x2c>
#endif
if (written > 0)
return written;
return ret;
}
d0d0: e1a00007 mov r0, r7
d0d4: e28dd004 add sp, sp, #4
d0d8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
d0dc: e3a01000 mov r1, #0
d0e0: e5900028 ldr r0, [r0, #40] ; 0x28
d0e4: e1a02001 mov r2, r1
d0e8: ebffeb6c bl 7ea0 <rtems_semaphore_obtain>
d0ec: e250b000 subs fp, r0, #0
return -EINTR;
d0f0: 13e07003 mvnne r7, #3
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
d0f4: 1afffff5 bne d0d0 <pipe_write+0x20>
return -EINTR;
if (pipe->Readers == 0) {
d0f8: e5947010 ldr r7, [r4, #16]
d0fc: e3570000 cmp r7, #0
d100: 0a00004e beq d240 <pipe_write+0x190>
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
d104: e5946004 ldr r6, [r4, #4]
d108: e1550006 cmp r5, r6
d10c: 91a0a005 movls sl, r5
d110: 83a0a001 movhi sl, #1
d114: e1a0700b mov r7, fp
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
d118: e594200c ldr r2, [r4, #12]
d11c: e0623006 rsb r3, r2, r6
d120: e153000a cmp r3, sl
d124: 2a00001f bcs d1a8 <pipe_write+0xf8>
if (LIBIO_NODELAY(iop)) {
d128: e598600c ldr r6, [r8, #12]
d12c: e2166001 ands r6, r6, #1
d130: 1a000044 bne d248 <pipe_write+0x198>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
d134: e594301c ldr r3, [r4, #28]
d138: e2833001 add r3, r3, #1
d13c: e584301c str r3, [r4, #28]
PIPE_UNLOCK(pipe);
d140: e5940028 ldr r0, [r4, #40] ; 0x28
d144: ebffeb9e bl 7fc4 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
d148: e1a01006 mov r1, r6
d14c: e5940030 ldr r0, [r4, #48] ; 0x30
d150: eb000348 bl de78 <rtems_barrier_wait>
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
d154: e1a01006 mov r1, r6
d158: e1a02001 mov r2, r1
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
d15c: e2506000 subs r6, r0, #0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
d160: e5940028 ldr r0, [r4, #40] ; 0x28
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
d164: 13e06003 mvnne r6, #3
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
d168: ebffeb4c bl 7ea0 <rtems_semaphore_obtain>
d16c: e3500000 cmp r0, #0
d170: 1a000036 bne d250 <pipe_write+0x1a0>
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
d174: e594301c ldr r3, [r4, #28]
if (ret != 0)
d178: e3560000 cmp r6, #0
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
d17c: e2433001 sub r3, r3, #1
d180: e584301c str r3, [r4, #28]
if (ret != 0)
d184: 1a000028 bne d22c <pipe_write+0x17c>
goto out_locked;
if (pipe->Readers == 0) {
d188: e5943010 ldr r3, [r4, #16]
d18c: e3530000 cmp r3, #0
d190: 0a00002a beq d240 <pipe_write+0x190>
d194: e5946004 ldr r6, [r4, #4]
/* 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) {
d198: e594200c ldr r2, [r4, #12]
d19c: e0623006 rsb r3, r2, r6
d1a0: e153000a cmp r3, sl
d1a4: 3affffdf bcc d128 <pipe_write+0x78>
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
d1a8: e5940008 ldr r0, [r4, #8]
d1ac: e1a01006 mov r1, r6
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
d1b0: e06ba005 rsb sl, fp, r5
chunk1 = pipe->Size - PIPE_WSTART(pipe);
d1b4: e0820000 add r0, r2, r0
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
d1b8: e153000a cmp r3, sl
d1bc: 31a0a003 movcc sl, r3
chunk1 = pipe->Size - PIPE_WSTART(pipe);
d1c0: eb003c9f bl 1c444 <__umodsi3>
d1c4: e0606006 rsb r6, r0, r6
if (chunk > chunk1) {
d1c8: e15a0006 cmp sl, r6
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
d1cc: e5943000 ldr r3, [r4]
d1d0: e089100b add r1, r9, fp
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
if (chunk > chunk1) {
d1d4: da00001f ble d258 <pipe_write+0x1a8>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
d1d8: e1a02006 mov r2, r6
d1dc: e0830000 add r0, r3, r0
d1e0: eb000c6d bl 1039c <memcpy>
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
d1e4: e086100b add r1, r6, fp
d1e8: e5940000 ldr r0, [r4]
d1ec: e0891001 add r1, r9, r1
d1f0: e066200a rsb r2, r6, sl
d1f4: eb000c68 bl 1039c <memcpy>
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
d1f8: e594300c ldr r3, [r4, #12]
if (pipe->waitingReaders > 0)
d1fc: e5942018 ldr r2, [r4, #24]
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
d200: e083300a add r3, r3, sl
if (pipe->waitingReaders > 0)
d204: e3520000 cmp r2, #0
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
d208: e584300c str r3, [r4, #12]
if (pipe->waitingReaders > 0)
d20c: 1a000015 bne d268 <pipe_write+0x1b8>
PIPE_WAKEUPREADERS(pipe);
written += chunk;
d210: e087700a add r7, r7, sl
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
d214: e1550007 cmp r5, r7
d218: e1a0b007 mov fp, r7
d21c: 85946004 ldrhi r6, [r4, #4]
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
written += chunk;
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
d220: 83a0a001 movhi sl, #1
d224: 8affffbb bhi d118 <pipe_write+0x68>
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
d228: e3a06000 mov r6, #0
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
d22c: e5940028 ldr r0, [r4, #40] ; 0x28
d230: ebffeb63 bl 7fc4 <rtems_semaphore_release>
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
return written;
return ret;
d234: e3570000 cmp r7, #0
d238: d1a07006 movle r7, r6
d23c: eaffffa3 b d0d0 <pipe_write+0x20>
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
d240: e3e0601f mvn r6, #31
d244: eafffff8 b d22c <pipe_write+0x17c>
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
d248: e3e0600a mvn r6, #10
d24c: eafffff6 b d22c <pipe_write+0x17c>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
d250: e3e06003 mvn r6, #3 <== NOT EXECUTED
d254: eafffff6 b d234 <pipe_write+0x184> <== NOT EXECUTED
if (chunk > chunk1) {
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
d258: e0830000 add r0, r3, r0
d25c: e1a0200a mov r2, sl
d260: eb000c4d bl 1039c <memcpy>
d264: eaffffe3 b d1f8 <pipe_write+0x148>
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
d268: e594002c ldr r0, [r4, #44] ; 0x2c
d26c: e1a0100d mov r1, sp
d270: eb0002e8 bl de18 <rtems_barrier_release>
d274: eaffffe5 b d210 <pipe_write+0x160>
00003094 <putk>:
/**
* Kernel putk (e.g. puts) function requiring minimal infrastrure.
*/
void putk(const char *s)
{
3094: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3098: e1a04000 mov r4, r0 <== NOT EXECUTED
const char *p;
for (p=s ; *p ; p++ )
309c: e5d00000 ldrb r0, [r0] <== NOT EXECUTED
30a0: e3500000 cmp r0, #0 <== NOT EXECUTED
30a4: e59f5024 ldr r5, [pc, #36] ; 30d0 <putk+0x3c> <== NOT EXECUTED
30a8: 0a000004 beq 30c0 <putk+0x2c> <== NOT EXECUTED
BSP_output_char(*p);
30ac: e1a0e00f mov lr, pc <== NOT EXECUTED
30b0: e595f000 ldr pc, [r5] <== NOT EXECUTED
*/
void putk(const char *s)
{
const char *p;
for (p=s ; *p ; p++ )
30b4: e5f40001 ldrb r0, [r4, #1]! <== NOT EXECUTED
30b8: e3500000 cmp r0, #0 <== NOT EXECUTED
30bc: 1afffffa bne 30ac <putk+0x18> <== NOT EXECUTED
BSP_output_char(*p);
BSP_output_char('\n');
30c0: e3a0000a mov r0, #10 <== NOT EXECUTED
30c4: e1a0e00f mov lr, pc <== NOT EXECUTED
30c8: e595f000 ldr pc, [r5] <== NOT EXECUTED
}
30cc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
0000b6c0 <ramdisk_allocate>:
void *area_begin,
uint32_t media_block_size,
rtems_blkdev_bnum media_block_count,
bool trace
)
{
b6c0: e92d41f0 push {r4, r5, r6, r7, r8, lr}
b6c4: e1a04000 mov r4, r0
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
b6c8: e3a00010 mov r0, #16
void *area_begin,
uint32_t media_block_size,
rtems_blkdev_bnum media_block_count,
bool trace
)
{
b6cc: e1a05001 mov r5, r1
b6d0: e1a07002 mov r7, r2
b6d4: e20380ff and r8, r3, #255 ; 0xff
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
b6d8: ebffe18d bl 3d14 <malloc>
if (rd == NULL) {
b6dc: e2506000 subs r6, r0, #0
b6e0: 0a000008 beq b708 <ramdisk_allocate+0x48>
return NULL;
}
if (area_begin == NULL) {
b6e4: e3540000 cmp r4, #0
return NULL;
}
rd->malloced = true;
} else {
rd->malloced = false;
b6e8: 13a03000 movne r3, #0
b6ec: 15c6300d strbne r3, [r6, #13]
if (rd == NULL) {
return NULL;
}
if (area_begin == NULL) {
b6f0: 0a000006 beq b710 <ramdisk_allocate+0x50>
}
rd->block_size = media_block_size;
rd->block_num = media_block_count;
rd->area = area_begin;
rd->trace = trace;
rd->initialized = true;
b6f4: e3a03001 mov r3, #1
rd->malloced = true;
} else {
rd->malloced = false;
}
rd->block_size = media_block_size;
rd->block_num = media_block_count;
b6f8: e88600a0 stm r6, {r5, r7}
rd->area = area_begin;
b6fc: e5864008 str r4, [r6, #8]
rd->trace = trace;
b700: e5c6800e strb r8, [r6, #14]
rd->initialized = true;
b704: e5c6300c strb r3, [r6, #12]
return rd;
}
b708: e1a00006 mov r0, r6
b70c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
if (rd == NULL) {
return NULL;
}
if (area_begin == NULL) {
area_begin = calloc(media_block_count, media_block_size);
b710: e1a00007 mov r0, r7
b714: e1a01005 mov r1, r5
b718: ebffdf87 bl 353c <calloc>
if (area_begin == NULL) {
b71c: e2504000 subs r4, r0, #0
free(rd);
return NULL;
}
rd->malloced = true;
b720: 13a03001 movne r3, #1
b724: 15c6300d strbne r3, [r6, #13]
return NULL;
}
if (area_begin == NULL) {
area_begin = calloc(media_block_count, media_block_size);
if (area_begin == NULL) {
b728: 1afffff1 bne b6f4 <ramdisk_allocate+0x34>
free(rd);
b72c: e1a00006 mov r0, r6 <== NOT EXECUTED
b730: ebffe03c bl 3828 <free> <== NOT EXECUTED
return NULL;
b734: e1a06004 mov r6, r4 <== NOT EXECUTED
b738: eafffff2 b b708 <ramdisk_allocate+0x48> <== NOT EXECUTED
0000c9b4 <ramdisk_initialize>:
rtems_device_driver
ramdisk_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *arg __attribute__((unused)))
{
c9b4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
c9b8: e24dd01c sub sp, sp, #28
c9bc: e1a0b000 mov fp, 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();
c9c0: ebffdb96 bl 3820 <rtems_disk_io_initialize>
if (rc != RTEMS_SUCCESSFUL)
c9c4: e2505000 subs r5, r0, #0
c9c8: 11a00005 movne r0, r5
c9cc: 0a000001 beq c9d8 <ramdisk_initialize+0x24>
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
}
c9d0: e28dd01c add sp, sp, #28
c9d4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* 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));
c9d8: e59f7100 ldr r7, [pc, #256] ; cae0 <ramdisk_initialize+0x12c>
c9dc: e5976000 ldr r6, [r7]
c9e0: e3a01010 mov r1, #16
c9e4: e1a00006 mov r0, r6
c9e8: ebffdf12 bl 4638 <calloc>
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
c9ec: e3560000 cmp r6, #0
* 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));
c9f0: e1a04000 mov r4, r0
r->trace = false;
c9f4: e5c0500e strb r5, [r0, #14]
free(r->area);
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
c9f8: 01a00006 moveq r0, r6
* 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++)
c9fc: 0afffff3 beq c9d0 <ramdisk_initialize+0x1c>
ca00: e59f60dc ldr r6, [pc, #220] ; cae4 <ramdisk_initialize+0x130>
}
}
else
{
r->malloced = false;
r->initialized = true;
ca04: e58db00c str fp, [sp, #12]
ca08: e28da010 add sl, sp, #16
{
if (r->malloced)
{
free(r->area);
}
r->initialized = false;
ca0c: e1a09005 mov r9, r5
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
ca10: e59f30d0 ldr r3, [pc, #208] ; cae8 <ramdisk_initialize+0x134>
ca14: e8930007 ldm r3, {r0, r1, r2}
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
r->block_size = c->block_size;
r->block_num = c->block_num;
if (c->location == NULL)
ca18: e5963008 ldr r3, [r6, #8]
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
r->block_size = c->block_size;
r->block_num = c->block_num;
ca1c: e8960900 ldm r6, {r8, fp}
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;
ca20: e0822005 add r2, r2, r5
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
ca24: e1a0c00a mov ip, sl
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
r->block_size = c->block_size;
r->block_num = c->block_num;
if (c->location == NULL)
ca28: e3530000 cmp r3, #0
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
ca2c: e8ac0003 stmia ip!, {r0, r1}
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
ca30: e5cd2018 strb r2, [sp, #24]
r->block_size = c->block_size;
r->block_num = c->block_num;
ca34: e8840900 stm r4, {r8, fp}
if (c->location == NULL)
ca38: 0a00001d beq cab4 <ramdisk_initialize+0x100>
}
}
else
{
r->malloced = false;
r->initialized = true;
ca3c: e3a0c001 mov ip, #1 <== NOT EXECUTED
r->initialized = true;
}
}
else
{
r->malloced = false;
ca40: e5c4900d strb r9, [r4, #13] <== NOT EXECUTED
r->initialized = true;
ca44: e5c4c00c strb ip, [r4, #12] <== NOT EXECUTED
r->area = c->location;
ca48: e5843008 str r3, [r4, #8] <== NOT EXECUTED
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
ca4c: e59fc098 ldr ip, [pc, #152] ; caec <ramdisk_initialize+0x138>
ca50: e1a01005 mov r1, r5
ca54: e1a02008 mov r2, r8
ca58: e1a0300b mov r3, fp
ca5c: e59d000c ldr r0, [sp, #12]
ca60: e58d4004 str r4, [sp, #4]
ca64: e58dc000 str ip, [sp]
ca68: e58da008 str sl, [sp, #8]
ca6c: ebffdac9 bl 3598 <rtems_disk_create_phys>
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
ca70: e3500000 cmp r0, #0
ca74: 0a000003 beq ca88 <ramdisk_initialize+0xd4>
{
if (r->malloced)
ca78: e5d4300d ldrb r3, [r4, #13] <== NOT EXECUTED
ca7c: e3530000 cmp r3, #0 <== NOT EXECUTED
ca80: 1a000008 bne caa8 <ramdisk_initialize+0xf4> <== NOT EXECUTED
{
free(r->area);
}
r->initialized = false;
ca84: e5c4900c strb r9, [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++)
ca88: e5973000 ldr r3, [r7]
ca8c: e2855001 add r5, r5, #1
ca90: e1530005 cmp r3, r5
ca94: e286600c add r6, r6, #12
ca98: e2844010 add r4, r4, #16
ca9c: 8affffdb bhi ca10 <ramdisk_initialize+0x5c>
free(r->area);
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
caa0: e3a00000 mov r0, #0
caa4: eaffffc9 b c9d0 <ramdisk_initialize+0x1c>
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
{
if (r->malloced)
{
free(r->area);
caa8: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
caac: ebffdf9c bl 4924 <free> <== NOT EXECUTED
cab0: eafffff3 b ca84 <ramdisk_initialize+0xd0> <== NOT EXECUTED
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
r->block_size = c->block_size;
r->block_num = c->block_num;
if (c->location == NULL)
{
r->malloced = true;
cab4: e3a0c001 mov ip, #1
r->area = malloc(r->block_size * r->block_num);
cab8: e0000b98 mul r0, r8, fp
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;
cabc: e5c4c00d strb ip, [r4, #13]
r->area = malloc(r->block_size * r->block_num);
cac0: ebffe116 bl 4f20 <malloc>
if (r->area == NULL) /* No enough memory for this disk */
cac4: e3500000 cmp r0, #0
r->initialized = false;
continue;
}
else
{
r->initialized = true;
cac8: 13a02001 movne r2, #1
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);
cacc: e5840008 str r0, [r4, #8]
if (r->area == NULL) /* No enough memory for this disk */
{
r->initialized = false;
cad0: 05c4000c strbeq r0, [r4, #12]
continue;
}
else
{
r->initialized = true;
cad4: 15c4200c strbne r2, [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 */
cad8: 1affffdb bne ca4c <ramdisk_initialize+0x98>
cadc: eaffffe9 b ca88 <ramdisk_initialize+0xd4> <== NOT EXECUTED
0000b598 <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)
b598: e59fc118 ldr ip, [pc, #280] ; b6b8 <ramdisk_ioctl+0x120>
b59c: e151000c cmp r1, ip
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
b5a0: e92d41f0 push {r4, r5, r6, r7, r8, lr}
b5a4: e1a05002 mov r5, r2
static inline void *rtems_disk_get_driver_data(
const rtems_disk_device *dd
)
{
return dd->driver_data;
b5a8: e590603c ldr r6, [r0, #60] ; 0x3c
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
b5ac: 0a000004 beq b5c4 <ramdisk_ioctl+0x2c>
b5b0: e59fc104 ldr ip, [pc, #260] ; b6bc <ramdisk_ioctl+0x124>
b5b4: e151000c cmp r1, ip
b5b8: 0a000009 beq b5e4 <ramdisk_ioctl+0x4c>
break;
}
errno = EINVAL;
return -1;
}
b5bc: e8bd41f0 pop {r4, r5, r6, r7, r8, lr}
ramdisk_free(rd);
}
break;
default:
return rtems_blkdev_ioctl (dd, req, argp);
b5c0: ea000a71 b df8c <rtems_blkdev_ioctl>
}
break;
}
case RTEMS_BLKIO_DELETED:
if (rd->free_at_delete_request) {
b5c4: e5d6300f ldrb r3, [r6, #15]
b5c8: e3530000 cmp r3, #0
b5cc: 1a000036 bne b6ac <ramdisk_ioctl+0x114>
default:
return rtems_blkdev_ioctl (dd, req, argp);
break;
}
errno = EINVAL;
b5d0: eb0019d5 bl 11d2c <__errno>
b5d4: e3a03016 mov r3, #22
b5d8: e5803000 str r3, [r0]
return -1;
b5dc: e3e00000 mvn r0, #0
}
b5e0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
b5e4: e5927000 ldr r7, [r2]
b5e8: e3570000 cmp r7, #0
b5ec: 1a000015 bne b648 <ramdisk_ioctl+0xb0>
#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++)
b5f0: e5923010 ldr r3, [r2, #16]
b5f4: e3530000 cmp r3, #0
#endif
static int
ramdisk_read(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *from = rd->area;
b5f8: e5968008 ldr r8, [r6, #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++)
b5fc: 0a00000b beq b630 <ramdisk_ioctl+0x98>
b600: e2824018 add r4, r2, #24
#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);
b604: e5943000 ldr r3, [r4]
b608: e5961000 ldr r1, [r6]
b60c: e5940008 ldr r0, [r4, #8]
b610: e5942004 ldr r2, [r4, #4]
b614: e0218193 mla r1, r3, r1, r8
b618: eb001bfd bl 12614 <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++)
b61c: e5953010 ldr r3, [r5, #16]
b620: e2877001 add r7, r7, #1
b624: e1570003 cmp r7, r3
b628: e2844010 add r4, r4, #16
b62c: 3afffff4 bcc b604 <ramdisk_ioctl+0x6c>
static inline void rtems_blkdev_request_done(
rtems_blkdev_request *req,
rtems_status_code status
)
{
(*req->done)(req, status);
b630: e1a00005 mov r0, r5
b634: e3a01000 mov r1, #0
b638: e1a0e00f mov lr, pc
b63c: e595f004 ldr pc, [r5, #4]
{
case RTEMS_BLKDEV_REQ_READ:
return ramdisk_read(rd, r);
case RTEMS_BLKDEV_REQ_WRITE:
return ramdisk_write(rd, r);
b640: e3a00000 mov r0, #0
b644: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
b648: e3570001 cmp r7, #1
b64c: 0a000004 beq b664 <ramdisk_ioctl+0xcc>
case RTEMS_BLKDEV_REQ_WRITE:
return ramdisk_write(rd, r);
default:
errno = EINVAL;
b650: eb0019b5 bl 11d2c <__errno> <== NOT EXECUTED
b654: e3a03016 mov r3, #22 <== NOT EXECUTED
b658: e5803000 str r3, [r0] <== NOT EXECUTED
return -1;
b65c: e3e00000 mvn r0, #0 <== NOT EXECUTED
b660: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
b664: e5923010 ldr r3, [r2, #16]
b668: e3530000 cmp r3, #0
}
static int
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *to = rd->area;
b66c: e5968008 ldr r8, [r6, #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++)
b670: 0affffee beq b630 <ramdisk_ioctl+0x98>
b674: e2824018 add r4, r2, #24
b678: e3a07000 mov r7, #0
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
b67c: e5943000 ldr r3, [r4]
b680: e5960000 ldr r0, [r6]
b684: e5941008 ldr r1, [r4, #8]
b688: e5942004 ldr r2, [r4, #4]
b68c: e0208093 mla r0, r3, r0, r8
b690: eb001bdf bl 12614 <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++)
b694: e5953010 ldr r3, [r5, #16]
b698: e2877001 add r7, r7, #1
b69c: e1570003 cmp r7, r3
b6a0: e2844010 add r4, r4, #16
b6a4: 3afffff4 bcc b67c <ramdisk_ioctl+0xe4>
b6a8: eaffffe0 b b630 <ramdisk_ioctl+0x98>
break;
}
case RTEMS_BLKIO_DELETED:
if (rd->free_at_delete_request) {
ramdisk_free(rd);
b6ac: e1a00006 mov r0, r6
b6b0: eb000021 bl b73c <ramdisk_free>
b6b4: eaffffc5 b b5d0 <ramdisk_ioctl+0x38>
0000b76c <ramdisk_register>:
rtems_blkdev_bnum media_block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
b76c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
b770: e24dd010 sub sp, sp, #16
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_device_major_number major = 0;
b774: e3a06000 mov r6, #0
b778: e28dc010 add ip, sp, #16
b77c: e52c6004 str r6, [ip, #-4]!
rtems_blkdev_bnum media_block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
b780: e1a0e002 mov lr, r2
b784: e1a05000 mov r5, r0
b788: e1a04001 mov r4, r1
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
b78c: e1a00006 mov r0, r6
b790: e59f108c ldr r1, [pc, #140] ; b824 <ramdisk_register+0xb8>
b794: e1a0200c mov r2, ip
rtems_blkdev_bnum media_block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
b798: e1a06003 mov r6, r3
b79c: e59d9030 ldr r9, [sp, #48] ; 0x30
b7a0: e20e80ff and r8, lr, #255 ; 0xff
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);
b7a4: ebfff2cf bl 82e8 <rtems_io_register_driver>
if (sc != RTEMS_SUCCESSFUL) {
b7a8: e2507000 subs r7, r0, #0
return RTEMS_UNSATISFIED;
b7ac: 13a0000d movne r0, #13
rtems_device_major_number major = 0;
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
if (sc != RTEMS_SUCCESSFUL) {
b7b0: 0a000001 beq b7bc <ramdisk_register+0x50>
}
*dev_ptr = dev;
return RTEMS_SUCCESSFUL;
}
b7b4: e28dd010 add sp, sp, #16
b7b8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
if (sc != RTEMS_SUCCESSFUL) {
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, media_block_size, media_block_count, trace);
b7bc: e1a03008 mov r3, r8
b7c0: e1a01005 mov r1, r5
b7c4: e1a02004 mov r2, r4
b7c8: ebffffbc bl b6c0 <ramdisk_allocate>
if (rd == NULL) {
b7cc: e2508000 subs r8, r0, #0
b7d0: 0a00000f beq b814 <ramdisk_register+0xa8>
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
b7d4: e59da00c ldr sl, [sp, #12]
return RTEMS_UNSATISFIED;
}
dev = rtems_filesystem_make_dev_t(major, 0);
sc = rtems_disk_create_phys(
b7d8: e59fc048 ldr ip, [pc, #72] ; b828 <ramdisk_register+0xbc>
b7dc: e1a0000a mov r0, sl
b7e0: e1a01007 mov r1, r7
b7e4: e1a02005 mov r2, r5
b7e8: e1a03004 mov r3, r4
b7ec: e58dc000 str ip, [sp]
b7f0: e58d8004 str r8, [sp, #4]
b7f4: e58d6008 str r6, [sp, #8]
b7f8: ebffdca5 bl 2a94 <rtems_disk_create_phys>
media_block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
b7fc: e3500000 cmp r0, #0
rtems_io_unregister_driver(major);
return RTEMS_UNSATISFIED;
}
*dev_ptr = dev;
b800: 0589a000 streq sl, [r9]
b804: 05890004 streq r0, [r9, #4]
media_block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
b808: 0affffe9 beq b7b4 <ramdisk_register+0x48>
ramdisk_free(rd);
b80c: e1a00008 mov r0, r8 <== NOT EXECUTED
b810: ebffffc9 bl b73c <ramdisk_free> <== NOT EXECUTED
rtems_io_unregister_driver(major);
b814: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED
b818: ebfff30d bl 8454 <rtems_io_unregister_driver> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
b81c: e3a0000d mov r0, #13 <== NOT EXECUTED
b820: eaffffe3 b b7b4 <ramdisk_register+0x48> <== NOT EXECUTED
00018c14 <read>:
size_t count
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
18c14: e59f3080 ldr r3, [pc, #128] ; 18c9c <read+0x88> 18c18: e5933000 ldr r3, [r3] 18c1c: e1500003 cmp r0, r3
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
18c20: e92d4010 push {r4, lr}
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
18c24: 2a000012 bcs 18c74 <read+0x60>
iop = rtems_libio_iop( fd );
18c28: e59f4070 ldr r4, [pc, #112] ; 18ca0 <read+0x8c> 18c2c: e5944000 ldr r4, [r4] 18c30: e0800080 add r0, r0, r0, lsl #1 18c34: e0840200 add r0, r4, r0, lsl #4
rtems_libio_check_is_open( iop );
18c38: e590400c ldr r4, [r0, #12] 18c3c: e3140c01 tst r4, #256 ; 0x100
18c40: 0a00000b beq 18c74 <read+0x60> rtems_libio_check_buffer( buffer );
18c44: e3510000 cmp r1, #0
18c48: 0a00000e beq 18c88 <read+0x74> rtems_libio_check_count( count );
18c4c: e3520000 cmp r2, #0
18c50: 0a000005 beq 18c6c <read+0x58> rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
18c54: e3140002 tst r4, #2
18c58: 0a000005 beq 18c74 <read+0x60>
/*
* Now process the read().
*/
return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
18c5c: e5903020 ldr r3, [r0, #32]
18c60: e1a0e00f mov lr, pc
18c64: e593f008 ldr pc, [r3, #8]
18c68: e8bd8010 pop {r4, 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 );
18c6c: e1a00002 mov r0, r2
/*
* Now process the read().
*/
return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
}
18c70: e8bd8010 pop {r4, pc}
rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
18c74: ebffd2db bl d7e8 <__errno>
18c78: e3a03009 mov r3, #9
18c7c: e5803000 str r3, [r0]
18c80: e3e00000 mvn r0, #0
18c84: e8bd8010 pop {r4, pc}
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
18c88: ebffd2d6 bl d7e8 <__errno> <== NOT EXECUTED
18c8c: e3a03016 mov r3, #22 <== NOT EXECUTED
18c90: e5803000 str r3, [r0] <== NOT EXECUTED
18c94: e3e00000 mvn r0, #0 <== NOT EXECUTED
18c98: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00003af0 <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)
{
3af0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
int i;
rtems_sector_data_t *sector = NULL;
3af4: e3a03000 mov r3, #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)
{
3af8: e24dd008 sub sp, sp, #8
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))
3afc: e2524000 subs r4, 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)
{
3b00: e1a08000 mov r8, r0
3b04: e1a07001 mov r7, r1
int i;
rtems_sector_data_t *sector = NULL;
3b08: 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))
3b0c: 0a00000f beq 3b50 <read_extended_partition+0x60>
3b10: e5943010 ldr r3, [r4, #16]
3b14: e3530000 cmp r3, #0
3b18: 0a00000c beq 3b50 <read_extended_partition+0x60>
{
return RTEMS_INTERNAL_ERROR;
}
/* get start sector of current extended partition */
here = ext_part->start;
3b1c: e5949004 ldr r9, [r4, #4]
/* get first extended partition sector */
rc = get_sector(fd, here, §or);
3b20: e1a0200d mov r2, sp
3b24: e1a01009 mov r1, r9
3b28: ebffff9c bl 39a0 <get_sector>
if (rc != RTEMS_SUCCESSFUL)
3b2c: e2505000 subs r5, r0, #0
{
if (sector)
3b30: e59d0000 ldr r0, [sp]
here = ext_part->start;
/* get first extended partition sector */
rc = get_sector(fd, here, §or);
if (rc != RTEMS_SUCCESSFUL)
3b34: 1a000009 bne 3b60 <read_extended_partition+0x70>
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) &&
3b38: e5d03202 ldrb r3, [r0, #514] ; 0x202
3b3c: e3530055 cmp r3, #85 ; 0x55
3b40: 0a00000a beq 3b70 <read_extended_partition+0x80>
return rc;
}
if (!msdos_signature_check(sector))
{
free(sector);
3b44: eb000376 bl 4924 <free> <== NOT EXECUTED
return RTEMS_INTERNAL_ERROR;
3b48: e3a05019 mov r5, #25 <== NOT EXECUTED
3b4c: ea000000 b 3b54 <read_extended_partition+0x64> <== NOT EXECUTED
rtems_part_desc_t *new_part_desc;
rtems_status_code rc;
if ((ext_part == NULL) || (ext_part->disk_desc == NULL))
{
return RTEMS_INTERNAL_ERROR;
3b50: e3a05019 mov r5, #25 <== NOT EXECUTED
}
free(sector);
return RTEMS_SUCCESSFUL;
}
3b54: e1a00005 mov r0, r5
3b58: e28dd008 add sp, sp, #8
3b5c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* get first extended partition sector */
rc = get_sector(fd, here, §or);
if (rc != RTEMS_SUCCESSFUL)
{
if (sector)
3b60: e3500000 cmp r0, #0 <== NOT EXECUTED
3b64: 0afffffa beq 3b54 <read_extended_partition+0x64> <== NOT EXECUTED
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
3b68: eb00036d bl 4924 <free> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3b6c: eafffff8 b 3b54 <read_extended_partition+0x64> <== 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) &&
3b70: e5d03203 ldrb r3, [r0, #515] ; 0x203
3b74: e35300aa cmp r3, #170 ; 0xaa
3b78: 1afffff1 bne 3b44 <read_extended_partition+0x54>
* 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)
3b7c: e2800e1d add r0, r0, #464 ; 0x1d0
3b80: e280a002 add sl, r0, #2
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) &&
3b84: e1a06004 mov r6, r4
* 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)
3b88: e284b010 add fp, r4, #16
3b8c: e24a0010 sub r0, sl, #16
3b90: e28d1004 add r1, sp, #4
3b94: ebffffa5 bl 3a30 <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)
3b98: e2505000 subs r5, r0, #0
3b9c: 1a000025 bne 3c38 <read_extended_partition+0x148>
{
free(sector);
return rc;
}
if (new_part_desc == NULL)
3ba0: e59d2004 ldr r2, [sp, #4]
3ba4: e3520000 cmp r2, #0
3ba8: 0a000013 beq 3bfc <read_extended_partition+0x10c>
{
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
continue;
}
ext_part->sub_part[i] = new_part_desc;
3bac: 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))
3bb0: 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;
3bb4: e5943010 ldr r3, [r4, #16]
if (is_extended(new_part_desc->sys_type))
3bb8: e3510005 cmp r1, #5
3bbc: 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;
3bc0: e5824014 str r4, [r2, #20]
new_part_desc->disk_desc = ext_part->disk_desc;
3bc4: e5823010 str r3, [r2, #16]
if (is_extended(new_part_desc->sys_type))
3bc8: 0a000012 beq 3c18 <read_extended_partition+0x128>
{
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;
3bcc: e9924002 ldmib r2, {r1, lr}
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;
3bd0: e593c024 ldr ip, [r3, #36] ; 0x24
new_part_desc->log_id = ++disk_desc->last_log_id;
new_part_desc->start += here;
3bd4: e0891001 add r1, r9, r1
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
3bd8: e24ee001 sub lr, lr, #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;
3bdc: e28c0001 add r0, ip, #1
new_part_desc->start += here;
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
3be0: e08ee001 add lr, lr, r1
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;
3be4: e28cc00a add ip, ip, #10
3be8: e783210c str r2, [r3, ip, lsl #2]
new_part_desc->log_id = ++disk_desc->last_log_id;
3bec: e5830024 str r0, [r3, #36] ; 0x24
3bf0: e5c20002 strb r0, [r2, #2]
new_part_desc->start += here;
3bf4: e5821004 str r1, [r2, #4]
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
3bf8: e582e00c str lr, [r2, #12]
3bfc: 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++)
3c00: 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;
3c04: e28aa010 add sl, sl, #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++)
3c08: 1affffdf bne 3b8c <read_extended_partition+0x9c>
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
3c0c: e59d0000 ldr r0, [sp]
3c10: eb000343 bl 4924 <free>
3c14: eaffffce b 3b54 <read_extended_partition+0x64>
new_part_desc->disk_desc = ext_part->disk_desc;
if (is_extended(new_part_desc->sys_type))
{
new_part_desc->log_id = EMPTY_PARTITION;
new_part_desc->start += start;
3c18: e5923004 ldr r3, [r2, #4]
3c1c: e0833007 add r3, r3, r7
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;
3c20: e5c25002 strb r5, [r2, #2]
new_part_desc->start += start;
3c24: e5823004 str r3, [r2, #4]
read_extended_partition(fd, start, new_part_desc);
3c28: e1a00008 mov r0, r8
3c2c: e1a01007 mov r1, r7
3c30: ebffffae bl 3af0 <read_extended_partition>
3c34: eafffff0 b 3bfc <read_extended_partition+0x10c>
* and parse the next one
*/
rc = data_to_part_desc(data, &new_part_desc);
if (rc != RTEMS_SUCCESSFUL)
{
free(sector);
3c38: e59d0000 ldr r0, [sp] <== NOT EXECUTED
3c3c: eb000338 bl 4924 <free> <== NOT EXECUTED
return rc;
3c40: eaffffc3 b 3b54 <read_extended_partition+0x64> <== NOT EXECUTED
00003ff0 <readv>:
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
3ff0: e59f3120 ldr r3, [pc, #288] ; 4118 <readv+0x128>
3ff4: e5933000 ldr r3, [r3]
3ff8: e1500003 cmp r0, r3
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
3ffc: e92d41f0 push {r4, r5, r6, r7, r8, lr}
4000: e1a04002 mov r4, r2
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
4004: 2a00003e bcs 4104 <readv+0x114>
iop = rtems_libio_iop( fd );
4008: e59f310c ldr r3, [pc, #268] ; 411c <readv+0x12c>
400c: e5933000 ldr r3, [r3]
4010: e0800080 add r0, r0, r0, lsl #1
4014: e0837200 add r7, r3, r0, lsl #4
rtems_libio_check_is_open( iop );
4018: e597300c ldr r3, [r7, #12]
401c: e3130c01 tst r3, #256 ; 0x100
4020: 0a000037 beq 4104 <readv+0x114>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
4024: e3130002 tst r3, #2
4028: 0a000035 beq 4104 <readv+0x114>
/*
* Argument validation on IO vector
*/
if ( !iov )
402c: e3510000 cmp r1, #0
4030: 0a00002d beq 40ec <readv+0xfc>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
4034: e3520000 cmp r2, #0
4038: da00002b ble 40ec <readv+0xfc>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
403c: e3520b01 cmp r2, #1024 ; 0x400
4040: ca000029 bgt 40ec <readv+0xfc>
4044: e3a02000 mov r2, #0
rtems_set_errno_and_return_minus_one( EINVAL );
4048: e1a05001 mov r5, r1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
404c: e1a03001 mov r3, r1
4050: e3a06001 mov r6, #1
4054: e1a01002 mov r1, r2
4058: ea000000 b 4060 <readv+0x70>
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
405c: e1a0100c mov r1, ip
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
4060: e5930000 ldr r0, [r3]
4064: e3500000 cmp r0, #0
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
4068: e2822001 add r2, r2, #1
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
406c: 0a00001e beq 40ec <readv+0xfc>
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
4070: e5930004 ldr r0, [r3, #4]
4074: e080c001 add ip, r0, r1
if ( total < old )
4078: e15c0001 cmp ip, r1
407c: ba00001a blt 40ec <readv+0xfc>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
4080: e3500000 cmp r0, #0
4084: 13a06000 movne r6, #0
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
4088: e1520004 cmp r2, r4
408c: e2833008 add r3, r3, #8
4090: 1afffff1 bne 405c <readv+0x6c>
/*
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
4094: e3560000 cmp r6, #0
return 0;
4098: 13a08000 movne r8, #0
/*
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
409c: 1a000016 bne 40fc <readv+0x10c>
40a0: e1a08006 mov r8, r6
40a4: ea000006 b 40c4 <readv+0xd4>
if ( bytes > 0 ) {
total += bytes;
}
if (bytes != iov[ v ].iov_len)
40a8: e5953004 ldr r3, [r5, #4]
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
total += bytes;
40ac: 10888000 addne r8, r8, r0
}
if (bytes != iov[ v ].iov_len)
40b0: e1500003 cmp r0, r3
40b4: 1a000010 bne 40fc <readv+0x10c>
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
40b8: e1560004 cmp r6, r4
40bc: e2855008 add r5, r5, #8
40c0: 0a00000d beq 40fc <readv+0x10c>
bytes = (*iop->pathinfo.handlers->read_h)(
40c4: e8950006 ldm r5, {r1, r2}
40c8: e5973020 ldr r3, [r7, #32]
40cc: e1a00007 mov r0, r7
40d0: e1a0e00f mov lr, pc
40d4: e593f008 ldr pc, [r3, #8]
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
40d8: e3500000 cmp r0, #0
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
40dc: e2866001 add r6, r6, #1
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
40e0: aafffff0 bge 40a8 <readv+0xb8>
return -1;
40e4: e3e08000 mvn r8, #0 <== NOT EXECUTED
40e8: ea000003 b 40fc <readv+0x10c> <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old )
rtems_set_errno_and_return_minus_one( EINVAL );
40ec: eb002911 bl e538 <__errno>
40f0: e3a03016 mov r3, #22
40f4: e5803000 str r3, [r0]
40f8: e3e08000 mvn r8, #0
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
40fc: e1a00008 mov r0, r8
4100: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
4104: eb00290b bl e538 <__errno>
4108: e3a03009 mov r3, #9
410c: e5803000 str r3, [r0]
4110: e3e08000 mvn r8, #0
4114: eafffff8 b 40fc <readv+0x10c>
000032fc <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
32fc: e92d41f0 push {r4, r5, r6, r7, r8, lr}
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
3300: e59f2118 ldr r2, [pc, #280] ; 3420 <realloc+0x124>
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
3304: e59f5118 ldr r5, [pc, #280] ; 3424 <realloc+0x128>
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
3308: e5922000 ldr r2, [r2]
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
330c: e5953010 ldr r3, [r5, #16]
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
3310: e3520003 cmp r2, #3
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
3314: e2833001 add r3, r3, #1
void *realloc(
void *ptr,
size_t size
)
{
3318: e24dd004 sub sp, sp, #4
331c: e1a04000 mov r4, r0
3320: e1a06001 mov r6, r1
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
3324: e5853010 str r3, [r5, #16]
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
3328: 0a000024 beq 33c0 <realloc+0xc4>
}
/*
* Continue with realloc().
*/
if ( !ptr )
332c: e3540000 cmp r4, #0
3330: 0a000036 beq 3410 <realloc+0x114>
return malloc( size );
if ( !size ) {
3334: e3560000 cmp r6, #0
3338: 0a00002b beq 33ec <realloc+0xf0>
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
333c: e59f70e4 ldr r7, [pc, #228] ; 3428 <realloc+0x12c>
3340: e1a01004 mov r1, r4
3344: e5970000 ldr r0, [r7]
3348: e1a0200d mov r2, sp
334c: eb0013ce bl 828c <_Protected_heap_Get_block_size>
3350: e2508000 subs r8, r0, #0
3354: 0a000028 beq 33fc <realloc+0x100>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
3358: e5970000 ldr r0, [r7]
335c: e1a01004 mov r1, r4
3360: e1a02006 mov r2, r6
3364: eb0013db bl 82d8 <_Protected_heap_Resize_block>
3368: e3500000 cmp r0, #0
336c: 0a000002 beq 337c <realloc+0x80>
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
3370: e1a00004 mov r0, r4
3374: e28dd004 add sp, sp, #4
3378: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* 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 );
337c: e1a00006 mov r0, r6
3380: ebfffd31 bl 284c <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
3384: e5953004 ldr r3, [r5, #4]
if ( !new_area ) {
3388: e2507000 subs r7, r0, #0
* and the C Standard.
*/
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
338c: e2433001 sub r3, r3, #1
3390: e5853004 str r3, [r5, #4]
if ( !new_area ) {
return (void *) 0;
3394: 01a04007 moveq r4, r7
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
3398: 0afffff4 beq 3370 <realloc+0x74>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
339c: e59d2000 ldr r2, [sp]
33a0: e1a01004 mov r1, r4
33a4: e1560002 cmp r6, r2
33a8: 31a02006 movcc r2, r6
33ac: eb002b47 bl e0d0 <memcpy>
free( ptr );
33b0: e1a00004 mov r0, r4
33b4: ebfffc56 bl 2514 <free>
return new_area;
33b8: e1a04007 mov r4, r7
33bc: eaffffeb b 3370 <realloc+0x74>
* 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 )
33c0: e59f3064 ldr r3, [pc, #100] ; 342c <realloc+0x130>
33c4: e5933000 ldr r3, [r3]
33c8: e3530000 cmp r3, #0
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
33cc: 13a04000 movne r4, #0
33d0: 1affffe6 bne 3370 <realloc+0x74>
if (_ISR_Nest_level > 0)
33d4: e59f2054 ldr r2, [pc, #84] ; 3430 <realloc+0x134>
33d8: e5922000 ldr r2, [r2]
33dc: e3520000 cmp r2, #0
33e0: 0affffd1 beq 332c <realloc+0x30>
return (void *) 0;
33e4: e1a04003 mov r4, r3 <== NOT EXECUTED
33e8: eaffffe0 b 3370 <realloc+0x74> <== NOT EXECUTED
*/
if ( !ptr )
return malloc( size );
if ( !size ) {
free( ptr );
33ec: e1a00004 mov r0, r4 <== NOT EXECUTED
33f0: ebfffc47 bl 2514 <free> <== NOT EXECUTED
return (void *) 0;
33f4: e1a04006 mov r4, r6 <== NOT EXECUTED
33f8: eaffffdc b 3370 <realloc+0x74> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
33fc: eb0028f9 bl d7e8 <__errno>
3400: e3a03016 mov r3, #22
3404: e5803000 str r3, [r0]
return (void *) 0;
3408: e1a04008 mov r4, r8
340c: eaffffd7 b 3370 <realloc+0x74>
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
3410: e1a00006 mov r0, r6
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
3414: e28dd004 add sp, sp, #4
3418: e8bd41f0 pop {r4, r5, r6, r7, r8, lr}
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
341c: eafffd0a b 284c <malloc>
00003bac <release_with_count>:
static void release_with_count(
rtems_filesystem_global_location_t *global_loc,
int count
)
{
3bac: e92d4070 push {r4, r5, r6, lr}
rtems_filesystem_mount_table_entry_t *mt_entry =
3bb0: e5905014 ldr r5, [r0, #20]
static void release_with_count(
rtems_filesystem_global_location_t *global_loc,
int count
)
{
3bb4: e1a04000 mov r4, r0
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3bb8: e10f3000 mrs r3, CPSR
3bbc: e3832080 orr r2, r3, #128 ; 0x80
3bc0: e129f002 msr CPSR_fc, r2
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
&& mt_entry->mt_fs_root->reference_count == 1;
3bc4: e5d56028 ldrb r6, [r5, #40] ; 0x28
rtems_filesystem_mt_entry_declare_lock_context(lock_context);
bool do_free;
bool do_unmount;
rtems_filesystem_mt_entry_lock(lock_context);
global_loc->reference_count -= count;
3bc8: e5902018 ldr r2, [r0, #24]
3bcc: e3560000 cmp r6, #0
3bd0: e0611002 rsb r1, r1, r2
3bd4: e5801018 str r1, [r0, #24]
static inline bool rtems_filesystem_is_ready_for_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
3bd8: 13a06000 movne r6, #0
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
&& mt_entry->mt_fs_root->reference_count == 1;
3bdc: 1a000003 bne 3bf0 <release_with_count+0x44>
static inline bool rtems_filesystem_is_ready_for_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
3be0: e5950014 ldr r0, [r5, #20]
3be4: e595201c ldr r2, [r5, #28]
3be8: e1500002 cmp r0, r2
3bec: 0a00000e beq 3c2c <release_with_count+0x80>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3bf0: e129f003 msr CPSR_fc, r3
do_free = global_loc->reference_count == 0;
do_unmount = rtems_filesystem_is_ready_for_unmount(mt_entry);
rtems_filesystem_mt_entry_unlock(lock_context);
if (do_free) {
3bf4: e3510000 cmp r1, #0
3bf8: 0a000004 beq 3c10 <release_with_count+0x64>
rtems_filesystem_location_free(&global_loc->location);
free(global_loc);
}
if (do_unmount) {
3bfc: e3560000 cmp r6, #0
3c00: 08bd8070 popeq {r4, r5, r6, pc}
rtems_filesystem_do_unmount(mt_entry);
3c04: e1a00005 mov r0, r5
} }
3c08: e8bd4070 pop {r4, r5, r6, lr}
rtems_filesystem_location_free(&global_loc->location);
free(global_loc);
}
if (do_unmount) {
rtems_filesystem_do_unmount(mt_entry);
3c0c: eaffff99 b 3a78 <rtems_filesystem_do_unmount>
do_free = global_loc->reference_count == 0;
do_unmount = rtems_filesystem_is_ready_for_unmount(mt_entry);
rtems_filesystem_mt_entry_unlock(lock_context);
if (do_free) {
rtems_filesystem_location_free(&global_loc->location);
3c10: e1a00004 mov r0, r4
3c14: eb001bf0 bl abdc <rtems_filesystem_location_free>
free(global_loc);
3c18: e1a00004 mov r0, r4
3c1c: ebfffa3c bl 2514 <free>
}
if (do_unmount) {
3c20: e3560000 cmp r6, #0
3c24: 08bd8070 popeq {r4, r5, r6, pc}
3c28: eafffff5 b 3c04 <release_with_count+0x58> <== NOT EXECUTED
&& mt_entry->mt_fs_root->reference_count == 1;
3c2c: e5952024 ldr r2, [r5, #36] ; 0x24
3c30: e5922018 ldr r2, [r2, #24]
3c34: e3520001 cmp r2, #1
3c38: 1affffec bne 3bf0 <release_with_count+0x44>
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 );
3c3c: e2850014 add r0, r5, #20
3c40: e285c018 add ip, r5, #24
head->next = tail;
head->previous = NULL;
3c44: e5856018 str r6, [r5, #24]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3c48: e585c014 str ip, [r5, #20]
head->previous = NULL; tail->previous = head;
3c4c: e585001c str r0, [r5, #28]
static inline bool rtems_filesystem_is_ready_for_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
3c50: e1a06002 mov r6, r2
3c54: eaffffe5 b 3bf0 <release_with_count+0x44>
0000ab00 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
ab00: e92d4030 push {r4, r5, lr}
ab04: e1a04000 mov r4, r0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
ab08: e5900000 ldr r0, [r0]
ab0c: e3500000 cmp r0, #0
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
ab10: e1a05001 mov r5, r1
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
ab14: 08bd8030 popeq {r4, r5, pc}
ab18: e59f1078 ldr r1, [pc, #120] ; ab98 <rtems_assoc_ptr_by_local+0x98>
ab1c: eb000e8d bl e558 <strcmp>
ab20: e3500000 cmp r0, #0
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
const rtems_assoc_t *default_ap = 0;
ab24: 13a0c000 movne ip, #0
if (rtems_assoc_is_default(ap))
ab28: 0a000011 beq ab74 <rtems_assoc_ptr_by_local+0x74>
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
ab2c: e5943004 ldr r3, [r4, #4]
ab30: e1530005 cmp r3, r5
#include <rtems.h>
#include <rtems/assoc.h>
#include <string.h> /* strcat, strcmp */
const rtems_assoc_t *rtems_assoc_ptr_by_local(
ab34: 1284100c addne r1, r4, #12
ab38: 11a03001 movne r3, r1
ab3c: 11a00004 movne r0, r4
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
ab40: 1a000004 bne ab58 <rtems_assoc_ptr_by_local+0x58>
ab44: ea000011 b ab90 <rtems_assoc_ptr_by_local+0x90>
ab48: e5132008 ldr r2, [r3, #-8]
ab4c: e1520005 cmp r2, r5
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
ab50: e280000c add r0, r0, #12
if (ap->local_value == local_value)
ab54: 08bd8030 popeq {r4, r5, pc}
#include <rtems.h>
#include <rtems/assoc.h>
#include <string.h> /* strcat, strcmp */
const rtems_assoc_t *rtems_assoc_ptr_by_local(
ab58: e0642000 rsb r2, r4, r0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
ab5c: e7912002 ldr r2, [r1, r2]
ab60: e3520000 cmp r2, #0
ab64: e283300c add r3, r3, #12
ab68: 1afffff6 bne ab48 <rtems_assoc_ptr_by_local+0x48>
ab6c: e1a0000c mov r0, ip
ab70: e8bd8030 pop {r4, r5, pc}
ab74: e594300c ldr r3, [r4, #12]
ab78: e3530000 cmp r3, #0
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
ab7c: 11a0c004 movne ip, r4
ab80: 1284400c addne r4, r4, #12
for ( ; ap->name; ap++)
ab84: 1affffe8 bne ab2c <rtems_assoc_ptr_by_local+0x2c>
ab88: e1a00004 mov r0, r4 <== NOT EXECUTED
ab8c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (ap->local_value == local_value)
ab90: e1a00004 mov r0, r4
return ap;
return default_ap;
}
ab94: e8bd8030 pop {r4, r5, pc}
00002e5c <rtems_assoc_ptr_by_name>:
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
2e5c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
2e60: e5904000 ldr r4, [r0]
2e64: e3540000 cmp r4, #0
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
2e68: e1a05000 mov r5, r0
2e6c: e1a06001 mov r6, r1
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
2e70: 0a000014 beq 2ec8 <rtems_assoc_ptr_by_name+0x6c>
2e74: e1a00004 mov r0, r4
2e78: e59f1078 ldr r1, [pc, #120] ; 2ef8 <rtems_assoc_ptr_by_name+0x9c>
2e7c: eb0030a7 bl f120 <strcmp>
2e80: e3500000 cmp r0, #0
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
const rtems_assoc_t *default_ap = 0;
2e84: 13a08000 movne r8, #0
if (rtems_assoc_is_default(ap))
2e88: 0a000010 beq 2ed0 <rtems_assoc_ptr_by_name+0x74>
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
2e8c: e1a03005 mov r3, r5
#include <rtems/assoc.h>
#include <string.h> /* strcat, strcmp */
const rtems_assoc_t *rtems_assoc_ptr_by_name(
2e90: e285700c add r7, r5, #12
2e94: ea000002 b 2ea4 <rtems_assoc_ptr_by_name+0x48>
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
2e98: e512400c ldr r4, [r2, #-12]
2e9c: e3540000 cmp r4, #0
2ea0: 0a000011 beq 2eec <rtems_assoc_ptr_by_name+0x90>
if (strcmp(ap->name, name) == 0)
2ea4: e1a00004 mov r0, r4
2ea8: e1a01006 mov r1, r6
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
2eac: e1a04003 mov r4, r3
for ( ; ap->name; ap++)
if (strcmp(ap->name, name) == 0)
2eb0: eb00309a bl f120 <strcmp>
2eb4: e284300c add r3, r4, #12
#include <rtems/assoc.h>
#include <string.h> /* strcat, strcmp */
const rtems_assoc_t *rtems_assoc_ptr_by_name(
2eb8: e0652003 rsb r2, r5, r3
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
if (strcmp(ap->name, name) == 0)
2ebc: e3500000 cmp r0, #0
#include <rtems/assoc.h>
#include <string.h> /* strcat, strcmp */
const rtems_assoc_t *rtems_assoc_ptr_by_name(
2ec0: e0822007 add r2, r2, r7
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
if (strcmp(ap->name, name) == 0)
2ec4: 1afffff3 bne 2e98 <rtems_assoc_ptr_by_name+0x3c>
return ap;
return default_ap;
}
2ec8: e1a00004 mov r0, r4
2ecc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
2ed0: e595400c ldr r4, [r5, #12]
2ed4: e3540000 cmp r4, #0
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
2ed8: 11a08005 movne r8, r5
2edc: 1285500c addne r5, r5, #12
for ( ; ap->name; ap++)
2ee0: 1affffe9 bne 2e8c <rtems_assoc_ptr_by_name+0x30>
2ee4: e1a04005 mov r4, r5 <== NOT EXECUTED
2ee8: eafffff6 b 2ec8 <rtems_assoc_ptr_by_name+0x6c> <== NOT EXECUTED
2eec: e1a04008 mov r4, r8
if (strcmp(ap->name, name) == 0)
return ap;
return default_ap;
}
2ef0: e1a00004 mov r0, r4
2ef4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
0000d28c <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
d28c: e92d4030 push {r4, r5, lr}
d290: e1a04000 mov r4, r0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
d294: e5900000 ldr r0, [r0]
d298: e3500000 cmp r0, #0
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
d29c: e1a05001 mov r5, r1
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
d2a0: 08bd8030 popeq {r4, r5, pc}
d2a4: e59f1078 ldr r1, [pc, #120] ; d324 <rtems_assoc_ptr_by_remote+0x98>
d2a8: eb0004aa bl e558 <strcmp>
d2ac: e3500000 cmp r0, #0
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
const rtems_assoc_t *default_ap = 0;
d2b0: 13a0c000 movne ip, #0
if (rtems_assoc_is_default(ap))
d2b4: 0a000011 beq d300 <rtems_assoc_ptr_by_remote+0x74>
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
d2b8: e5943008 ldr r3, [r4, #8]
d2bc: e1530005 cmp r3, r5
#include <rtems.h>
#include <rtems/assoc.h>
#include <string.h> /* strcat, strcmp */
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
d2c0: 1284100c addne r1, r4, #12
d2c4: 11a03001 movne r3, r1
d2c8: 11a00004 movne r0, r4
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
d2cc: 1a000004 bne d2e4 <rtems_assoc_ptr_by_remote+0x58>
d2d0: ea000011 b d31c <rtems_assoc_ptr_by_remote+0x90>
d2d4: e5132004 ldr r2, [r3, #-4]
d2d8: e1520005 cmp r2, r5
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
d2dc: e280000c add r0, r0, #12
if (ap->remote_value == remote_value)
d2e0: 08bd8030 popeq {r4, r5, pc}
#include <rtems.h>
#include <rtems/assoc.h>
#include <string.h> /* strcat, strcmp */
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
d2e4: e0642000 rsb r2, r4, r0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
d2e8: e7912002 ldr r2, [r1, r2]
d2ec: e3520000 cmp r2, #0
d2f0: e283300c add r3, r3, #12
d2f4: 1afffff6 bne d2d4 <rtems_assoc_ptr_by_remote+0x48>
d2f8: e1a0000c mov r0, ip
d2fc: e8bd8030 pop {r4, r5, pc}
d300: e594300c ldr r3, [r4, #12]
d304: e3530000 cmp r3, #0
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
d308: 11a0c004 movne ip, r4
d30c: 1284400c addne r4, r4, #12
for ( ; ap->name; ap++)
d310: 1affffe8 bne d2b8 <rtems_assoc_ptr_by_remote+0x2c>
d314: e1a00004 mov r0, r4 <== NOT EXECUTED
d318: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (ap->remote_value == remote_value)
d31c: e1a00004 mov r0, r4
return ap;
return default_ap;
}
d320: e8bd8030 pop {r4, r5, pc}
0000bcfc <rtems_bdbuf_add_to_modified_list_after_access>:
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
bcfc: e92d4010 push {r4, lr}
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)
bd00: e59f40b0 ldr r4, [pc, #176] ; bdb8 <rtems_bdbuf_add_to_modified_list_after_access+0xbc>
bd04: e5d43030 ldrb r3, [r4, #48] ; 0x30
bd08: e3530000 cmp r3, #0
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
bd0c: e24dd004 sub sp, sp, #4
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)
bd10: 0a000003 beq bd24 <rtems_bdbuf_add_to_modified_list_after_access+0x28>
bd14: e5942038 ldr r2, [r4, #56] ; 0x38 <== NOT EXECUTED
bd18: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED
bd1c: e1520003 cmp r2, r3 <== NOT EXECUTED
bd20: 0a00001d beq bd9c <rtems_bdbuf_add_to_modified_list_after_access+0xa0><== 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
bd24: e5903020 ldr r3, [r0, #32]
bd28: e3530003 cmp r3, #3
bd2c: 13530005 cmpne r3, #5
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
bd->hold_timer = bdbuf_config.swap_block_hold;
bd30: 059f3084 ldreq r3, [pc, #132] ; bdbc <rtems_bdbuf_add_to_modified_list_after_access+0xc0>
bd34: 05933010 ldreq r3, [r3, #16]
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append_unprotected (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
bd38: e590c024 ldr ip, [r0, #36] ; 0x24
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
bd3c: e59f2074 ldr r2, [pc, #116] ; bdb8 <rtems_bdbuf_add_to_modified_list_after_access+0xbc>
* only a specific period of time even if still changing and get onto disk
* and letting the file system try and recover this position if it can.
*/
if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
bd->hold_timer = bdbuf_config.swap_block_hold;
bd40: 0580302c streq r3, [r0, #44] ; 0x2c
bd44: e5943054 ldr r3, [r4, #84] ; 0x54
the_node->next = tail;
bd48: e2821050 add r1, r2, #80 ; 0x50
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append_unprotected (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
bd4c: e35c0000 cmp ip, #0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
bd50: e3a0c007 mov ip, #7
bd54: e580c020 str ip, [r0, #32]
bd58: e5801000 str r1, [r0]
tail->previous = the_node;
bd5c: e5840054 str r0, [r4, #84] ; 0x54
old_last->next = the_node;
bd60: e5830000 str r0, [r3]
the_node->previous = old_last;
bd64: e5803004 str r3, [r0, #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)
bd68: 1a000007 bne bd8c <rtems_bdbuf_add_to_modified_list_after_access+0x90>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else if (rtems_bdbuf_has_buffer_waiters ())
bd6c: e5923074 ldr r3, [r2, #116] ; 0x74
bd70: e3530000 cmp r3, #0
bd74: 1a000001 bne bd80 <rtems_bdbuf_add_to_modified_list_after_access+0x84>
rtems_bdbuf_wake_swapper ();
}
bd78: e28dd004 add sp, sp, #4
bd7c: e8bd8010 pop {r4, pc}
bd80: e28dd004 add sp, sp, #4
bd84: 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 ();
bd88: eaffff32 b ba58 <rtems_bdbuf_wake_swapper>
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);
bd8c: e2820064 add r0, r2, #100 ; 0x64
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
}
bd90: e28dd004 add sp, sp, #4
bd94: 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);
bd98: eaffffcd b bcd4 <rtems_bdbuf_wake>
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)
{
rtems_bdbuf_unlock_cache ();
bd9c: e58d0000 str r0, [sp] <== NOT EXECUTED
bda0: ebffff1a bl ba10 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
/*
* Wait for the sync lock.
*/
rtems_bdbuf_lock_sync ();
bda4: ebffff0b bl b9d8 <rtems_bdbuf_lock_sync> <== NOT EXECUTED
rtems_bdbuf_unlock_sync ();
bda8: ebffff21 bl ba34 <rtems_bdbuf_unlock_sync> <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
bdac: ebfffefe bl b9ac <rtems_bdbuf_lock_cache> <== NOT EXECUTED
bdb0: e59d0000 ldr r0, [sp] <== NOT EXECUTED
bdb4: eaffffda b bd24 <rtems_bdbuf_add_to_modified_list_after_access+0x28><== NOT EXECUTED
0000bb2c <rtems_bdbuf_anonymous_wait>:
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
bb2c: e5903000 ldr r3, [r0]
bb30: 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)
{
bb34: e92d4030 push {r4, r5, lr}
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
bb38: 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)
{
bb3c: 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 ();
bb40: ebffffdb bl bab4 <rtems_bdbuf_disable_preemption>
bb44: e1a05000 mov r5, r0
/*
* Unlock the cache, wait, and lock the cache when we return.
*/
rtems_bdbuf_unlock_cache ();
bb48: ebffffb0 bl ba10 <rtems_bdbuf_unlock_cache>
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
bb4c: e3a01000 mov r1, #0
bb50: e5940004 ldr r0, [r4, #4]
bb54: e1a02001 mov r2, r1
bb58: ebffefe0 bl 7ae0 <rtems_semaphore_obtain>
if (sc == RTEMS_TIMEOUT)
bb5c: e3500006 cmp r0, #6
bb60: 0a000008 beq bb88 <rtems_bdbuf_anonymous_wait+0x5c>
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_TO);
if (sc != RTEMS_UNSATISFIED)
bb64: e350000d cmp r0, #13
bb68: 1a000008 bne bb90 <rtems_bdbuf_anonymous_wait+0x64>
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_2);
rtems_bdbuf_lock_cache ();
bb6c: ebffff8e bl b9ac <rtems_bdbuf_lock_cache>
rtems_bdbuf_restore_preemption (prev_mode);
bb70: e1a00005 mov r0, r5
bb74: ebffffde bl baf4 <rtems_bdbuf_restore_preemption>
--waiters->count;
bb78: e5943000 ldr r3, [r4]
bb7c: e2433001 sub r3, r3, #1
bb80: e5843000 str r3, [r4]
}
bb84: e8bd8030 pop {r4, r5, pc}
rtems_bdbuf_unlock_cache ();
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
if (sc == RTEMS_TIMEOUT)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_TO);
bb88: e3a00003 mov r0, #3 <== NOT EXECUTED
bb8c: ebffff82 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
if (sc != RTEMS_UNSATISFIED)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_2);
bb90: e3a00002 mov r0, #2 <== NOT EXECUTED
bb94: ebffff80 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
0000bdc0 <rtems_bdbuf_create_task.constprop.10>:
return NULL;
}
static rtems_status_code
rtems_bdbuf_create_task(
bdc0: e92d4070 push {r4, r5, r6, lr}
rtems_task_argument arg,
rtems_id *id
)
{
rtems_status_code sc;
size_t stack_size = bdbuf_config.task_stack_size ?
bdc4: e59fc060 ldr ip, [pc, #96] ; be2c <rtems_bdbuf_create_task.constprop.10+0x6c>
bdc8: e59cc01c ldr ip, [ip, #28]
return NULL;
}
static rtems_status_code
rtems_bdbuf_create_task(
bdcc: e24dd008 sub sp, sp, #8
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,
bdd0: e3510000 cmp r1, #0
return NULL;
}
static rtems_status_code
rtems_bdbuf_create_task(
bdd4: 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,
bdd8: 03a0100f moveq r1, #15
bddc: e35c0000 cmp ip, #0
return NULL;
}
static rtems_status_code
rtems_bdbuf_create_task(
bde0: e1a06002 mov r6, r2
bde4: e1a05003 mov r5, r3
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,
bde8: 11a0200c movne r2, ip
bdec: 03a02a01 moveq r2, #4096 ; 0x1000
bdf0: e3a0c000 mov ip, #0
bdf4: e3a03b01 mov r3, #1024 ; 0x400
bdf8: e58dc000 str ip, [sp]
bdfc: e58d4004 str r4, [sp, #4]
be00: ebffefbe bl 7d00 <rtems_task_create>
stack_size,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
id);
if (sc == RTEMS_SUCCESSFUL)
be04: e3500000 cmp r0, #0
be08: 0a000001 beq be14 <rtems_bdbuf_create_task.constprop.10+0x54>
sc = rtems_task_start (*id, entry, arg);
return sc;
}
be0c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
be10: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
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);
be14: e5940000 ldr r0, [r4]
be18: e1a01006 mov r1, r6
be1c: e1a02005 mov r2, r5
return sc;
}
be20: e28dd008 add sp, sp, #8
be24: 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);
be28: eafff04b b 7f5c <rtems_task_start>
0000bab4 <rtems_bdbuf_disable_preemption>:
--bd->group->users;
}
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
bab4: e52de004 push {lr} ; (str lr, [sp, #-4]!)
bab8: e24dd004 sub sp, sp, #4
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_mode prev_mode = 0;
babc: e28d2004 add r2, sp, #4
bac0: e3a03000 mov r3, #0
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
bac4: e3a00c01 mov r0, #256 ; 0x100
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_mode prev_mode = 0;
bac8: e5223004 str r3, [r2, #-4]!
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
bacc: e1a01000 mov r1, r0
bad0: e1a0200d mov r2, sp
bad4: eb000fba bl f9c4 <rtems_task_mode>
if (sc != RTEMS_SUCCESSFUL)
bad8: e3500000 cmp r0, #0
badc: 1a000002 bne baec <rtems_bdbuf_disable_preemption+0x38>
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_DIS);
return prev_mode;
}
bae0: e59d0000 ldr r0, [sp]
bae4: e28dd004 add sp, sp, #4
bae8: e8bd8000 pop {pc}
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_mode prev_mode = 0;
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_DIS);
baec: e3a00005 mov r0, #5 <== NOT EXECUTED
baf0: ebffffa9 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
0000b99c <rtems_bdbuf_fatal>:
#define RTEMS_BDBUF_AVL_MAX_HEIGHT (32)
#endif
static void
rtems_bdbuf_fatal (rtems_fatal_code error)
{
b99c: e1a01000 mov r1, r0 <== NOT EXECUTED
b9a0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_fatal (RTEMS_FATAL_SOURCE_BDBUF, error);
b9a4: e3a00003 mov r0, #3 <== NOT EXECUTED
b9a8: ebfff20b bl 81dc <rtems_fatal> <== NOT EXECUTED
0000ba04 <rtems_bdbuf_fatal_with_state>:
}
static void
rtems_bdbuf_fatal_with_state (rtems_bdbuf_buf_state state,
rtems_bdbuf_fatal_code error)
{
ba04: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_bdbuf_fatal ((((uint32_t) state) << 16) | error);
ba08: e1810800 orr r0, r1, r0, lsl #16 <== NOT EXECUTED
ba0c: ebffffe2 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
0000d6a8 <rtems_bdbuf_get>:
rtems_status_code
rtems_bdbuf_get (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
d6a8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
d6ac: e1a04000 mov r4, r0
d6b0: e1a06001 mov r6, r1
d6b4: e1a05002 mov r5, r2
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block;
rtems_bdbuf_lock_cache ();
d6b8: ebfff8bb bl b9ac <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)
d6bc: e5943028 ldr r3, [r4, #40] ; 0x28
d6c0: e1560003 cmp r6, r3
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
}
else
{
sc = RTEMS_INVALID_ID;
d6c4: 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;
d6c8: 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)
d6cc: 3a000003 bcc d6e0 <rtems_bdbuf_get+0x38>
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
d6d0: ebfff8ce bl ba10 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
*bd_ptr = bd;
d6d4: e5854000 str r4, [r5] <== NOT EXECUTED
return sc;
}
d6d8: e1a00006 mov r0, r6 <== NOT EXECUTED
d6dc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
}
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)
d6e0: e5941030 ldr r1, [r4, #48] ; 0x30
d6e4: e3510000 cmp r1, #0
return block << dd->block_to_media_block_shift;
d6e8: a1a01116 lslge r1, r6, r1
}
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)
d6ec: ba000022 blt d77c <rtems_bdbuf_get+0xd4>
/*
* 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;
d6f0: e5943018 ldr r3, [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);
d6f4: e1a00004 mov r0, r4
d6f8: e0811003 add r1, r1, r3
d6fc: ebfffbc4 bl c614 <rtems_bdbuf_get_buffer_for_access>
d700: e1a04000 mov r4, r0
switch (bd->state)
d704: e5900020 ldr r0, [r0, #32]
d708: e3500002 cmp r0, #2
d70c: 0a000013 beq d760 <rtems_bdbuf_get+0xb8>
d710: e3500007 cmp r0, #7
d714: 0a000003 beq d728 <rtems_bdbuf_get+0x80>
d718: e3500001 cmp r0, #1
d71c: 0a000008 beq d744 <rtems_bdbuf_get+0x9c>
* 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);
d720: e3a0100f mov r1, #15 <== NOT EXECUTED
d724: ebfff8b6 bl ba04 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
d728: e3a03004 mov r3, #4
d72c: e5843020 str r3, [r4, #32]
d730: e3a06000 mov r6, #0
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
d734: ebfff8b5 bl ba10 <rtems_bdbuf_unlock_cache>
*bd_ptr = bd;
d738: e5854000 str r4, [r5]
return sc;
}
d73c: e1a00006 mov r0, r6
d740: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
d744: e3a03005 mov r3, #5
d748: e5843020 str r3, [r4, #32]
d74c: e3a06000 mov r6, #0
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
d750: ebfff8ae bl ba10 <rtems_bdbuf_unlock_cache>
*bd_ptr = bd;
d754: e5854000 str r4, [r5]
return sc;
}
d758: e1a00006 mov r0, r6
d75c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
d760: e3a03003 mov r3, #3
d764: e5843020 str r3, [r4, #32]
d768: e3a06000 mov r6, #0
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
d76c: ebfff8a7 bl ba10 <rtems_bdbuf_unlock_cache>
*bd_ptr = bd;
d770: e5854000 str r4, [r5]
return sc;
}
d774: e1a00006 mov r0, r6
d778: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
/*
* 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);
d77c: e5940024 ldr r0, [r4, #36] ; 0x24 <== NOT EXECUTED
d780: e0887096 umull r7, r8, r6, r0 <== NOT EXECUTED
d784: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
d788: e1a00007 mov r0, r7 <== NOT EXECUTED
d78c: e1a01008 mov r1, r8 <== NOT EXECUTED
d790: e3a03000 mov r3, #0 <== NOT EXECUTED
d794: eb003a56 bl 1c0f4 <__udivdi3> <== NOT EXECUTED
d798: e1a01000 mov r1, r0 <== NOT EXECUTED
d79c: eaffffd3 b d6f0 <rtems_bdbuf_get+0x48> <== NOT EXECUTED
0000c614 <rtems_bdbuf_get_buffer_for_access>:
}
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
c614: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
c618: e59f7228 ldr r7, [pc, #552] ; c848 <rtems_bdbuf_get_buffer_for_access+0x234>
c61c: e1a05000 mov r5, r0
c620: e1a06001 mov r6, r1
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
c624: e287805c add r8, r7, #92 ; 0x5c
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
c628: e597403c ldr r4, [r7, #60] ; 0x3c
const rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dd != dd) || (p->block != block)))
c62c: e3540000 cmp r4, #0
c630: 0a000009 beq c65c <rtems_bdbuf_get_buffer_for_access+0x48>
c634: e5943014 ldr r3, [r4, #20]
c638: e1550003 cmp r5, r3
c63c: 0a00001f beq c6c0 <rtems_bdbuf_get_buffer_for_access+0xac>
{
if (((uintptr_t) p->dd < (uintptr_t) dd)
c640: e1530005 cmp r3, r5
c644: 3a00001b bcc c6b8 <rtems_bdbuf_get_buffer_for_access+0xa4>
|| ((p->dd == dd) && (p->block < block)))
c648: e1550003 cmp r5, r3
c64c: 0a000016 beq c6ac <rtems_bdbuf_get_buffer_for_access+0x98>
{
p = p->avl.right;
}
else
{
p = p->avl.left;
c650: e5944008 ldr r4, [r4, #8]
const rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dd != dd) || (p->block != block)))
c654: e3540000 cmp r4, #0
c658: 1afffff5 bne c634 <rtems_bdbuf_get_buffer_for_access+0x20>
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
c65c: e1a00005 mov r0, r5
c660: e1a01006 mov r1, r6
c664: ebfffed8 bl c1cc <rtems_bdbuf_get_buffer_from_lru_list>
if (bd == NULL)
c668: e2504000 subs r4, r0, #0
c66c: 0a000050 beq c7b4 <rtems_bdbuf_get_buffer_for_access+0x1a0>
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
c670: e5940020 ldr r0, [r4, #32]
c674: e2403001 sub r3, r0, #1
c678: e3530009 cmp r3, #9
c67c: 979ff103 ldrls pc, [pc, r3, lsl #2]
c680: ea00006e b c840 <rtems_bdbuf_get_buffer_for_access+0x22c> <== NOT EXECUTED
c684: 0000c828 .word 0x0000c828 <== NOT EXECUTED
c688: 0000c820 .word 0x0000c820 <== NOT EXECUTED
c68c: 0000c810 .word 0x0000c810 <== NOT EXECUTED
c690: 0000c810 .word 0x0000c810 <== NOT EXECUTED
c694: 0000c810 .word 0x0000c810 <== NOT EXECUTED
c698: 0000c810 .word 0x0000c810 <== NOT EXECUTED
c69c: 0000c7e0 .word 0x0000c7e0 <== NOT EXECUTED
c6a0: 0000c7d0 .word 0x0000c7d0 <== NOT EXECUTED
c6a4: 0000c7d0 .word 0x0000c7d0 <== NOT EXECUTED
c6a8: 0000c7d0 .word 0x0000c7d0 <== NOT EXECUTED
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dd != dd) || (p->block != block)))
{
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
c6ac: e5943018 ldr r3, [r4, #24]
c6b0: e1560003 cmp r6, r3
c6b4: 9affffe5 bls c650 <rtems_bdbuf_get_buffer_for_access+0x3c>
{
p = p->avl.right;
c6b8: e594400c ldr r4, [r4, #12]
c6bc: eaffffe4 b c654 <rtems_bdbuf_get_buffer_for_access+0x40>
const rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dd != dd) || (p->block != block)))
c6c0: e5942018 ldr r2, [r4, #24]
c6c4: e1560002 cmp r6, r2
c6c8: 1affffdc bne c640 <rtems_bdbuf_get_buffer_for_access+0x2c>
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
if (bd != NULL)
{
if (bd->group->bds_per_group != dd->bds_per_group)
c6cc: e5942028 ldr r2, [r4, #40] ; 0x28
c6d0: e5953034 ldr r3, [r5, #52] ; 0x34
c6d4: e5922008 ldr r2, [r2, #8]
c6d8: e1520003 cmp r2, r3
c6dc: 0affffe3 beq c670 <rtems_bdbuf_get_buffer_for_access+0x5c>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c6e0: e3a0a008 mov sl, #8
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
c6e4: e5940020 ldr r0, [r4, #32]
c6e8: e350000a cmp r0, #10
c6ec: 979ff100 ldrls pc, [pc, r0, lsl #2]
c6f0: ea00002d b c7ac <rtems_bdbuf_get_buffer_for_access+0x198> <== NOT EXECUTED
c6f4: 0000c778 .word 0x0000c778 <== NOT EXECUTED
c6f8: 0000c76c .word 0x0000c76c <== NOT EXECUTED
c6fc: 0000c76c .word 0x0000c76c <== NOT EXECUTED
c700: 0000c75c .word 0x0000c75c <== NOT EXECUTED
c704: 0000c75c .word 0x0000c75c <== NOT EXECUTED
c708: 0000c75c .word 0x0000c75c <== NOT EXECUTED
c70c: 0000c75c .word 0x0000c75c <== NOT EXECUTED
c710: 0000c730 .word 0x0000c730 <== NOT EXECUTED
c714: 0000c720 .word 0x0000c720 <== NOT EXECUTED
c718: 0000c720 .word 0x0000c720 <== NOT EXECUTED
c71c: 0000c720 .word 0x0000c720 <== NOT EXECUTED
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
c720: e1a00004 mov r0, r4 <== NOT EXECUTED
c724: e59f1120 ldr r1, [pc, #288] ; c84c <rtems_bdbuf_get_buffer_for_access+0x238><== NOT EXECUTED
c728: ebfffd1a bl bb98 <rtems_bdbuf_wait> <== NOT EXECUTED
c72c: eaffffec b c6e4 <rtems_bdbuf_get_buffer_for_access+0xd0> <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
c730: e8940006 ldm r4, {r1, r2} <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c734: e584a020 str sl, [r4, #32] <== NOT EXECUTED
next->previous = previous;
c738: e5812004 str r2, [r1, #4] <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
c73c: e5973060 ldr r3, [r7, #96] ; 0x60 <== NOT EXECUTED
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
previous->next = next;
c740: e5821000 str r1, [r2] <== NOT EXECUTED
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
c744: e5874060 str r4, [r7, #96] ; 0x60 <== NOT EXECUTED
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
c748: e5848000 str r8, [r4] <== NOT EXECUTED
tail->previous = the_node; old_last->next = the_node; the_node->previous = old_last;
c74c: e5843004 str r3, [r4, #4] <== 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;
c750: e5834000 str r4, [r3] <== 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 ();
c754: ebfffcbf bl ba58 <rtems_bdbuf_wake_swapper> <== NOT EXECUTED
c758: eaffffe1 b c6e4 <rtems_bdbuf_get_buffer_for_access+0xd0> <== NOT EXECUTED
}
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
c75c: e1a00004 mov r0, r4
c760: e59f10e8 ldr r1, [pc, #232] ; c850 <rtems_bdbuf_get_buffer_for_access+0x23c>
c764: ebfffd0b bl bb98 <rtems_bdbuf_wait>
c768: eaffffdd b c6e4 <rtems_bdbuf_get_buffer_for_access+0xd0>
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)
c76c: e5943024 ldr r3, [r4, #36] ; 0x24
c770: e3530000 cmp r3, #0
c774: 1a000012 bne c7c4 <rtems_bdbuf_get_buffer_for_access+0x1b0>
{
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);
c778: e1a00004 mov r0, r4 <== NOT EXECUTED
c77c: ebfffe84 bl c194 <rtems_bdbuf_remove_from_tree_and_lru_list><== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
c780: e5973040 ldr r3, [r7, #64] ; 0x40 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
c784: e59f00c8 ldr r0, [pc, #200] ; c854 <rtems_bdbuf_get_buffer_for_access+0x240><== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c788: e3a02000 mov r2, #0 <== NOT EXECUTED
c78c: e5842020 str r2, [r4, #32] <== NOT EXECUTED
c790: e5840004 str r0, [r4, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
c794: e5874040 str r4, [r7, #64] ; 0x40 <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
c798: e5834004 str r4, [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;
c79c: e5843000 str r3, [r4] <== NOT EXECUTED
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
c7a0: e2800034 add r0, r0, #52 ; 0x34 <== NOT EXECUTED
c7a4: ebfffd4a bl bcd4 <rtems_bdbuf_wake> <== NOT EXECUTED
c7a8: eaffff9e b c628 <rtems_bdbuf_get_buffer_for_access+0x14> <== NOT EXECUTED
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_8);
c7ac: e3a01014 mov r1, #20 <== NOT EXECUTED
c7b0: ebfffc93 bl ba04 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
c7b4: e597204c ldr r2, [r7, #76] ; 0x4c
c7b8: e59f3098 ldr r3, [pc, #152] ; c858 <rtems_bdbuf_get_buffer_for_access+0x244>
c7bc: e1520003 cmp r2, r3
rtems_bdbuf_wake_swapper ();
c7c0: 1bfffca4 blne ba58 <rtems_bdbuf_wake_swapper>
rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);
c7c4: e59f0090 ldr r0, [pc, #144] ; c85c <rtems_bdbuf_get_buffer_for_access+0x248>
c7c8: ebfffcd7 bl bb2c <rtems_bdbuf_anonymous_wait>
c7cc: eaffff95 b c628 <rtems_bdbuf_get_buffer_for_access+0x14>
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
c7d0: e1a00004 mov r0, r4
c7d4: e59f1070 ldr r1, [pc, #112] ; c84c <rtems_bdbuf_get_buffer_for_access+0x238>
c7d8: ebfffcee bl bb98 <rtems_bdbuf_wait>
c7dc: eaffffa3 b c670 <rtems_bdbuf_get_buffer_for_access+0x5c>
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
c7e0: e5943028 ldr r3, [r4, #40] ; 0x28
c7e4: e593200c ldr r2, [r3, #12]
c7e8: e2422001 sub r2, r2, #1
c7ec: e583200c str r2, [r3, #12]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
c7f0: e8940006 ldm r4, {r1, r2}
next->previous = previous;
c7f4: e5812004 str r2, [r1, #4]
previous->next = next;
c7f8: e5821000 str r1, [r2]
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
c7fc: e593200c ldr r2, [r3, #12]
c800: e2822001 add r2, r2, #1
c804: e583200c str r2, [r3, #12]
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
return bd;
}
c808: e1a00004 mov r0, r4
c80c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
return;
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
c810: e1a00004 mov r0, r4
c814: e59f1034 ldr r1, [pc, #52] ; c850 <rtems_bdbuf_get_buffer_for_access+0x23c>
c818: ebfffcde bl bb98 <rtems_bdbuf_wait>
c81c: eaffff93 b c670 <rtems_bdbuf_get_buffer_for_access+0x5c>
c820: e5943028 ldr r3, [r4, #40] ; 0x28
c824: eafffff1 b c7f0 <rtems_bdbuf_get_buffer_for_access+0x1dc>
c828: e5943028 ldr r3, [r4, #40] ; 0x28
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
c82c: e593200c ldr r2, [r3, #12]
c830: e2822001 add r2, r2, #1
c834: e583200c str r2, [r3, #12]
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
return bd;
}
c838: e1a00004 mov r0, r4
c83c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_7);
c840: e3a01013 mov r1, #19 <== NOT EXECUTED
c844: ebfffc6e bl ba04 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
0000c590 <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);
c590: e59f3078 ldr r3, [pc, #120] ; c610 <rtems_bdbuf_get_buffer_for_read_ahead+0x80>
c594: e593303c ldr r3, [r3, #60] ; 0x3c
const rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dd != dd) || (p->block != block)))
c598: e3530000 cmp r3, #0
}
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_read_ahead (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
c59c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
const rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dd != dd) || (p->block != block)))
c5a0: 0a000009 beq c5cc <rtems_bdbuf_get_buffer_for_read_ahead+0x3c>
c5a4: e5932014 ldr r2, [r3, #20]
c5a8: e1500002 cmp r0, r2
c5ac: 0a000012 beq c5fc <rtems_bdbuf_get_buffer_for_read_ahead+0x6c>
{
if (((uintptr_t) p->dd < (uintptr_t) dd)
c5b0: e1520000 cmp r2, r0
c5b4: 3a00000e bcc c5f4 <rtems_bdbuf_get_buffer_for_read_ahead+0x64>
|| ((p->dd == dd) && (p->block < block)))
c5b8: e1500002 cmp r0, r2
c5bc: 0a000009 beq c5e8 <rtems_bdbuf_get_buffer_for_read_ahead+0x58>
{
p = p->avl.right;
}
else
{
p = p->avl.left;
c5c0: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
const rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dd != dd) || (p->block != block)))
c5c4: e3530000 cmp r3, #0
c5c8: 1afffff5 bne c5a4 <rtems_bdbuf_get_buffer_for_read_ahead+0x14>
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
if (bd == NULL)
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
c5cc: ebfffefe bl c1cc <rtems_bdbuf_get_buffer_from_lru_list>
if (bd != NULL)
c5d0: e3500000 cmp r0, #0
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
c5d4: 15903028 ldrne r3, [r0, #40] ; 0x28
c5d8: 1593200c ldrne r2, [r3, #12]
c5dc: 12822001 addne r2, r2, #1
c5e0: 1583200c strne r2, [r3, #12]
* thus no need for a read ahead.
*/
bd = NULL;
return bd;
}
c5e4: e49df004 pop {pc} ; (ldr pc, [sp], #4)
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dd != dd) || (p->block != block)))
{
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
c5e8: e5932018 ldr r2, [r3, #24]
c5ec: e1510002 cmp r1, r2
c5f0: 9afffff2 bls c5c0 <rtems_bdbuf_get_buffer_for_read_ahead+0x30>
{
p = p->avl.right;
c5f4: e593300c ldr r3, [r3, #12]
c5f8: eafffff1 b c5c4 <rtems_bdbuf_get_buffer_for_read_ahead+0x34>
const rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dd != dd) || (p->block != block)))
c5fc: e593c018 ldr ip, [r3, #24]
c600: e151000c cmp r1, ip
c604: 1affffe9 bne c5b0 <rtems_bdbuf_get_buffer_for_read_ahead+0x20>
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;
c608: e3a00000 mov r0, #0 <== NOT EXECUTED
c60c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
0000c1cc <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)
{
c1cc: 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;
c1d0: e59f53ac ldr r5, [pc, #940] ; c584 <rtems_bdbuf_get_buffer_from_lru_list+0x3b8>
c1d4: e5956040 ldr r6, [r5, #64] ; 0x40
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
c1d8: e2852044 add r2, r5, #68 ; 0x44
}
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_from_lru_list (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
c1dc: e24dd08c sub sp, sp, #140 ; 0x8c
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
c1e0: e1560002 cmp r6, r2
}
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_from_lru_list (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
c1e4: e1a0b000 mov fp, r0
c1e8: e58d1008 str r1, [sp, #8]
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
c1ec: 0a00003e beq c2ec <rtems_bdbuf_get_buffer_from_lru_list+0x120>
c1f0: e2859040 add r9, r5, #64 ; 0x40
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c1f4: e3a0a000 mov sl, #0
bd->group->bds_per_group, dd->bds_per_group);
/*
* If nobody waits for this BD, we may recycle it.
*/
if (bd->waiters == 0)
c1f8: e5963024 ldr r3, [r6, #36] ; 0x24
c1fc: e3530000 cmp r3, #0
c200: 1a000035 bne c2dc <rtems_bdbuf_get_buffer_from_lru_list+0x110>
{
if (bd->group->bds_per_group == dd->bds_per_group)
c204: e5967028 ldr r7, [r6, #40] ; 0x28
c208: e59b8034 ldr r8, [fp, #52] ; 0x34
c20c: e5971008 ldr r1, [r7, #8]
c210: e1510008 cmp r1, r8
c214: 0a000038 beq c2fc <rtems_bdbuf_get_buffer_from_lru_list+0x130>
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
empty_bd = bd;
}
else if (bd->group->users == 0)
c218: e597300c ldr r3, [r7, #12]
c21c: e3530000 cmp r3, #0
c220: 1a00002d bne c2dc <rtems_bdbuf_get_buffer_from_lru_list+0x110>
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;
c224: e3510000 cmp r1, #0
if (rtems_bdbuf_tracer)
printf ("bdbuf:realloc: %tu: %zd -> %zd\n",
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
c228: e5950020 ldr r0, [r5, #32]
for (b = 0, bd = group->bdbuf;
c22c: e5974010 ldr r4, [r7, #16]
c230: 0a000011 beq c27c <rtems_bdbuf_get_buffer_from_lru_list+0xb0>
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;
c234: e58d3000 str r3, [sp]
c238: eb003a71 bl 1ac04 <__aeabi_uidiv>
for (b = 0, bd = group->bdbuf;
c23c: e0600180 rsb r0, r0, r0, lsl #3
c240: e1a00180 lsl r0, r0, #3
c244: e58d0004 str r0, [sp, #4]
c248: e59d3000 ldr r3, [sp]
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
c24c: e1a00004 mov r0, r4
c250: e58d3000 str r3, [sp]
c254: ebffffce bl c194 <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)
c258: e59d3000 ldr r3, [sp]
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;
c25c: e5972008 ldr r2, [r7, #8]
b < group->bds_per_group;
b++, bd += bufs_per_bd)
c260: e2833001 add r3, r3, #1
c264: e59d1004 ldr r1, [sp, #4]
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;
c268: e1530002 cmp r3, r2
b < group->bds_per_group;
b++, bd += bufs_per_bd)
c26c: e0844001 add r4, r4, r1
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;
c270: 3afffff5 bcc c24c <rtems_bdbuf_get_buffer_from_lru_list+0x80>
c274: e5950020 ldr r0, [r5, #32]
c278: e5974010 ldr r4, [r7, #16]
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;
c27c: e3580001 cmp r8, #1
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
c280: e5878008 str r8, [r7, #8]
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
c284: 9a000012 bls c2d4 <rtems_bdbuf_get_buffer_from_lru_list+0x108>
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;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
c288: e1a01008 mov r1, r8
c28c: eb003a5c bl 1ac04 <__aeabi_uidiv>
for (b = 1, bd = group->bdbuf + bufs_per_bd;
c290: e0600180 rsb r0, r0, r0, lsl #3
c294: e1a01180 lsl r1, r0, #3
c298: e0844001 add r4, r4, r1
c29c: e3a03001 mov r3, #1
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
c2a0: e5952040 ldr r2, [r5, #64] ; 0x40
b < group->bds_per_group;
b++, bd += bufs_per_bd)
c2a4: e2833001 add r3, r3, #1
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
c2a8: e1530008 cmp r3, r8
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c2ac: e584a020 str sl, [r4, #32]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
c2b0: e5849004 str r9, [r4, #4]
before_node = after_node->next; after_node->next = the_node;
c2b4: e5854040 str r4, [r5, #64] ; 0x40
the_node->next = before_node; before_node->previous = the_node;
c2b8: e5824004 str r4, [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;
c2bc: e5842000 str r2, [r4]
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)
c2c0: e0844001 add r4, r4, r1
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;
c2c4: 1afffff5 bne c2a0 <rtems_bdbuf_get_buffer_from_lru_list+0xd4>
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
if (b > 1)
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
c2c8: e59f02b8 ldr r0, [pc, #696] ; c588 <rtems_bdbuf_get_buffer_from_lru_list+0x3bc>
c2cc: ebfffe80 bl bcd4 <rtems_bdbuf_wake>
c2d0: e5974010 ldr r4, [r7, #16]
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, dd->bds_per_group);
}
if (empty_bd != NULL)
c2d4: e3540000 cmp r4, #0
c2d8: 1a00000c bne c310 <rtems_bdbuf_get_buffer_from_lru_list+0x144>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
c2dc: e5966000 ldr r6, [r6]
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))
c2e0: e59f12a4 ldr r1, [pc, #676] ; c58c <rtems_bdbuf_get_buffer_from_lru_list+0x3c0>
c2e4: e1560001 cmp r6, r1
c2e8: 1affffc2 bne c1f8 <rtems_bdbuf_get_buffer_from_lru_list+0x2c>
}
node = rtems_chain_next (node);
}
return NULL;
c2ec: e3a04000 mov r4, #0
}
c2f0: e1a00004 mov r0, r4
c2f4: e28dd08c add sp, sp, #140 ; 0x8c
c2f8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
*/
if (bd->waiters == 0)
{
if (bd->group->bds_per_group == dd->bds_per_group)
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
c2fc: e1a00006 mov r0, r6
c300: e1a04006 mov r4, r6
c304: ebffffa2 bl c194 <rtems_bdbuf_remove_from_tree_and_lru_list>
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, dd->bds_per_group);
}
if (empty_bd != NULL)
c308: e3540000 cmp r4, #0
c30c: 0afffff2 beq c2dc <rtems_bdbuf_get_buffer_from_lru_list+0x110>
rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
bd->block = block;
bd->avl.left = NULL;
c310: e3a02000 mov r2, #0
static void
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
c314: e584b014 str fp, [r4, #20]
bd->block = block; bd->avl.left = NULL;
c318: e5842008 str r2, [r4, #8]
bd->avl.right = NULL;
c31c: e584200c str r2, [r4, #12]
rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
c320: e595303c ldr r3, [r5, #60] ; 0x3c
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
bd->block = block;
c324: e59d8008 ldr r8, [sp, #8]
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
c328: e1530002 cmp r3, r2
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
bd->block = block;
c32c: e5848018 str r8, [r4, #24]
bd->avl.left = NULL; bd->avl.right = NULL; bd->waiters = 0;
c330: e5842024 str r2, [r4, #36] ; 0x24
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
c334: 0a00008c beq c56c <rtems_bdbuf_get_buffer_from_lru_list+0x3a0>
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;
c338: e28dc00c add ip, sp, #12
c33c: e1a0000c mov r0, ip
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
c340: e3a06001 mov r6, #1
break;
}
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
c344: e3e07000 mvn r7, #0
c348: ea000005 b c364 <rtems_bdbuf_get_buffer_from_lru_list+0x198>
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
q = p->avl.right;
c34c: e593100c ldr r1, [r3, #12]
if (q == NULL)
c350: e3510000 cmp r1, #0
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
c354: e5c36010 strb r6, [r3, #16]
q = p->avl.right;
if (q == NULL)
c358: 0a00007a beq c548 <rtems_bdbuf_get_buffer_from_lru_list+0x37c>
p->avl.cache = -1;
q = p->avl.left;
if (q == NULL)
{
q = node;
p->avl.left = q;
c35c: e1a00002 mov r0, r2
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
c360: e1a03001 mov r3, r1
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
c364: e5931014 ldr r1, [r3, #20]
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
c368: e1a02000 mov r2, r0
if (((uintptr_t) p->dd < (uintptr_t) dd)
c36c: e151000b cmp r1, fp
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
c370: e4823004 str r3, [r2], #4
if (((uintptr_t) p->dd < (uintptr_t) dd)
c374: 3afffff4 bcc c34c <rtems_bdbuf_get_buffer_from_lru_list+0x180>
|| ((p->dd == dd) && (p->block < block)))
c378: e15b0001 cmp fp, r1
c37c: 0a00004b beq c4b0 <rtems_bdbuf_get_buffer_from_lru_list+0x2e4>
}
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
q = p->avl.left;
c380: e5931008 ldr r1, [r3, #8]
if (q == NULL)
c384: e3510000 cmp r1, #0
break;
}
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
c388: e5c37010 strb r7, [r3, #16]
q = p->avl.left;
if (q == NULL)
c38c: 1afffff2 bne c35c <rtems_bdbuf_get_buffer_from_lru_list+0x190>
{
q = node;
p->avl.left = q;
c390: e5834008 str r4, [r3, #8]
c394: e3a020ff mov r2, #255 ; 0xff
}
p = q;
}
q->avl.left = q->avl.right = NULL;
c398: e3a07000 mov r7, #0
c39c: e1a02c02 lsl r2, r2, #24
c3a0: e584700c str r7, [r4, #12]
c3a4: e5847008 str r7, [r4, #8]
q->avl.bal = 0;
c3a8: e5c47011 strb r7, [r4, #17]
c3ac: e1a02c42 asr r2, r2, #24
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
c3b0: e3a08001 mov r8, #1
c3b4: ea000015 b c410 <rtems_bdbuf_get_buffer_from_lru_list+0x244>
break;
}
}
else
{
switch (p->avl.bal)
c3b8: e1d321d1 ldrsb r2, [r3, #17]
c3bc: e3520000 cmp r2, #0
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
c3c0: 05c38011 strbeq r8, [r3, #17]
c3c4: 01a01003 moveq r1, r3
c3c8: 03a06001 moveq r6, #1
break;
}
}
else
{
switch (p->avl.bal)
c3cc: 0a000005 beq c3e8 <rtems_bdbuf_get_buffer_from_lru_list+0x21c>
c3d0: e3520001 cmp r2, #1
c3d4: 0a000040 beq c4dc <rtems_bdbuf_get_buffer_from_lru_list+0x310>
c3d8: e3720001 cmn r2, #1
c3dc: 0a00003a beq c4cc <rtems_bdbuf_get_buffer_from_lru_list+0x300>
c3e0: e1a01003 mov r1, r3 <== NOT EXECUTED
c3e4: e3a06001 mov r6, #1 <== NOT EXECUTED
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
c3e8: e150000c cmp r0, ip
c3ec: 9a00002b bls c4a0 <rtems_bdbuf_get_buffer_from_lru_list+0x2d4>
{
p = *--buf_prev;
c3f0: e5103004 ldr r3, [r0, #-4]
if (p->avl.cache == -1)
c3f4: e1d321d0 ldrsb r2, [r3, #16]
c3f8: e3720001 cmn r2, #1
{
p->avl.left = q;
c3fc: 05831008 streq r1, [r3, #8]
}
else
{
p->avl.right = q;
c400: 1583100c strne r1, [r3, #12]
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
c404: e3560000 cmp r6, #0
p->avl.right = q;
}
}
else
{
*root = p;
c408: e2400004 sub r0, r0, #4
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
c40c: 0a000024 beq c4a4 <rtems_bdbuf_get_buffer_from_lru_list+0x2d8>
{
if (p->avl.cache == -1)
c410: e3720001 cmn r2, #1
c414: 1affffe7 bne c3b8 <rtems_bdbuf_get_buffer_from_lru_list+0x1ec>
{
switch (p->avl.bal)
c418: e1d311d1 ldrsb r1, [r3, #17]
c41c: e3510000 cmp r1, #0
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = -1;
c420: 05c32011 strbeq r2, [r3, #17]
c424: 01a01003 moveq r1, r3
c428: 03a06001 moveq r6, #1
while (modified)
{
if (p->avl.cache == -1)
{
switch (p->avl.bal)
c42c: 0affffed beq c3e8 <rtems_bdbuf_get_buffer_from_lru_list+0x21c>
c430: e3510001 cmp r1, #1
c434: 0a000024 beq c4cc <rtems_bdbuf_get_buffer_from_lru_list+0x300>
c438: e3710001 cmn r1, #1
c43c: 1affffe7 bne c3e0 <rtems_bdbuf_get_buffer_from_lru_list+0x214>
case 0:
p->avl.bal = -1;
break;
case -1:
p1 = p->avl.left;
c440: e5936008 ldr r6, [r3, #8]
if (p1->avl.bal == -1) /* simple LL-turn */
c444: e1d611d1 ldrsb r1, [r6, #17]
c448: e3710001 cmn r1, #1
c44c: 0a000040 beq c554 <rtems_bdbuf_get_buffer_from_lru_list+0x388>
p->avl.bal = 0;
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
c450: e596100c ldr r1, [r6, #12]
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
c454: e1d1a1d1 ldrsb sl, [r1, #17]
c458: e37a0001 cmn sl, #1
c45c: 13a0a000 movne sl, #0
c460: 03a0a001 moveq sl, #1
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
c464: e5919008 ldr r9, [r1, #8]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
c468: e5c3a011 strb sl, [r3, #17]
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
c46c: e586900c str r9, [r6, #12]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
c470: e1d1a1d1 ldrsb sl, [r1, #17]
c474: e35a0001 cmp sl, #1
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
c478: e591a00c ldr sl, [r1, #12]
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
c47c: 11a02007 movne r2, r7
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
c480: e5816008 str r6, [r1, #8]
p->avl.left = p2->avl.right;
p2->avl.right = p;
c484: e581300c str r3, [r1, #12]
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
c488: e583a008 str sl, [r3, #8]
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
c48c: e5c62011 strb r2, [r6, #17]
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
c490: e150000c cmp r0, ip
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
p = p2;
}
p->avl.bal = 0;
c494: e5c17011 strb r7, [r1, #17]
modified = false;
c498: e3a06000 mov r6, #0
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
c49c: 8affffd3 bhi c3f0 <rtems_bdbuf_get_buffer_from_lru_list+0x224>
p->avl.right = q;
}
}
else
{
*root = p;
c4a0: e585103c str r1, [r5, #60] ; 0x3c
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c4a4: e3a03001 mov r3, #1
c4a8: e5843020 str r3, [r4, #32]
if (empty_bd != NULL)
{
rtems_bdbuf_setup_empty_buffer (empty_bd, dd, block);
return empty_bd;
c4ac: eaffff8f b c2f0 <rtems_bdbuf_get_buffer_from_lru_list+0x124>
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
c4b0: e5931018 ldr r1, [r3, #24]
c4b4: e59d8008 ldr r8, [sp, #8]
c4b8: e1580001 cmp r8, r1
c4bc: 8affffa2 bhi c34c <rtems_bdbuf_get_buffer_from_lru_list+0x180>
q = node;
p->avl.right = q = node;
break;
}
}
else if ((p->dd != dd) || (p->block != block))
c4c0: 1affffae bne c380 <rtems_bdbuf_get_buffer_from_lru_list+0x1b4>
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);
c4c4: e3a00008 mov r0, #8 <== NOT EXECUTED
c4c8: ebfffd33 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
else
{
switch (p->avl.bal)
{
case -1:
p->avl.bal = 0;
c4cc: e5c37011 strb r7, [r3, #17]
c4d0: e1a01003 mov r1, r3
modified = false;
c4d4: e3a06000 mov r6, #0
c4d8: eaffffc2 b c3e8 <rtems_bdbuf_get_buffer_from_lru_list+0x21c>
case 0:
p->avl.bal = 1;
break;
case 1:
p1 = p->avl.right;
c4dc: e593200c ldr r2, [r3, #12]
if (p1->avl.bal == 1) /* simple RR-turn */
c4e0: e1d211d1 ldrsb r1, [r2, #17]
c4e4: e3510001 cmp r1, #1
{
p->avl.right = p1->avl.left;
c4e8: e5921008 ldr r1, [r2, #8]
p->avl.bal = 1;
break;
case 1:
p1 = p->avl.right;
if (p1->avl.bal == 1) /* simple RR-turn */
c4ec: 0a000010 beq c534 <rtems_bdbuf_get_buffer_from_lru_list+0x368>
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
c4f0: e1d161d1 ldrsb r6, [r1, #17]
c4f4: e3560001 cmp r6, #1
c4f8: 03a060ff moveq r6, #255 ; 0xff
c4fc: 13a06000 movne r6, #0
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
c500: e591a00c ldr sl, [r1, #12]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
c504: e5c36011 strb r6, [r3, #17]
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
c508: e582a008 str sl, [r2, #8]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
c50c: e1d161d1 ldrsb r6, [r1, #17]
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
c510: e591a008 ldr sl, [r1, #8]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
c514: e3760001 cmn r6, #1
c518: 11a06007 movne r6, r7
c51c: 01a06008 moveq r6, r8
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
c520: e581200c str r2, [r1, #12]
p->avl.right = p2->avl.left;
p2->avl.left = p;
c524: e5813008 str r3, [r1, #8]
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
c528: e583a00c str sl, [r3, #12]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
c52c: e5c26011 strb r6, [r2, #17]
c530: eaffffd6 b c490 <rtems_bdbuf_get_buffer_from_lru_list+0x2c4>
case 1:
p1 = p->avl.right;
if (p1->avl.bal == 1) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
c534: e583100c str r1, [r3, #12]
p1->avl.left = p;
p->avl.bal = 0;
c538: e5c37011 strb r7, [r3, #17]
case 1:
p1 = p->avl.right;
if (p1->avl.bal == 1) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
p1->avl.left = p;
c53c: e5823008 str r3, [r2, #8]
p->avl.bal = 0;
c540: e1a01002 mov r1, r2
c544: eaffffd1 b c490 <rtems_bdbuf_get_buffer_from_lru_list+0x2c4>
p->avl.cache = 1;
q = p->avl.right;
if (q == NULL)
{
q = node;
p->avl.right = q = node;
c548: e583400c str r4, [r3, #12]
c54c: e3a02001 mov r2, #1
c550: eaffff90 b c398 <rtems_bdbuf_get_buffer_from_lru_list+0x1cc>
case -1:
p1 = p->avl.left;
if (p1->avl.bal == -1) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
c554: e596200c ldr r2, [r6, #12]
p1->avl.right = p;
p->avl.bal = 0;
c558: e5c37011 strb r7, [r3, #17]
case -1:
p1 = p->avl.left;
if (p1->avl.bal == -1) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
c55c: e5832008 str r2, [r3, #8]
p1->avl.right = p;
c560: e586300c str r3, [r6, #12]
p->avl.bal = 0;
c564: e1a01006 mov r1, r6
c568: eaffffc8 b c490 <rtems_bdbuf_get_buffer_from_lru_list+0x2c4>
bool modified = false;
if (p == NULL)
{
*root = node;
c56c: e59f2010 ldr r2, [pc, #16] ; c584 <rtems_bdbuf_get_buffer_from_lru_list+0x3b8>
c570: e582403c str r4, [r2, #60] ; 0x3c
node->avl.left = NULL;
c574: e5843008 str r3, [r4, #8]
node->avl.right = NULL;
c578: e584300c str r3, [r4, #12]
node->avl.bal = 0;
c57c: e5c43011 strb r3, [r4, #17]
c580: eaffffc7 b c4a4 <rtems_bdbuf_get_buffer_from_lru_list+0x2d8>
0000d260 <rtems_bdbuf_init>:
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
d260: 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())
d264: e59f340c ldr r3, [pc, #1036] ; d678 <rtems_bdbuf_init+0x418>
d268: e5933000 ldr r3, [r3]
d26c: e3530000 cmp r3, #0
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
d270: e24dd014 sub sp, sp, #20
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
return RTEMS_CALLED_FROM_ISR;
d274: 13a00012 movne r0, #18
rtems_mode prev_mode;
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
d278: 0a000001 beq d284 <rtems_bdbuf_init+0x24>
}
bdbuf_cache.initialised = false;
return RTEMS_UNSATISFIED;
}
d27c: e28dd014 add sp, sp, #20
d280: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return RTEMS_CALLED_FROM_ISR;
/*
* Check the configuration table values.
*/
if ((bdbuf_config.buffer_max % bdbuf_config.buffer_min) != 0)
d284: e59f43f0 ldr r4, [pc, #1008] ; d67c <rtems_bdbuf_init+0x41c>
d288: e59f53ec ldr r5, [pc, #1004] ; d67c <rtems_bdbuf_init+0x41c>
d28c: e5944028 ldr r4, [r4, #40] ; 0x28
d290: e5955024 ldr r5, [r5, #36] ; 0x24
d294: e1a00004 mov r0, r4
d298: e1a01005 mov r1, r5
d29c: e58d400c str r4, [sp, #12]
d2a0: e58d5008 str r5, [sp, #8]
d2a4: eb00369c bl 1ad1c <__umodsi3>
d2a8: e3500000 cmp r0, #0
return RTEMS_INVALID_NUMBER;
d2ac: 13a0000a movne r0, #10
return RTEMS_CALLED_FROM_ISR;
/*
* Check the configuration table values.
*/
if ((bdbuf_config.buffer_max % bdbuf_config.buffer_min) != 0)
d2b0: 1afffff1 bne d27c <rtems_bdbuf_init+0x1c>
/*
* 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 ();
d2b4: ebfff9fe bl bab4 <rtems_bdbuf_disable_preemption>
if (bdbuf_cache.initialised)
d2b8: e59f63c0 ldr r6, [pc, #960] ; d680 <rtems_bdbuf_init+0x420>
d2bc: e5d66095 ldrb r6, [r6, #149] ; 0x95
d2c0: e3560000 cmp r6, #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 ();
d2c4: e1a04000 mov r4, r0
if (bdbuf_cache.initialised)
d2c8: e58d6010 str r6, [sp, #16]
d2cc: 0a000002 beq d2dc <rtems_bdbuf_init+0x7c>
{
rtems_bdbuf_restore_preemption (prev_mode);
d2d0: ebfffa07 bl baf4 <rtems_bdbuf_restore_preemption> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
d2d4: e3a0000c mov r0, #12 <== NOT EXECUTED
d2d8: eaffffe7 b d27c <rtems_bdbuf_init+0x1c> <== NOT EXECUTED
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
bdbuf_cache.initialised = true;
d2dc: e59f839c ldr r8, [pc, #924] ; d680 <rtems_bdbuf_init+0x420>
{
rtems_bdbuf_restore_preemption (prev_mode);
return RTEMS_RESOURCE_IN_USE;
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
d2e0: e59d1010 ldr r1, [sp, #16]
d2e4: e3a02098 mov r2, #152 ; 0x98
bdbuf_cache.initialised = true;
d2e8: e3a07001 mov r7, #1
{
rtems_bdbuf_restore_preemption (prev_mode);
return RTEMS_RESOURCE_IN_USE;
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
d2ec: e59f038c ldr r0, [pc, #908] ; d680 <rtems_bdbuf_init+0x420>
d2f0: eb0014fd bl 126ec <memset>
bdbuf_cache.initialised = true; rtems_bdbuf_restore_preemption (prev_mode);
d2f4: e1a00004 mov r0, r4
rtems_bdbuf_restore_preemption (prev_mode);
return RTEMS_RESOURCE_IN_USE;
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
bdbuf_cache.initialised = true;
d2f8: e5c87095 strb r7, [r8, #149] ; 0x95
rtems_bdbuf_restore_preemption (prev_mode);
d2fc: ebfff9fc bl baf4 <rtems_bdbuf_restore_preemption>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
d300: e288700c add r7, r8, #12
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'),
d304: e59d3010 ldr r3, [sp, #16]
head->previous = NULL; tail->previous = head;
d308: e2886008 add r6, r8, #8
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
d30c: e5887008 str r7, [r8, #8]
head->previous = NULL; tail->previous = head;
d310: e5886010 str r6, [r8, #16]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
d314: e2884050 add r4, r8, #80 ; 0x50
head->previous = NULL; tail->previous = head;
d318: e288e04c add lr, r8, #76 ; 0x4c
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
d31c: e288c05c add ip, r8, #92 ; 0x5c
head->previous = NULL; tail->previous = head;
d320: e2885040 add r5, r8, #64 ; 0x40
d324: e2889088 add r9, r8, #136 ; 0x88
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
d328: e2886044 add r6, r8, #68 ; 0x44
head->previous = NULL; tail->previous = head;
d32c: e2887058 add r7, r8, #88 ; 0x58
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
d330: e288a08c add sl, r8, #140 ; 0x8c
d334: e588404c str r4, [r8, #76] ; 0x4c
*/
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;
d338: e5883038 str r3, [r8, #56] ; 0x38
head->previous = NULL;
d33c: e588300c str r3, [r8, #12]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
d340: e5886040 str r6, [r8, #64] ; 0x40
head->previous = NULL;
d344: e5883044 str r3, [r8, #68] ; 0x44
tail->previous = head;
d348: e5885048 str r5, [r8, #72] ; 0x48
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
d34c: e5883050 str r3, [r8, #80] ; 0x50
tail->previous = head;
d350: e588e054 str lr, [r8, #84] ; 0x54
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
d354: e588c058 str ip, [r8, #88] ; 0x58
head->previous = NULL;
d358: e588305c str r3, [r8, #92] ; 0x5c
tail->previous = head;
d35c: e5887060 str r7, [r8, #96] ; 0x60
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
d360: e588a088 str sl, [r8, #136] ; 0x88
head->previous = NULL;
d364: e588308c str r3, [r8, #140] ; 0x8c
tail->previous = head;
d368: e5889090 str r9, [r8, #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'),
d36c: e288b028 add fp, r8, #40 ; 0x28
d370: e59f030c ldr r0, [pc, #780] ; d684 <rtems_bdbuf_init+0x424>
d374: e3a01001 mov r1, #1
d378: e3a02054 mov r2, #84 ; 0x54
d37c: e58db000 str fp, [sp]
d380: ebffe93d bl 787c <rtems_semaphore_create>
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
d384: e2504000 subs r4, r0, #0
d388: 0a000026 beq d428 <rtems_bdbuf_init+0x1c8>
return RTEMS_SUCCESSFUL;
error:
if (bdbuf_cache.read_ahead_task != 0)
d38c: e59f72ec ldr r7, [pc, #748] ; d680 <rtems_bdbuf_init+0x420><== NOT EXECUTED
d390: e5970084 ldr r0, [r7, #132] ; 0x84 <== NOT EXECUTED
d394: e3500000 cmp r0, #0 <== NOT EXECUTED
d398: 1a00001a bne d408 <rtems_bdbuf_init+0x1a8> <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.read_ahead_task);
if (bdbuf_cache.swapout != 0)
d39c: e59f82dc ldr r8, [pc, #732] ; d680 <rtems_bdbuf_init+0x420><== NOT EXECUTED
d3a0: e5980000 ldr r0, [r8] <== NOT EXECUTED
d3a4: e3500000 cmp r0, #0 <== NOT EXECUTED
d3a8: 1a00001c bne d420 <rtems_bdbuf_init+0x1c0> <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.swapout);
free (bdbuf_cache.buffers);
d3ac: e59fa2cc ldr sl, [pc, #716] ; d680 <rtems_bdbuf_init+0x420><== NOT EXECUTED
d3b0: e59a0018 ldr r0, [sl, #24] <== NOT EXECUTED
d3b4: ebffd91b bl 3828 <free> <== NOT EXECUTED
free (bdbuf_cache.groups);
d3b8: e59a0080 ldr r0, [sl, #128] ; 0x80 <== NOT EXECUTED
d3bc: ebffd919 bl 3828 <free> <== NOT EXECUTED
free (bdbuf_cache.bds);
d3c0: e59a0014 ldr r0, [sl, #20] <== NOT EXECUTED
d3c4: ebffd917 bl 3828 <free> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);
d3c8: e59a0078 ldr r0, [sl, #120] ; 0x78 <== NOT EXECUTED
d3cc: ebffe99a bl 7a3c <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);
d3d0: e59a0068 ldr r0, [sl, #104] ; 0x68 <== NOT EXECUTED
d3d4: ebffe998 bl 7a3c <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
d3d8: e59a0070 ldr r0, [sl, #112] ; 0x70 <== NOT EXECUTED
d3dc: ebffe996 bl 7a3c <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.sync_lock);
d3e0: e59a002c ldr r0, [sl, #44] ; 0x2c <== NOT EXECUTED
d3e4: ebffe994 bl 7a3c <rtems_semaphore_delete> <== NOT EXECUTED
if (bdbuf_cache.lock != 0)
d3e8: e59a3028 ldr r3, [sl, #40] ; 0x28 <== NOT EXECUTED
d3ec: e3530000 cmp r3, #0 <== NOT EXECUTED
d3f0: 1a000006 bne d410 <rtems_bdbuf_init+0x1b0> <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
rtems_semaphore_delete (bdbuf_cache.lock);
}
bdbuf_cache.initialised = false;
d3f4: e59fc284 ldr ip, [pc, #644] ; d680 <rtems_bdbuf_init+0x420><== NOT EXECUTED
d3f8: e3a03000 mov r3, #0 <== NOT EXECUTED
d3fc: e5cc3095 strb r3, [ip, #149] ; 0x95 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
d400: e3a0000d mov r0, #13 <== NOT EXECUTED
d404: eaffff9c b d27c <rtems_bdbuf_init+0x1c> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
error:
if (bdbuf_cache.read_ahead_task != 0)
rtems_task_delete (bdbuf_cache.read_ahead_task);
d408: ebffea8e bl 7e48 <rtems_task_delete> <== NOT EXECUTED
d40c: eaffffe2 b d39c <rtems_bdbuf_init+0x13c> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
rtems_semaphore_delete (bdbuf_cache.sync_lock);
if (bdbuf_cache.lock != 0)
{
rtems_bdbuf_unlock_cache ();
d410: ebfff97e bl ba10 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.lock);
d414: e59a0028 ldr r0, [sl, #40] ; 0x28 <== NOT EXECUTED
d418: ebffe987 bl 7a3c <rtems_semaphore_delete> <== NOT EXECUTED
d41c: eafffff4 b d3f4 <rtems_bdbuf_init+0x194> <== NOT EXECUTED
if (bdbuf_cache.read_ahead_task != 0)
rtems_task_delete (bdbuf_cache.read_ahead_task);
if (bdbuf_cache.swapout != 0)
rtems_task_delete (bdbuf_cache.swapout);
d420: ebffea88 bl 7e48 <rtems_task_delete> <== NOT EXECUTED
d424: eaffffe0 b d3ac <rtems_bdbuf_init+0x14c> <== NOT EXECUTED
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
goto error;
rtems_bdbuf_lock_cache ();
d428: ebfff95f bl b9ac <rtems_bdbuf_lock_cache>
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'),
d42c: e288c02c add ip, r8, #44 ; 0x2c
d430: e3a01001 mov r1, #1
d434: e59f024c ldr r0, [pc, #588] ; d688 <rtems_bdbuf_init+0x428>
d438: e3a02054 mov r2, #84 ; 0x54
d43c: e1a03004 mov r3, r4
d440: e58dc000 str ip, [sp]
d444: ebffe90c bl 787c <rtems_semaphore_create>
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.sync_lock);
if (sc != RTEMS_SUCCESSFUL)
d448: e2501000 subs r1, r0, #0
d44c: 1affffce bne d38c <rtems_bdbuf_init+0x12c>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'),
d450: e288c068 add ip, r8, #104 ; 0x68
d454: e1a03001 mov r3, r1
d458: e59f022c ldr r0, [pc, #556] ; d68c <rtems_bdbuf_init+0x42c>
d45c: e3a02024 mov r2, #36 ; 0x24
d460: e58dc000 str ip, [sp]
d464: ebffe904 bl 787c <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.access_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
d468: e2501000 subs r1, r0, #0
d46c: 1affffc6 bne d38c <rtems_bdbuf_init+0x12c>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'),
d470: e288c070 add ip, r8, #112 ; 0x70
d474: e1a03001 mov r3, r1
d478: e59f0210 ldr r0, [pc, #528] ; d690 <rtems_bdbuf_init+0x430>
d47c: e3a02024 mov r2, #36 ; 0x24
d480: e58dc000 str ip, [sp]
d484: ebffe8fc bl 787c <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.transfer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
d488: e2501000 subs r1, r0, #0
d48c: 1affffbe bne d38c <rtems_bdbuf_init+0x12c>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'),
d490: e288c078 add ip, r8, #120 ; 0x78
d494: e59f01f8 ldr r0, [pc, #504] ; d694 <rtems_bdbuf_init+0x434>
d498: e3a02024 mov r2, #36 ; 0x24
d49c: e1a03001 mov r3, r1
d4a0: e58dc000 str ip, [sp]
d4a4: ebffe8f4 bl 787c <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.buffer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
d4a8: e3500000 cmp r0, #0
d4ac: 1affffb6 bne d38c <rtems_bdbuf_init+0x12c>
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
d4b0: e59fe1c4 ldr lr, [pc, #452] ; d67c <rtems_bdbuf_init+0x41c>
d4b4: e59d1008 ldr r1, [sp, #8]
d4b8: e59e0020 ldr r0, [lr, #32]
d4bc: eb0035d0 bl 1ac04 <__aeabi_uidiv>
d4c0: e1a05000 mov r5, r0
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
d4c4: e59d1008 ldr r1, [sp, #8]
d4c8: e59d000c ldr r0, [sp, #12]
goto error;
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
d4cc: e588501c str r5, [r8, #28]
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
d4d0: eb0035cb bl 1ac04 <__aeabi_uidiv>
d4d4: e1a03000 mov r3, r0
bdbuf_cache.group_count =
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
d4d8: 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 =
d4dc: e5883020 str r3, [r8, #32]
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
d4e0: e1a00005 mov r0, r5
d4e4: eb0035c6 bl 1ac04 <__aeabi_uidiv>
d4e8: e1a04000 mov r4, r0
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
d4ec: e1a01005 mov r1, r5
d4f0: e3a00038 mov r0, #56 ; 0x38
*/
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 =
d4f4: e588407c str r4, [r8, #124] ; 0x7c
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),
d4f8: ebffd80f bl 353c <calloc>
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
d4fc: 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),
d500: e5880014 str r0, [r8, #20]
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
d504: 0affffa0 beq d38c <rtems_bdbuf_init+0x12c>
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
d508: e3a00014 mov r0, #20
d50c: e1a01004 mov r1, r4
d510: ebffd809 bl 353c <calloc>
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
d514: e3500000 cmp r0, #0
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
d518: e5880080 str r0, [r8, #128] ; 0x80
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
d51c: 0affff9a beq d38c <rtems_bdbuf_init+0x12c>
* 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,
d520: e59d6008 ldr r6, [sp, #8]
d524: e3a01020 mov r1, #32
d528: e2880018 add r0, r8, #24
d52c: e0020596 mul r2, r6, r5
d530: eb000740 bl f238 <rtems_memalign>
d534: e3500000 cmp r0, #0
d538: e1a04008 mov r4, r8
d53c: 1affff92 bne d38c <rtems_bdbuf_init+0x12c>
/*
* 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,
d540: e5985080 ldr r5, [r8, #128] ; 0x80
bd->group = group;
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
d544: e594b020 ldr fp, [r4, #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;
b < bdbuf_cache.buffer_min_count;
d548: e594201c ldr r2, [r4, #28]
/*
* 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;
d54c: e5988014 ldr r8, [r8, #20]
d550: e594a018 ldr sl, [r4, #24]
/*
* 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,
d554: e1a09005 mov r9, r5
d558: e58d500c str r5, [sp, #12]
d55c: e1a06000 mov r6, r0
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))
d560: e24b7001 sub r7, fp, #1
/*
* 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;
d564: e1a04008 mov r4, r8
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dd = BDBUF_INVALID_DEV;
d568: e1a0c000 mov ip, r0
d56c: e1a05002 mov r5, r2
/*
* 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,
d570: e1560005 cmp r6, r5
bd->group = group;
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
d574: e1a00006 mov r0, r6
d578: e1a0100b mov r1, fp
/*
* 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,
d57c: 0a000013 beq d5d0 <rtems_bdbuf_init+0x370>
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;
bd->group = group;
d580: e5849028 str r9, [r4, #40] ; 0x28
bd->buffer = buffer;
d584: e584a01c str sl, [r4, #28]
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)
{
bd->dd = BDBUF_INVALID_DEV;
d588: e584c014 str ip, [r4, #20]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
d58c: e59fe0ec ldr lr, [pc, #236] ; d680 <rtems_bdbuf_init+0x420>
d590: e59e3048 ldr r3, [lr, #72] ; 0x48
the_node->next = tail;
d594: e28e2044 add r2, lr, #68 ; 0x44
d598: e5842000 str r2, [r4]
tail->previous = the_node; old_last->next = the_node;
d59c: e5834000 str r4, [r3]
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
d5a0: e58e4048 str r4, [lr, #72] ; 0x48
old_last->next = the_node; the_node->previous = old_last;
d5a4: e5843004 str r3, [r4, #4]
bd->group = group;
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
d5a8: e58dc004 str ip, [sp, #4]
d5ac: eb0035da bl 1ad1c <__umodsi3>
* 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)
d5b0: e59d3008 ldr r3, [sp, #8]
bd->group = group;
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
d5b4: e1500007 cmp r0, r7
d5b8: e59dc004 ldr ip, [sp, #4]
(bdbuf_cache.max_bds_per_group - 1))
group++;
d5bc: 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)
d5c0: e2866001 add r6, r6, #1
d5c4: e2844038 add r4, r4, #56 ; 0x38
d5c8: e08aa003 add sl, sl, r3
d5cc: eaffffe7 b d570 <rtems_bdbuf_init+0x310>
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
d5d0: e59f40a8 ldr r4, [pc, #168] ; d680 <rtems_bdbuf_init+0x420>
d5d4: e5942020 ldr r2, [r4, #32]
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
d5d8: e3a01038 mov r1, #56 ; 0x38
d5dc: e0010192 mul r1, r2, r1
d5e0: e59d500c ldr r5, [sp, #12]
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
d5e4: e594007c ldr r0, [r4, #124] ; 0x7c
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
d5e8: e3a03000 mov r3, #0
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
d5ec: e1530000 cmp r3, r0
d5f0: 0a000005 beq d60c <rtems_bdbuf_init+0x3ac>
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
group->bdbuf = bd;
d5f4: e5858010 str r8, [r5, #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;
d5f8: e5852008 str r2, [r5, #8]
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
d5fc: e2833001 add r3, r3, #1
group++,
d600: e2855014 add r5, r5, #20
bd += bdbuf_cache.max_bds_per_group)
d604: e0888001 add r8, r8, r1
d608: eafffff7 b d5ec <rtems_bdbuf_init+0x38c>
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
d60c: e59f606c ldr r6, [pc, #108] ; d680 <rtems_bdbuf_init+0x420>
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
d610: e59f5064 ldr r5, [pc, #100] ; d67c <rtems_bdbuf_init+0x41c>
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
d614: e3a04001 mov r4, #1
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
d618: e3a03000 mov r3, #0
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
d61c: e5c64004 strb r4, [r6, #4]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
d620: e59f0070 ldr r0, [pc, #112] ; d698 <rtems_bdbuf_init+0x438>
d624: e5951008 ldr r1, [r5, #8]
d628: e59f206c ldr r2, [pc, #108] ; d69c <rtems_bdbuf_init+0x43c>
d62c: e58d6000 str r6, [sp]
d630: ebfff9e2 bl bdc0 <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)
d634: e2503000 subs r3, r0, #0
d638: 1affff53 bne d38c <rtems_bdbuf_init+0x12c>
goto error;
if (bdbuf_config.max_read_ahead_blocks > 0)
d63c: e5951000 ldr r1, [r5]
d640: e3510000 cmp r1, #0
d644: 0a000008 beq d66c <rtems_bdbuf_init+0x40c>
{
bdbuf_cache.read_ahead_enabled = true;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'R', 'D', 'A'),
d648: e286e084 add lr, r6, #132 ; 0x84
if (sc != RTEMS_SUCCESSFUL)
goto error;
if (bdbuf_config.max_read_ahead_blocks > 0)
{
bdbuf_cache.read_ahead_enabled = true;
d64c: e5c64094 strb r4, [r6, #148] ; 0x94
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'R', 'D', 'A'),
d650: e59f0048 ldr r0, [pc, #72] ; d6a0 <rtems_bdbuf_init+0x440>
d654: e595102c ldr r1, [r5, #44] ; 0x2c
d658: e59f2044 ldr r2, [pc, #68] ; d6a4 <rtems_bdbuf_init+0x444>
d65c: e58de000 str lr, [sp]
d660: ebfff9d6 bl bdc0 <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)
d664: e3500000 cmp r0, #0
d668: 1affff47 bne d38c <rtems_bdbuf_init+0x12c>
goto error;
}
rtems_bdbuf_unlock_cache ();
d66c: ebfff8e7 bl ba10 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
d670: e3a00000 mov r0, #0
d674: eaffff00 b d27c <rtems_bdbuf_init+0x1c>
0000b9ac <rtems_bdbuf_lock_cache>:
* @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,
b9ac: e59f3020 ldr r3, [pc, #32] ; b9d4 <rtems_bdbuf_lock_cache+0x28>
b9b0: e3a01000 mov r1, #0
/**
* Lock the cache. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_cache (void)
{
b9b4: 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,
b9b8: e5930028 ldr r0, [r3, #40] ; 0x28
b9bc: e1a02001 mov r2, r1
b9c0: ebfff046 bl 7ae0 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
b9c4: e3500000 cmp r0, #0
b9c8: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_bdbuf_fatal (fatal_error_code);
b9cc: e3a00000 mov r0, #0 <== NOT EXECUTED
b9d0: ebfffff1 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
0000b9d8 <rtems_bdbuf_lock_sync>:
* @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,
b9d8: e59f3020 ldr r3, [pc, #32] ; ba00 <rtems_bdbuf_lock_sync+0x28>
b9dc: e3a01000 mov r1, #0
/**
* Lock the cache's sync. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_sync (void)
{
b9e0: 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,
b9e4: e593002c ldr r0, [r3, #44] ; 0x2c
b9e8: e1a02001 mov r2, r1
b9ec: ebfff03b bl 7ae0 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
b9f0: e3500000 cmp r0, #0
b9f4: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_bdbuf_fatal (fatal_error_code);
b9f8: e3a00019 mov r0, #25 <== NOT EXECUTED
b9fc: ebffffe6 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
0000dc34 <rtems_bdbuf_purge_dev>:
}
}
void
rtems_bdbuf_purge_dev (rtems_disk_device *dd)
{
dc34: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
dc38: e24dd08c sub sp, sp, #140 ; 0x8c
dc3c: e1a06000 mov r6, r0
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
dc40: e3a05000 mov r5, #0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
dc44: e28da080 add sl, sp, #128 ; 0x80
dc48: e28d7084 add r7, sp, #132 ; 0x84
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;
dc4c: e59f81d8 ldr r8, [pc, #472] ; de2c <rtems_bdbuf_purge_dev+0x1f8>
dc50: e58d7080 str r7, [sp, #128] ; 0x80
head->previous = NULL;
dc54: e58d5084 str r5, [sp, #132] ; 0x84
tail->previous = head;
dc58: e58da088 str sl, [sp, #136] ; 0x88
rtems_bdbuf_purge_dev (rtems_disk_device *dd)
{
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
dc5c: ebfff752 bl b9ac <rtems_bdbuf_lock_cache>
}
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
dc60: e1a00006 mov r0, r6
dc64: ebfff808 bl bc8c <rtems_bdbuf_read_ahead_cancel>
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;
dc68: e598403c ldr r4, [r8, #60] ; 0x3c
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
dc6c: e3e03000 mvn r3, #0
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
dc70: e1540005 cmp r4, r5
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
dc74: e586306c str r3, [r6, #108] ; 0x6c
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
dc78: e58d5000 str r5, [sp]
while (cur != NULL)
dc7c: 0a00003f beq dd80 <rtems_bdbuf_purge_dev+0x14c>
static void
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;
dc80: e1a0500d mov r5, sp
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
dc84: e3a0b006 mov fp, #6
dc88: e3a0900a mov r9, #10
dc8c: ea000005 b dca8 <rtems_bdbuf_purge_dev+0x74>
default:
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_STATE_11);
}
}
if (cur->avl.left != NULL)
dc90: e5943008 ldr r3, [r4, #8]
dc94: e3530000 cmp r3, #0
dc98: 0a000025 beq dd34 <rtems_bdbuf_purge_dev+0x100>
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
*prev = cur;
dc9c: e5854004 str r4, [r5, #4]
dca0: e1a04003 mov r4, r3
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
dca4: e2855004 add r5, r5, #4
*prev = NULL;
while (cur != NULL)
{
if (cur->dd == dd)
dca8: e5943014 ldr r3, [r4, #20]
dcac: e1560003 cmp r6, r3
dcb0: 1afffff6 bne dc90 <rtems_bdbuf_purge_dev+0x5c>
{
switch (cur->state)
dcb4: e5943020 ldr r3, [r4, #32]
dcb8: e353000a cmp r3, #10
dcbc: 979ff103 ldrls pc, [pc, r3, lsl #2]
dcc0: ea000052 b de10 <rtems_bdbuf_purge_dev+0x1dc> <== NOT EXECUTED
dcc4: 0000dc90 .word 0x0000dc90 <== NOT EXECUTED
dcc8: 0000dc90 .word 0x0000dc90 <== NOT EXECUTED
dccc: 0000dd08 .word 0x0000dd08 <== NOT EXECUTED
dcd0: 0000de08 .word 0x0000de08 <== NOT EXECUTED
dcd4: 0000de08 .word 0x0000de08 <== NOT EXECUTED
dcd8: 0000de08 .word 0x0000de08 <== NOT EXECUTED
dcdc: 0000dc90 .word 0x0000dc90 <== NOT EXECUTED
dce0: 0000dcf8 .word 0x0000dcf8 <== NOT EXECUTED
dce4: 0000dcf0 .word 0x0000dcf0 <== NOT EXECUTED
dce8: 0000de00 .word 0x0000de00 <== NOT EXECUTED
dcec: 0000dc90 .word 0x0000dc90 <== 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);
dcf0: e59f0138 ldr r0, [pc, #312] ; de30 <rtems_bdbuf_purge_dev+0x1fc>
dcf4: ebfff7f6 bl bcd4 <rtems_bdbuf_wake>
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
dcf8: e5943028 ldr r3, [r4, #40] ; 0x28
dcfc: e593200c ldr r2, [r3, #12]
dd00: e2422001 sub r2, r2, #1
dd04: e583200c str r2, [r3, #12]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
dd08: e8940006 ldm r4, {r1, r2}
next->previous = previous;
dd0c: e5812004 str r2, [r1, #4]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
dd10: e59d3088 ldr r3, [sp, #136] ; 0x88
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
previous->next = next;
dd14: e5821000 str r1, [r2]
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
dd18: e58d4088 str r4, [sp, #136] ; 0x88
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
dd1c: e5847000 str r7, [r4]
tail->previous = the_node; old_last->next = the_node; the_node->previous = old_last;
dd20: 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;
dd24: e5834000 str r4, [r3]
default:
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_STATE_11);
}
}
if (cur->avl.left != NULL)
dd28: e5943008 ldr r3, [r4, #8]
dd2c: e3530000 cmp r3, #0
dd30: 1affffd9 bne dc9c <rtems_bdbuf_purge_dev+0x68>
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
dd34: e594300c ldr r3, [r4, #12]
dd38: e3530000 cmp r3, #0
dd3c: 1affffd6 bne dc9c <rtems_bdbuf_purge_dev+0x68>
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL
dd40: e5953000 ldr r3, [r5]
dd44: e3530000 cmp r3, #0
dd48: 0a00000c beq dd80 <rtems_bdbuf_purge_dev+0x14c>
dd4c: e1a02005 mov r2, r5
dd50: ea000001 b dd5c <rtems_bdbuf_purge_dev+0x128>
dd54: e1a04003 mov r4, r3
dd58: e1a03001 mov r3, r1
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
dd5c: e593100c ldr r1, [r3, #12]
dd60: e1510004 cmp r1, r4
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL
dd64: e1a05002 mov r5, r2
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
dd68: 0a000001 beq dd74 <rtems_bdbuf_purge_dev+0x140>
dd6c: e3510000 cmp r1, #0
dd70: 1a00002b bne de24 <rtems_bdbuf_purge_dev+0x1f0>
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL
dd74: e5321004 ldr r1, [r2, #-4]!
dd78: e3510000 cmp r1, #0
dd7c: 1afffff4 bne dd54 <rtems_bdbuf_purge_dev+0x120>
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
dd80: e59d4080 ldr r4, [sp, #128] ; 0x80
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
dd84: e59f90a8 ldr r9, [pc, #168] ; de34 <rtems_bdbuf_purge_dev+0x200>
while ((node = rtems_chain_get_unprotected (purge_list)) != NULL)
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
wake_buffer_waiters = true;
dd88: e3a02000 mov r2, #0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
dd8c: e3a06001 mov r6, #1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
dd90: e1540007 cmp r4, r7
dd94: 0a000011 beq dde0 <rtems_bdbuf_purge_dev+0x1ac>
while ((node = rtems_chain_get_unprotected (purge_list)) != NULL)
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
dd98: e5945024 ldr r5, [r4, #36] ; 0x24
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
dd9c: e5943000 ldr r3, [r4]
dda0: e3550000 cmp r5, #0
head->next = new_first;
dda4: e58d3080 str r3, [sp, #128] ; 0x80
new_first->previous = head;
dda8: e583a004 str sl, [r3, #4]
ddac: 1a000010 bne ddf4 <rtems_bdbuf_purge_dev+0x1c0>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ddb0: e5846020 str r6, [r4, #32]
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
{
rtems_bdbuf_remove_from_tree (bd);
ddb4: e1a00004 mov r0, r4
ddb8: ebfff81c bl be30 <rtems_bdbuf_remove_from_tree>
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
ddbc: e5983040 ldr r3, [r8, #64] ; 0x40
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ddc0: e5845020 str r5, [r4, #32]
after_node->next = the_node;
ddc4: e5884040 str r4, [r8, #64] ; 0x40
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
ddc8: e8840208 stm r4, {r3, r9}
before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; before_node->previous = the_node;
ddcc: e5834004 str r4, [r3, #4]
ddd0: e59d4080 ldr r4, [sp, #128] ; 0x80
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
ddd4: e1540007 cmp r4, r7
while ((node = rtems_chain_get_unprotected (purge_list)) != NULL)
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
wake_buffer_waiters = true;
ddd8: e3a02001 mov r2, #1
dddc: 1affffed bne dd98 <rtems_bdbuf_purge_dev+0x164>
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
dde0: e3520000 cmp r2, #0
dde4: 1a00000b bne de18 <rtems_bdbuf_purge_dev+0x1e4>
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 ();
dde8: ebfff708 bl ba10 <rtems_bdbuf_unlock_cache>
}
ddec: e28dd08c add sp, sp, #140 ; 0x8c
ddf0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ddf4: e5846020 str r6, [r4, #32]
ddf8: e1a04003 mov r4, r3
ddfc: eaffffe3 b dd90 <rtems_bdbuf_purge_dev+0x15c>
de00: e5849020 str r9, [r4, #32]
de04: eaffffa1 b dc90 <rtems_bdbuf_purge_dev+0x5c>
de08: e584b020 str fp, [r4, #32]
de0c: eaffff9f b dc90 <rtems_bdbuf_purge_dev+0x5c>
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);
de10: e3a00017 mov r0, #23 <== NOT EXECUTED
de14: ebfff6e0 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
de18: e59f0018 ldr r0, [pc, #24] ; de38 <rtems_bdbuf_purge_dev+0x204>
de1c: ebfff7ac bl bcd4 <rtems_bdbuf_wake>
de20: eafffff0 b dde8 <rtems_bdbuf_purge_dev+0x1b4>
cur = cur->avl.right;
}
else
{
while (*prev != NULL
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
de24: e1a04001 mov r4, r1
de28: eaffff9e b dca8 <rtems_bdbuf_purge_dev+0x74>
0000d7a0 <rtems_bdbuf_read>:
rtems_status_code
rtems_bdbuf_read (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
d7a0: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
d7a4: e1a04000 mov r4, r0
d7a8: e1a05001 mov r5, r1
d7ac: e1a06002 mov r6, r2
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block;
rtems_bdbuf_lock_cache ();
d7b0: ebfff87d bl b9ac <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)
d7b4: e5943028 ldr r3, [r4, #40] ; 0x28
d7b8: 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;
d7bc: 23a07000 movcs r7, #0
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
}
else
{
sc = RTEMS_INVALID_ID;
d7c0: 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)
d7c4: 2a00002e bcs d884 <rtems_bdbuf_read+0xe4>
}
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)
d7c8: e5941030 ldr r1, [r4, #48] ; 0x30
d7cc: e3510000 cmp r1, #0
return block << dd->block_to_media_block_shift;
d7d0: a1a01115 lslge r1, r5, r1
}
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)
d7d4: ba00002e blt d894 <rtems_bdbuf_read+0xf4>
/*
* 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;
d7d8: e5943018 ldr r3, [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);
d7dc: e1a00004 mov r0, r4
d7e0: e0811003 add r1, r1, r3
d7e4: ebfffb8a bl c614 <rtems_bdbuf_get_buffer_for_access>
d7e8: e1a07000 mov r7, r0
switch (bd->state)
d7ec: e5900020 ldr r0, [r0, #32]
d7f0: e3500002 cmp r0, #2
d7f4: 0a000005 beq d810 <rtems_bdbuf_read+0x70>
d7f8: e3500007 cmp r0, #7
d7fc: 0a000052 beq d94c <rtems_bdbuf_read+0x1ac>
d800: e3500001 cmp r0, #1
d804: 0a000033 beq d8d8 <rtems_bdbuf_read+0x138>
{
bd = NULL;
}
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_4);
d808: e3a01010 mov r1, #16 <== NOT EXECUTED
d80c: ebfff87c bl ba04 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
switch (bd->state)
{
case RTEMS_BDBUF_STATE_CACHED:
++dd->stats.read_hits;
d810: e5943044 ldr r3, [r4, #68] ; 0x44
d814: e2833001 add r3, r3, #1
d818: e5843044 str r3, [r4, #68] ; 0x44
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
d81c: e3a03003 mov r3, #3
d820: e5873020 str r3, [r7, #32]
d824: e3a08000 mov r8, #0
static void
rtems_bdbuf_check_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (bdbuf_cache.read_ahead_task != 0
d828: e59fa150 ldr sl, [pc, #336] ; d980 <rtems_bdbuf_read+0x1e0>
d82c: e59a0084 ldr r0, [sl, #132] ; 0x84
d830: e3500000 cmp r0, #0
d834: 0a000012 beq d884 <rtems_bdbuf_read+0xe4>
&& dd->read_ahead.trigger == block
d838: e594306c ldr r3, [r4, #108] ; 0x6c
d83c: e1550003 cmp r5, r3
d840: 1a00000f bne d884 <rtems_bdbuf_read+0xe4>
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
d844: e5943064 ldr r3, [r4, #100] ; 0x64
d848: e3530000 cmp r3, #0
d84c: 1a00000c bne d884 <rtems_bdbuf_read+0xe4>
d850: e5943068 ldr r3, [r4, #104] ; 0x68
d854: e3530000 cmp r3, #0
d858: 1a000009 bne d884 <rtems_bdbuf_read+0xe4>
&& !rtems_bdbuf_is_read_ahead_active (dd))
{
rtems_status_code sc;
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
if (rtems_chain_is_empty (chain))
d85c: e59a3088 ldr r3, [sl, #136] ; 0x88
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
d860: e28a508c add r5, sl, #140 ; 0x8c
d864: e1530005 cmp r3, r5
d868: 0a00003e beq d968 <rtems_bdbuf_read+0x1c8>
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
d86c: e59a3090 ldr r3, [sl, #144] ; 0x90
RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);
}
rtems_chain_append_unprotected (chain, &dd->read_ahead.node);
d870: e2842064 add r2, r4, #100 ; 0x64
the_node->next = tail;
d874: e5845064 str r5, [r4, #100] ; 0x64
tail->previous = the_node;
d878: e58a2090 str r2, [sl, #144] ; 0x90
old_last->next = the_node;
d87c: e5832000 str r2, [r3]
the_node->previous = old_last;
d880: e5843068 str r3, [r4, #104] ; 0x68
}
rtems_bdbuf_check_read_ahead_trigger (dd, block);
}
rtems_bdbuf_unlock_cache ();
d884: ebfff861 bl ba10 <rtems_bdbuf_unlock_cache>
*bd_ptr = bd;
d888: e5867000 str r7, [r6]
return sc;
}
d88c: e1a00008 mov r0, r8
d890: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
/*
* 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);
d894: e5940024 ldr r0, [r4, #36] ; 0x24 <== NOT EXECUTED
d898: e0887095 umull r7, r8, r5, r0 <== NOT EXECUTED
d89c: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
d8a0: e1a00007 mov r0, r7 <== NOT EXECUTED
d8a4: e3a03000 mov r3, #0 <== NOT EXECUTED
d8a8: e1a01008 mov r1, r8 <== NOT EXECUTED
d8ac: eb003a10 bl 1c0f4 <__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;
d8b0: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED
/*
* 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);
d8b4: e1a01000 mov r1, r0 <== NOT EXECUTED
{
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);
d8b8: e0811003 add r1, r1, r3 <== NOT EXECUTED
d8bc: e1a00004 mov r0, r4 <== NOT EXECUTED
d8c0: ebfffb53 bl c614 <rtems_bdbuf_get_buffer_for_access> <== NOT EXECUTED
d8c4: e1a07000 mov r7, r0 <== NOT EXECUTED
switch (bd->state)
d8c8: e5900020 ldr r0, [r0, #32] <== NOT EXECUTED
d8cc: e3500002 cmp r0, #2 <== NOT EXECUTED
d8d0: 1affffc8 bne d7f8 <rtems_bdbuf_read+0x58> <== NOT EXECUTED
d8d4: eaffffcd b d810 <rtems_bdbuf_read+0x70> <== NOT EXECUTED
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;
d8d8: e5943048 ldr 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)
d8dc: e594206c ldr r2, [r4, #108] ; 0x6c
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;
d8e0: e2833001 add r3, r3, #1
static void
rtems_bdbuf_set_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (dd->read_ahead.trigger != block)
d8e4: e1550002 cmp r5, r2
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;
d8e8: 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)
d8ec: 0a000005 beq d908 <rtems_bdbuf_read+0x168>
{
rtems_bdbuf_read_ahead_cancel (dd);
d8f0: e1a00004 mov r0, r4
d8f4: ebfff8e4 bl bc8c <rtems_bdbuf_read_ahead_cancel>
dd->read_ahead.trigger = block + 1;
d8f8: e2852001 add r2, r5, #1
dd->read_ahead.next = block + 2;
d8fc: e2853002 add r3, r5, #2
rtems_blkdev_bnum block)
{
if (dd->read_ahead.trigger != block)
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = block + 1;
d900: e584206c str r2, [r4, #108] ; 0x6c
dd->read_ahead.next = block + 2;
d904: 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);
d908: e1a01007 mov r1, r7
d90c: e1a00004 mov r0, r4
d910: e3a02001 mov r2, #1
d914: ebfffdc7 bl d038 <rtems_bdbuf_execute_read_request>
if (sc == RTEMS_SUCCESSFUL)
d918: e2508000 subs r8, r0, #0
rtems_chain_extract_unprotected (&bd->link);
rtems_bdbuf_group_obtain (bd);
}
else
{
bd = NULL;
d91c: 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)
d920: 1affffc0 bne d828 <rtems_bdbuf_read+0x88>
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
d924: e5973028 ldr r3, [r7, #40] ; 0x28
d928: e593000c ldr r0, [r3, #12]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
d92c: e8970006 ldm r7, {r1, r2}
d930: e2800001 add r0, r0, #1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
d934: e3a0c003 mov ip, #3
d938: e587c020 str ip, [r7, #32]
next->previous = previous;
d93c: e5812004 str r2, [r1, #4]
previous->next = next;
d940: e5821000 str r1, [r2]
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
d944: e583000c str r0, [r3, #12]
d948: eaffffb6 b d828 <rtems_bdbuf_read+0x88>
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;
d94c: e5943044 ldr r3, [r4, #68] ; 0x44
d950: e2833001 add r3, r3, #1
d954: e5843044 str r3, [r4, #68] ; 0x44
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
d958: e3a03004 mov r3, #4
d95c: e3a08000 mov r8, #0
d960: e5873020 str r3, [r7, #32]
d964: eaffffaf b d828 <rtems_bdbuf_read+0x88>
rtems_status_code sc;
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
if (rtems_chain_is_empty (chain))
{
sc = rtems_event_send (bdbuf_cache.read_ahead_task,
d968: e3a01002 mov r1, #2
d96c: ebffe741 bl 7678 <rtems_event_send>
RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
if (sc != RTEMS_SUCCESSFUL)
d970: e3500000 cmp r0, #0
d974: 0affffbc beq d86c <rtems_bdbuf_read+0xcc>
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);
d978: e3a00007 mov r0, #7 <== NOT EXECUTED
d97c: ebfff806 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
0000bc8c <rtems_bdbuf_read_ahead_cancel>:
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
bc8c: e5903064 ldr r3, [r0, #100] ; 0x64
bc90: e3530000 cmp r3, #0
bc94: e5902068 ldr r2, [r0, #104] ; 0x68
bc98: 0a000005 beq bcb4 <rtems_bdbuf_read_ahead_cancel+0x28>
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
bc9c: e3a01000 mov r1, #0 <== NOT EXECUTED
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
bca0: e5832004 str r2, [r3, #4] <== NOT EXECUTED
previous->next = next;
bca4: e5823000 str r3, [r2] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
bca8: e5801068 str r1, [r0, #104] ; 0x68 <== NOT EXECUTED
bcac: e5801064 str r1, [r0, #100] ; 0x64 <== NOT EXECUTED
bcb0: e12fff1e bx lr <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
bcb4: e3520000 cmp r2, #0
bcb8: 012fff1e bxeq lr
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
bcbc: e3a01000 mov r1, #0 <== NOT EXECUTED
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
bcc0: e5832004 str r2, [r3, #4] <== NOT EXECUTED
previous->next = next;
bcc4: e5823000 str r3, [r2] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
bcc8: e5801068 str r1, [r0, #104] ; 0x68 <== NOT EXECUTED
bccc: e5801064 str r1, [r0, #100] ; 0x64 <== NOT EXECUTED
bcd0: e12fff1e bx lr <== NOT EXECUTED
0000d124 <rtems_bdbuf_read_ahead_task>:
return sc;
}
static rtems_task
rtems_bdbuf_read_ahead_task (rtems_task_argument arg)
{
d124: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
while (bdbuf_cache.read_ahead_enabled)
d128: e59f7128 ldr r7, [pc, #296] ; d258 <rtems_bdbuf_read_ahead_task+0x134>
d12c: e5d73094 ldrb r3, [r7, #148] ; 0x94
d130: e3530000 cmp r3, #0
d134: 0a000036 beq d214 <rtems_bdbuf_read_ahead_task+0xf0>
d138: e287808c add r8, r7, #140 ; 0x8c
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
d13c: e1a0a007 mov sl, r7
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;
d140: e2879088 add r9, r7, #136 ; 0x88
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
d144: e3a06000 mov r6, #0
{
rtems_chain_node *node;
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
d148: e3a00002 mov r0, #2
d14c: ebfffaa8 bl bbf4 <rtems_bdbuf_wait_for_event>
rtems_bdbuf_lock_cache ();
d150: ebfffa15 bl b9ac <rtems_bdbuf_lock_cache>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
d154: e5974088 ldr r4, [r7, #136] ; 0x88
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
d158: e1540008 cmp r4, r8
d15c: 0a000027 beq d200 <rtems_bdbuf_read_ahead_task+0xdc>
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;
d160: e594500c ldr r5, [r4, #12]
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
d164: e514203c ldr r2, [r4, #-60] ; 0x3c
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
d168: e5943000 ldr r3, [r4]
d16c: e1550002 cmp r5, r2
head->next = new_first;
d170: e58a3088 str r3, [sl, #136] ; 0x88
new_first->previous = head;
d174: e5839004 str r9, [r3, #4]
d178: 2a000028 bcs d220 <rtems_bdbuf_read_ahead_task+0xfc>
}
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)
d17c: e5141034 ldr r1, [r4, #-52] ; 0x34
d180: e3510000 cmp r1, #0
return block << dd->block_to_media_block_shift;
d184: a1a01115 lslge r1, r5, r1
}
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)
d188: ba000029 blt d234 <rtems_bdbuf_read_ahead_task+0x110>
/*
* 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;
d18c: e514304c ldr r3, [r4, #-76] ; 0x4c
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 *)
d190: e244b064 sub fp, r4, #100 ; 0x64
rtems_chain_set_off_chain (&dd->read_ahead.node);
if (sc == RTEMS_SUCCESSFUL)
{
rtems_bdbuf_buffer *bd =
d194: e0811003 add r1, r1, r3
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
d198: e5846004 str r6, [r4, #4]
d19c: e5846000 str r6, [r4]
d1a0: e1a0000b mov r0, fp
d1a4: ebfffcf9 bl c590 <rtems_bdbuf_get_buffer_for_read_ahead>
rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
if (bd != NULL)
d1a8: e2501000 subs r1, r0, #0
d1ac: 0affffe8 beq d154 <rtems_bdbuf_read_ahead_task+0x30>
{
uint32_t transfer_count = dd->block_count - block;
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
d1b0: e59fc0a4 ldr ip, [pc, #164] ; d25c <rtems_bdbuf_read_ahead_task+0x138>
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;
d1b4: e514203c ldr r2, [r4, #-60] ; 0x3c
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
d1b8: e59c3000 ldr r3, [ip]
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;
d1bc: e0652002 rsb r2, r5, r2
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
if (transfer_count >= max_transfer_count)
d1c0: e1520003 cmp r2, r3
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
d1c4: 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;
d1c8: 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;
d1cc: 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;
d1d0: 25842008 strcs r2, [r4, #8]
dd->read_ahead.next = block + transfer_count;
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
d1d4: 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;
d1d8: 21a02003 movcs r2, r3
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
++dd->stats.read_ahead_transfers;
d1dc: e5143018 ldr r3, [r4, #-24]
d1e0: 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;
d1e4: 2584500c strcs r5, [r4, #12]
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
++dd->stats.read_ahead_transfers;
d1e8: e5043018 str r3, [r4, #-24]
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
d1ec: e1a0000b mov r0, fp
d1f0: ebffff90 bl d038 <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;
d1f4: e5974088 ldr r4, [r7, #136] ; 0x88
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
d1f8: e1540008 cmp r4, r8
d1fc: 1affffd7 bne d160 <rtems_bdbuf_read_ahead_task+0x3c>
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
}
rtems_bdbuf_unlock_cache ();
d200: ebfffa02 bl ba10 <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)
d204: e59f004c ldr r0, [pc, #76] ; d258 <rtems_bdbuf_read_ahead_task+0x134>
d208: e5d03094 ldrb r3, [r0, #148] ; 0x94
d20c: e3530000 cmp r3, #0
d210: 1affffcc bne d148 <rtems_bdbuf_read_ahead_task+0x24>
}
rtems_bdbuf_unlock_cache ();
}
rtems_task_delete (RTEMS_SELF);
d214: e3a00000 mov r0, #0 <== NOT EXECUTED
}
d218: e8bd4ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
}
rtems_bdbuf_unlock_cache ();
}
rtems_task_delete (RTEMS_SELF);
d21c: eaffeb09 b 7e48 <rtems_task_delete> <== NOT EXECUTED
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
}
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
d220: e3e03000 mvn r3, #0
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
d224: e5846004 str r6, [r4, #4]
d228: e5846000 str r6, [r4]
d22c: e5843008 str r3, [r4, #8]
d230: eaffffc7 b d154 <rtems_bdbuf_read_ahead_task+0x30>
/*
* 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);
d234: e5140040 ldr r0, [r4, #-64] ; 0x40 <== NOT EXECUTED
d238: e08cb590 umull fp, ip, r0, r5 <== NOT EXECUTED
d23c: e5142044 ldr r2, [r4, #-68] ; 0x44 <== NOT EXECUTED
d240: e1a0000b mov r0, fp <== NOT EXECUTED
d244: e1a0100c mov r1, ip <== NOT EXECUTED
d248: e3a03000 mov r3, #0 <== NOT EXECUTED
d24c: eb003ba8 bl 1c0f4 <__udivdi3> <== NOT EXECUTED
d250: e1a01000 mov r1, r0 <== NOT EXECUTED
d254: eaffffcc b d18c <rtems_bdbuf_read_ahead_task+0x68> <== NOT EXECUTED
0000d984 <rtems_bdbuf_release>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
d984: 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)
d988: e2504000 subs r4, r0, #0
d98c: 0a000009 beq d9b8 <rtems_bdbuf_release+0x34>
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
d990: ebfff805 bl b9ac <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
d994: e5940020 ldr r0, [r4, #32]
d998: e2403003 sub r3, r0, #3
d99c: e3530003 cmp r3, #3
d9a0: 979ff103 ldrls pc, [pc, r3, lsl #2]
d9a4: ea00000a b d9d4 <rtems_bdbuf_release+0x50> <== NOT EXECUTED
d9a8: 0000d9dc .word 0x0000d9dc <== NOT EXECUTED
d9ac: 0000da30 .word 0x0000da30 <== NOT EXECUTED
d9b0: 0000d9c0 .word 0x0000d9c0 <== NOT EXECUTED
d9b4: 0000d9c0 .word 0x0000d9c0 <== NOT EXECUTED
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;
d9b8: e3a00009 mov r0, #9 <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
d9bc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
rtems_bdbuf_add_to_lru_list_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
d9c0: e1a00004 mov r0, r4
d9c4: ebfffba5 bl c860 <rtems_bdbuf_discard_buffer_after_access>
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
d9c8: ebfff810 bl ba10 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
d9cc: e3a00000 mov r0, #0
d9d0: e8bd8010 pop {r4, pc}
break;
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_0);
d9d4: e3a0100e mov r1, #14 <== NOT EXECUTED
d9d8: ebfff809 bl ba04 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
d9dc: e5942028 ldr r2, [r4, #40] ; 0x28
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
d9e0: e59f005c ldr r0, [pc, #92] ; da44 <rtems_bdbuf_release+0xc0>
d9e4: e592c00c ldr ip, [r2, #12]
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)
d9e8: e594e024 ldr lr, [r4, #36] ; 0x24
d9ec: e5903048 ldr r3, [r0, #72] ; 0x48
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
d9f0: e24cc001 sub ip, ip, #1
d9f4: e582c00c str ip, [r2, #12]
the_node->next = tail;
d9f8: e2801044 add r1, r0, #68 ; 0x44
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)
d9fc: e35e0000 cmp lr, #0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
da00: e3a02002 mov r2, #2
da04: e5842020 str r2, [r4, #32]
da08: e5841000 str r1, [r4]
tail->previous = the_node;
da0c: e5804048 str r4, [r0, #72] ; 0x48
old_last->next = the_node;
da10: e5834000 str r4, [r3]
{
rtems_bdbuf_group_release (bd);
rtems_bdbuf_make_cached_and_add_to_lru_list (bd);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
da14: 12800064 addne r0, r0, #100 ; 0x64
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
da18: 02800074 addeq r0, r0, #116 ; 0x74
the_node->previous = old_last;
da1c: e5843004 str r3, [r4, #4]
da20: ebfff8ab bl bcd4 <rtems_bdbuf_wake>
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
da24: ebfff7f9 bl ba10 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
da28: e3a00000 mov r0, #0
da2c: e8bd8010 pop {r4, pc}
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
da30: e1a00004 mov r0, r4
da34: ebfff8b0 bl bcfc <rtems_bdbuf_add_to_modified_list_after_access>
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
da38: ebfff7f4 bl ba10 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
da3c: e3a00000 mov r0, #0
da40: e8bd8010 pop {r4, pc}
0000da48 <rtems_bdbuf_release_modified>:
}
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
da48: 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)
da4c: e2504000 subs r4, r0, #0
da50: 0a00000c beq da88 <rtems_bdbuf_release_modified+0x40>
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
da54: ebfff7d4 bl b9ac <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
da58: e5940020 ldr r0, [r4, #32]
da5c: e3500003 cmp r0, #3
da60: 2a000001 bcs da6c <rtems_bdbuf_release_modified+0x24>
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_6);
da64: e3a01012 mov r1, #18 <== NOT EXECUTED
da68: ebfff7e5 bl ba04 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
da6c: e3500005 cmp r0, #5
da70: 8a000006 bhi da90 <rtems_bdbuf_release_modified+0x48>
{
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);
da74: e1a00004 mov r0, r4
da78: ebfff89f bl bcfc <rtems_bdbuf_add_to_modified_list_after_access>
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
da7c: ebfff7e3 bl ba10 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
da80: e3a00000 mov r0, #0
da84: 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;
da88: e3a00009 mov r0, #9 <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
da8c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
da90: e3500006 cmp r0, #6
da94: 1afffff2 bne da64 <rtems_bdbuf_release_modified+0x1c>
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
da98: e1a00004 mov r0, r4
da9c: ebfffb6f bl c860 <rtems_bdbuf_discard_buffer_after_access>
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
daa0: ebfff7da bl ba10 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
daa4: e3a00000 mov r0, #0
daa8: e8bd8010 pop {r4, pc}
0000be30 <rtems_bdbuf_remove_from_tree>:
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
be30: e92d47f0 push {r4, r5, r6, r7, r8, r9, 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;
be34: e59fa354 ldr sl, [pc, #852] ; c190 <rtems_bdbuf_remove_from_tree+0x360>
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
be38: e24dd080 sub sp, sp, #128 ; 0x80
const rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
be3c: e59a403c ldr r4, [sl, #60] ; 0x3c
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
be40: e1a07000 mov r7, 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));
be44: e3a01000 mov r1, #0
be48: e1a0000d mov r0, sp
be4c: e3a02080 mov r2, #128 ; 0x80
static int
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer** root,
const rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
rtems_blkdev_bnum block = node->block;
be50: e2875014 add r5, r7, #20
be54: e8950120 ldm r5, {r5, r8}
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));
be58: eb001a23 bl 126ec <memset>
while (p != NULL)
be5c: e3540000 cmp r4, #0
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
be60: e1a0600d mov r6, sp
while (p != NULL)
be64: 0a000012 beq beb4 <rtems_bdbuf_remove_from_tree+0x84>
be68: e1a0300d mov r3, sp
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
be6c: e3a00001 mov r0, #1
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
be70: e3e0c000 mvn ip, #0
be74: ea000005 b be90 <rtems_bdbuf_remove_from_tree+0x60>
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
be78: e1550001 cmp r5, r1
be7c: 0a00000f beq bec0 <rtems_bdbuf_remove_from_tree+0x90>
p->avl.cache = 1;
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
be80: e5c4c010 strb ip, [r4, #16]
p = p->avl.left;
be84: e5944008 ldr r4, [r4, #8]
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
be88: e3540000 cmp r4, #0
be8c: 0a000008 beq beb4 <rtems_bdbuf_remove_from_tree+0x84>
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
be90: e5941014 ldr r1, [r4, #20]
be94: e1510005 cmp r1, r5
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
be98: e1a02003 mov r2, r3
{
*buf_prev++ = p;
be9c: e4834004 str r4, [r3], #4
if (((uintptr_t) p->dd < (uintptr_t) dd)
bea0: 2afffff4 bcs be78 <rtems_bdbuf_remove_from_tree+0x48>
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
bea4: e5c40010 strb r0, [r4, #16]
p = p->avl.right;
bea8: e594400c ldr r4, [r4, #12]
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
beac: e3540000 cmp r4, #0
beb0: 1afffff6 bne be90 <rtems_bdbuf_remove_from_tree+0x60>
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);
beb4: e5970020 ldr r0, [r7, #32] <== NOT EXECUTED
beb8: e3a0101b mov r1, #27 <== NOT EXECUTED
bebc: ebfffed0 bl ba04 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
bec0: e5941018 ldr r1, [r4, #24]
bec4: e1580001 cmp r8, r1
bec8: 8afffff5 bhi bea4 <rtems_bdbuf_remove_from_tree+0x74>
{
p->avl.cache = 1;
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
becc: 1affffeb bne be80 <rtems_bdbuf_remove_from_tree+0x50>
{
p = NULL;
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
bed0: e594800c ldr r8, [r4, #12]
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
bed4: e1520006 cmp r2, r6
{
p = *(buf_prev - 1);
bed8: 85139008 ldrhi r9, [r3, #-8]
}
else
{
p = NULL;
bedc: 93a09000 movls r9, #0
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
bee0: e3580000 cmp r8, #0
bee4: 0a00009b beq c158 <rtems_bdbuf_remove_from_tree+0x328>
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
bee8: e5981008 ldr r1, [r8, #8]
beec: e3510000 cmp r1, #0
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
*buf_prev++ = q = r;
bef0: 11a05003 movne r5, r3
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
bef4: 11a00008 movne r0, r8
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
bef8: 13e07000 mvnne r7, #0
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
befc: 1a000002 bne bf0c <rtems_bdbuf_remove_from_tree+0xdc>
bf00: ea000098 b c168 <rtems_bdbuf_remove_from_tree+0x338>
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
bf04: e1a00001 mov r0, r1
bf08: e1a0100c mov r1, ip
{
*buf_prev++ = r = s;
bf0c: e1a02005 mov r2, r5
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
bf10: e591c008 ldr ip, [r1, #8]
{
*buf_prev++ = r = s;
bf14: e4820004 str r0, [r2], #4
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
bf18: e35c0000 cmp ip, #0
{
*buf_prev++ = r = s;
bf1c: e1a05002 mov r5, r2
s = r->avl.left;
r->avl.cache = -1;
bf20: e5c07010 strb r7, [r0, #16]
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
bf24: 1afffff6 bne bf04 <rtems_bdbuf_remove_from_tree+0xd4>
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
bf28: e5947008 ldr r7, [r4, #8]
r->avl.left = s->avl.right;
bf2c: e591500c ldr r5, [r1, #12]
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
bf30: e5d4c011 ldrb ip, [r4, #17]
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
bf34: e5817008 str r7, [r1, #8]
r->avl.left = s->avl.right;
bf38: e5805008 str r5, [r0, #8]
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
s->avl.cache = 1;
bf3c: e3a00001 mov r0, #1
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
bf40: e581800c str r8, [r1, #12]
s->avl.bal = q->avl.bal;
bf44: e5c1c011 strb ip, [r1, #17]
s->avl.cache = 1;
bf48: e5c10010 strb r0, [r1, #16]
*t = q = s;
bf4c: e5031004 str r1, [r3, #-4]
}
}
if (p != NULL)
bf50: e3590000 cmp r9, #0
p->avl.right = q;
}
}
else
{
*root = q;
bf54: 058a103c streq r1, [sl, #60] ; 0x3c
*t = q = s;
}
}
if (p != NULL)
bf58: 0a000003 beq bf6c <rtems_bdbuf_remove_from_tree+0x13c>
{
if (p->avl.cache == -1)
bf5c: e1d931d0 ldrsb r3, [r9, #16]
bf60: e3730001 cmn r3, #1
{
p->avl.left = q;
}
else
{
p->avl.right = q;
bf64: 1589100c strne r1, [r9, #12]
if (p != NULL)
{
if (p->avl.cache == -1)
{
p->avl.left = q;
bf68: 05891008 streq r1, [r9, #8]
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
bf6c: e1520006 cmp r2, r6
bf70: 9a000032 bls c040 <rtems_bdbuf_remove_from_tree+0x210>
p->avl.right = q;
}
}
else
{
*root = q;
bf74: e5323004 ldr r3, [r2, #-4]!
{
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
bf78: e2664003 rsb r4, r6, #3
bf7c: e0844002 add r4, r4, r2
bf80: e3c44003 bic r4, r4, #3
bf84: e1d301d0 ldrsb r0, [r3, #16]
bf88: e0644002 rsb r4, r4, r2
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
bf8c: e3e07000 mvn r7, #0
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
bf90: e3a06000 mov r6, #0
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
bf94: e3a08001 mov r8, #1
bf98: ea000017 b bffc <rtems_bdbuf_remove_from_tree+0x1cc>
bf9c: e1d301d1 ldrsb r0, [r3, #17]
bfa0: e3500000 cmp r0, #0
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
bfa4: 05c37011 strbeq r7, [r3, #17]
bfa8: 01a01003 moveq r1, r3
modified = false;
bfac: 01a0c000 moveq ip, r0
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
bfb0: 0a000008 beq bfd8 <rtems_bdbuf_remove_from_tree+0x1a8>
bfb4: e3500001 cmp r0, #1
{
case +1:
p->avl.bal = 0;
bfb8: 05c36011 strbeq r6, [r3, #17]
bfbc: 01a01003 moveq r1, r3
bfc0: 01a0c000 moveq ip, r0
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
bfc4: 0a000003 beq bfd8 <rtems_bdbuf_remove_from_tree+0x1a8>
bfc8: e3700001 cmn r0, #1
bfcc: 0a00001d beq c048 <rtems_bdbuf_remove_from_tree+0x218>
bfd0: e1a01003 mov r1, r3 <== NOT EXECUTED
bfd4: e3a0c001 mov ip, #1 <== NOT EXECUTED
default:
break;
}
}
if (buf_prev > buf_stack)
bfd8: e1520004 cmp r2, r4
bfdc: 0a000016 beq c03c <rtems_bdbuf_remove_from_tree+0x20c>
{
q = *(buf_prev - 1);
bfe0: e5323004 ldr r3, [r2, #-4]!
if (q->avl.cache == -1)
bfe4: e1d301d0 ldrsb r0, [r3, #16]
bfe8: e3700001 cmn r0, #1
{
q->avl.left = p;
bfec: 05831008 streq r1, [r3, #8]
}
else
{
q->avl.right = p;
bff0: 1583100c strne r1, [r3, #12]
*root = q;
}
modified = true;
while (modified)
bff4: e35c0000 cmp ip, #0
bff8: 0a000010 beq c040 <rtems_bdbuf_remove_from_tree+0x210>
else
{
break;
}
if (p->avl.cache == -1)
bffc: e3700001 cmn r0, #1
c000: 1affffe5 bne bf9c <rtems_bdbuf_remove_from_tree+0x16c>
{
/* rebalance left branch */
switch (p->avl.bal)
c004: e1d3c1d1 ldrsb ip, [r3, #17]
c008: e35c0000 cmp ip, #0
{
case -1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = 1;
c00c: 05c38011 strbeq r8, [r3, #17]
c010: 01a01003 moveq r1, r3
}
if (p->avl.cache == -1)
{
/* rebalance left branch */
switch (p->avl.bal)
c014: 0affffef beq bfd8 <rtems_bdbuf_remove_from_tree+0x1a8>
c018: e35c0001 cmp ip, #1
c01c: 0a000022 beq c0ac <rtems_bdbuf_remove_from_tree+0x27c>
c020: e37c0001 cmn ip, #1
{
case -1:
p->avl.bal = 0;
c024: 05c36011 strbeq r6, [r3, #17]
c028: 01a01003 moveq r1, r3
c02c: 03a0c001 moveq ip, #1
}
if (p->avl.cache == -1)
{
/* rebalance left branch */
switch (p->avl.bal)
c030: 1affffe6 bne bfd0 <rtems_bdbuf_remove_from_tree+0x1a0>
default:
break;
}
}
if (buf_prev > buf_stack)
c034: e1520004 cmp r2, r4
c038: 1affffe8 bne bfe0 <rtems_bdbuf_remove_from_tree+0x1b0>
q->avl.right = p;
}
}
else
{
*root = p;
c03c: e58a103c str r1, [sl, #60] ; 0x3c
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);
}
c040: e28dd080 add sp, sp, #128 ; 0x80
c044: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
p->avl.bal = -1;
modified = false;
break;
case -1:
p1 = p->avl.left;
c048: e5935008 ldr r5, [r3, #8]
if (p1->avl.bal <= 0) /* simple LL-turn */
c04c: e5d5c011 ldrb ip, [r5, #17]
c050: e1a01c0c lsl r1, ip, #24
c054: e3510000 cmp r1, #0
{
p->avl.left = p1->avl.right;
c058: e595100c ldr r1, [r5, #12]
break;
case -1:
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
c05c: da00001f ble c0e0 <rtems_bdbuf_remove_from_tree+0x2b0>
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
c060: e1d1c1d1 ldrsb ip, [r1, #17]
c064: e37c0001 cmn ip, #1
c068: 13a0c000 movne ip, #0
c06c: 03a0c001 moveq ip, #1
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
c070: e5910008 ldr r0, [r1, #8]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
c074: e5c3c011 strb ip, [r3, #17]
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
c078: e585000c str r0, [r5, #12]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
c07c: e1d1c1d1 ldrsb ip, [r1, #17]
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
c080: e591000c ldr r0, [r1, #12]
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
c084: e35c0001 cmp ip, #1
c088: 03a0c0ff moveq ip, #255 ; 0xff
c08c: 13a0c000 movne ip, #0
c090: e5c5c011 strb ip, [r5, #17]
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
c094: e5815008 str r5, [r1, #8]
p->avl.left = p2->avl.right;
p2->avl.right = p;
c098: e581300c str r3, [r1, #12]
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
c09c: e5830008 str r0, [r3, #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;
p = p2;
p2->avl.bal = 0;
c0a0: e5c16011 strb r6, [r1, #17]
c0a4: e3a0c001 mov ip, #1
c0a8: eaffffca b bfd8 <rtems_bdbuf_remove_from_tree+0x1a8>
p->avl.bal = 1;
modified = false;
break;
case +1:
p1 = p->avl.right;
c0ac: e593100c ldr r1, [r3, #12]
if (p1->avl.bal >= 0) /* simple RR-turn */
c0b0: e5d15011 ldrb r5, [r1, #17]
c0b4: e3150080 tst r5, #128 ; 0x80
c0b8: 1a000012 bne c108 <rtems_bdbuf_remove_from_tree+0x2d8>
{
p->avl.right = p1->avl.left;
c0bc: e5919008 ldr r9, [r1, #8]
p1->avl.left = p;
if (p1->avl.bal == 0)
c0c0: e3550000 cmp r5, #0
p1->avl.bal = -1;
modified = false;
}
else
{
p->avl.bal = 0;
c0c4: 15c36011 strbne r6, [r3, #17]
case +1:
p1 = p->avl.right;
if (p1->avl.bal >= 0) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
c0c8: e583900c str r9, [r3, #12]
p1->avl.left = p;
c0cc: e5813008 str r3, [r1, #8]
if (p1->avl.bal == 0)
{
p1->avl.bal = -1;
c0d0: 05c10011 strbeq r0, [r1, #17]
modified = false;
c0d4: 01a0c005 moveq ip, r5
}
else
{
p->avl.bal = 0;
p1->avl.bal = 0;
c0d8: 15c16011 strbne r6, [r1, #17]
c0dc: eaffffbd b bfd8 <rtems_bdbuf_remove_from_tree+0x1a8>
if (p1->avl.bal <= 0) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
p1->avl.right = p;
if (p1->avl.bal == 0)
c0e0: e35c0000 cmp ip, #0
case -1:
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
c0e4: e5831008 str r1, [r3, #8]
p1->avl.bal = 1;
modified = false;
}
else
{
p->avl.bal = 0;
c0e8: 15c36011 strbne r6, [r3, #17]
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
p1->avl.right = p;
c0ec: e585300c str r3, [r5, #12]
if (p1->avl.bal == 0)
{
p1->avl.bal = 1;
c0f0: 05c58011 strbeq r8, [r5, #17]
c0f4: 01a01005 moveq r1, r5
modified = false;
}
else
{
p->avl.bal = 0;
p1->avl.bal = 0;
c0f8: 11a01005 movne r1, r5
c0fc: 15c56011 strbne r6, [r5, #17]
c100: 13a0c001 movne ip, #1
c104: eaffffb3 b bfd8 <rtems_bdbuf_remove_from_tree+0x1a8>
}
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
c108: e5910008 ldr r0, [r1, #8]
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
c10c: e1d091d1 ldrsb r9, [r0, #17]
c110: e3590001 cmp r9, #1
c114: 03a090ff moveq r9, #255 ; 0xff
c118: 13a09000 movne r9, #0
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
c11c: e590500c ldr r5, [r0, #12]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
c120: e5c39011 strb r9, [r3, #17]
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
c124: e5815008 str r5, [r1, #8]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
c128: e1d091d1 ldrsb r9, [r0, #17]
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
c12c: e5905008 ldr r5, [r0, #8]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
c130: e3790001 cmn r9, #1
c134: 13a09000 movne r9, #0
c138: 03a09001 moveq r9, #1
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
c13c: e580100c str r1, [r0, #12]
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
c140: e5c19011 strb r9, [r1, #17]
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
c144: e583500c str r5, [r3, #12]
p2->avl.left = p;
c148: 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;
p = p2;
p2->avl.bal = 0;
c14c: e5c06011 strb r6, [r0, #17]
c150: e1a01000 mov r1, r0
c154: eaffff9f b bfd8 <rtems_bdbuf_remove_from_tree+0x1a8>
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
{
r = q->avl.left;
c158: e5941008 ldr r1, [r4, #8]
if (r != NULL)
c15c: e3510000 cmp r1, #0
{
r->avl.bal = 0;
c160: 15c18011 strbne r8, [r1, #17]
c164: eaffff79 b bf50 <rtems_bdbuf_remove_from_tree+0x120>
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
c168: e5d42011 ldrb r2, [r4, #17]
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
c16c: e5941008 ldr r1, [r4, #8]
r->avl.bal = q->avl.bal;
c170: e5c82011 strb r2, [r8, #17]
r->avl.cache = 1;
c174: e3a02001 mov r2, #1
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
c178: e5881008 str r1, [r8, #8]
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
c17c: e5c82010 strb r2, [r8, #16]
*buf_prev++ = q = r;
c180: e5038004 str r8, [r3, #-4]
c184: e1a02003 mov r2, r3
c188: e1a01008 mov r1, r8
c18c: eaffff6f b bf50 <rtems_bdbuf_remove_from_tree+0x120>
0000baf4 <rtems_bdbuf_restore_preemption>:
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
baf4: e52de004 push {lr} ; (str lr, [sp, #-4]!)
baf8: e24dd004 sub sp, sp, #4
bafc: e28d2004 add r2, sp, #4
bb00: e5220004 str r0, [r2, #-4]!
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode);
bb04: e59f101c ldr r1, [pc, #28] ; bb28 <rtems_bdbuf_restore_preemption+0x34>
bb08: e1a0200d mov r2, sp
bb0c: eb000fac bl f9c4 <rtems_task_mode>
if (sc != RTEMS_SUCCESSFUL)
bb10: e3500000 cmp r0, #0
bb14: 1a000001 bne bb20 <rtems_bdbuf_restore_preemption+0x2c>
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_RST);
}
bb18: e28dd004 add sp, sp, #4
bb1c: e8bd8000 pop {pc}
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_RST);
bb20: e3a00006 mov r0, #6 <== NOT EXECUTED
bb24: ebffff9c bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
0000b82c <rtems_bdbuf_swapout_modified_processing>:
rtems_chain_control* chain,
rtems_chain_control* transfer,
bool sync_active,
bool update_timers,
uint32_t timer_delta)
{
b82c: e92d0ff0 push {r4, r5, r6, r7, r8, r9, sl, fp}
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
b830: e491c004 ldr ip, [r1], #4
if (!rtems_chain_is_empty (chain))
b834: e15c0001 cmp ip, r1
rtems_chain_control* chain,
rtems_chain_control* transfer,
bool sync_active,
bool update_timers,
uint32_t timer_delta)
{
b838: e5dd9020 ldrb r9, [sp, #32]
if (!rtems_chain_is_empty (chain))
b83c: 0a00002a beq b8ec <rtems_bdbuf_swapout_modified_processing+0xc0>
node = node->next;
/*
* A sync active with no valid dev means sync all.
*/
if (sync_active && (*dd_ptr == BDBUF_INVALID_DEV))
b840: e3530000 cmp r3, #0
sync_all = true;
else
sync_all = false;
b844: 01a07003 moveq r7, r3
node = node->next;
/*
* A sync active with no valid dev means sync all.
*/
if (sync_active && (*dd_ptr == BDBUF_INVALID_DEV))
b848: 0a000002 beq b858 <rtems_bdbuf_swapout_modified_processing+0x2c>
* @param update_timers If true update the timers.
* @param timer_delta It update_timers is true update the timers by this
* amount.
*/
static void
rtems_bdbuf_swapout_modified_processing (rtems_disk_device **dd_ptr,
b84c: e5907000 ldr r7, [r0]
b850: e2777001 rsbs r7, r7, #1
b854: 33a07000 movcc r7, #0
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
b858: e59f4138 ldr r4, [pc, #312] ; b998 <rtems_bdbuf_swapout_modified_processing+0x16c>
b85c: e594b074 ldr fp, [r4, #116] ; 0x74
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dd_ptr == bd->dd))
|| rtems_bdbuf_has_buffer_waiters ())
bd->hold_timer = 0;
b860: e3a0a000 mov sl, #0
b864: e1a08003 mov r8, r3
* or someone waits for a buffer written force all the timers to 0.
*
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dd_ptr == bd->dd))
b868: e3570000 cmp r7, #0
b86c: 1a000034 bne b944 <rtems_bdbuf_swapout_modified_processing+0x118>
b870: e3580000 cmp r8, #0
b874: 0a000003 beq b888 <rtems_bdbuf_swapout_modified_processing+0x5c>
b878: e5903000 ldr r3, [r0]
b87c: e59c4014 ldr r4, [ip, #20]
b880: e1530004 cmp r3, r4
b884: 0a000040 beq b98c <rtems_bdbuf_swapout_modified_processing+0x160>
|| rtems_bdbuf_has_buffer_waiters ())
b888: e35b0000 cmp fp, #0
b88c: 1a00002c bne b944 <rtems_bdbuf_swapout_modified_processing+0x118>
bd->hold_timer = 0;
if (bd->hold_timer)
b890: e59c302c ldr r3, [ip, #44] ; 0x2c
b894: e3530000 cmp r3, #0
b898: 0a000008 beq b8c0 <rtems_bdbuf_swapout_modified_processing+0x94>
{
if (update_timers)
b89c: e3590000 cmp r9, #0
b8a0: 0a00000e beq b8e0 <rtems_bdbuf_swapout_modified_processing+0xb4>
{
if (bd->hold_timer > timer_delta)
b8a4: e59d4024 ldr r4, [sp, #36] ; 0x24
b8a8: e1530004 cmp r3, r4
b8ac: 9a000032 bls b97c <rtems_bdbuf_swapout_modified_processing+0x150>
bd->hold_timer -= timer_delta;
b8b0: e0643003 rsb r3, r4, r3
else
bd->hold_timer = 0;
}
if (bd->hold_timer)
b8b4: e3530000 cmp r3, #0
if (bd->hold_timer)
{
if (update_timers)
{
if (bd->hold_timer > timer_delta)
bd->hold_timer -= timer_delta;
b8b8: e58c302c str r3, [ip, #44] ; 0x2c
else
bd->hold_timer = 0;
}
if (bd->hold_timer)
b8bc: 1a000007 bne b8e0 <rtems_bdbuf_swapout_modified_processing+0xb4>
{
node = node->next;
continue;
b8c0: e5903000 ldr r3, [r0] <== NOT EXECUTED
b8c4: e59c4014 ldr r4, [ip, #20] <== NOT EXECUTED
/*
* This assumes we can set it to BDBUF_INVALID_DEV which is just an
* assumption. Cannot use the transfer list being empty the sync dev
* calls sets the dev to use.
*/
if (*dd_ptr == BDBUF_INVALID_DEV)
b8c8: e3530000 cmp r3, #0
*dd_ptr = bd->dd;
b8cc: 05804000 streq r4, [r0]
b8d0: 01a03004 moveq r3, r4
b8d4: 059c4014 ldreq r4, [ip, #20]
if (bd->dd == *dd_ptr)
b8d8: e1530004 cmp r3, r4
b8dc: 0a000004 beq b8f4 <rtems_bdbuf_swapout_modified_processing+0xc8>
node = next_node;
}
else
{
node = node->next;
b8e0: e59cc000 ldr ip, [ip]
if (sync_active && (*dd_ptr == BDBUF_INVALID_DEV))
sync_all = true;
else
sync_all = false;
while (!rtems_chain_is_tail (chain, node))
b8e4: e151000c cmp r1, ip
b8e8: 1affffde bne b868 <rtems_bdbuf_swapout_modified_processing+0x3c>
{
node = node->next;
}
}
}
}
b8ec: e8bd0ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp}
b8f0: e12fff1e bx lr
if (*dd_ptr == BDBUF_INVALID_DEV)
*dd_ptr = bd->dd;
if (bd->dd == *dd_ptr)
{
rtems_chain_node* next_node = node->next;
b8f4: e59c6000 ldr r6, [ip]
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
b8f8: e59c4004 ldr r4, [ip, #4]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
b8fc: e3a03009 mov r3, #9
b900: e58c3020 str r3, [ip, #32]
next->previous = previous;
b904: e5864004 str r4, [r6, #4]
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
b908: e5923008 ldr r3, [r2, #8]
while (node && !rtems_chain_is_head (transfer, tnode))
b90c: e1530002 cmp r3, r2
previous->next = next;
b910: e5846000 str r6, [r4]
b914: 0a000011 beq b960 <rtems_bdbuf_swapout_modified_processing+0x134>
b918: e59c5018 ldr r5, [ip, #24]
{
rtems_bdbuf_buffer* tbd = (rtems_bdbuf_buffer*) tnode;
if (bd->block > tbd->block)
b91c: e5934018 ldr r4, [r3, #24]
b920: e1550004 cmp r5, r4
b924: 9a00000a bls b954 <rtems_bdbuf_swapout_modified_processing+0x128>
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
b928: e5934000 ldr r4, [r3]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
b92c: e58c3004 str r3, [ip, #4]
before_node = after_node->next; after_node->next = the_node;
b930: e583c000 str ip, [r3]
the_node->next = before_node; before_node->previous = the_node;
b934: e584c004 str ip, [r4, #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;
b938: e58c4000 str r4, [ip]
before_node->previous = the_node;
b93c: e1a0c006 mov ip, r6
b940: eaffffe7 b b8e4 <rtems_bdbuf_swapout_modified_processing+0xb8>
*
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dd_ptr == bd->dd))
|| rtems_bdbuf_has_buffer_waiters ())
b944: e5903000 ldr r3, [r0]
b948: e59c4014 ldr r4, [ip, #20]
bd->hold_timer = 0;
b94c: e58ca02c str sl, [ip, #44] ; 0x2c
b950: eaffffdc b b8c8 <rtems_bdbuf_swapout_modified_processing+0x9c>
{
rtems_chain_insert_unprotected (tnode, node);
node = NULL;
}
else
tnode = tnode->previous;
b954: e5933004 ldr r3, [r3, #4]
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
while (node && !rtems_chain_is_head (transfer, tnode))
b958: e1530002 cmp r3, r2
b95c: 1affffee bne b91c <rtems_bdbuf_swapout_modified_processing+0xf0>
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
b960: e5923000 ldr r3, [r2]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
b964: e58c2004 str r2, [ip, #4]
before_node = after_node->next; after_node->next = the_node;
b968: e582c000 str ip, [r2]
the_node->next = before_node; before_node->previous = the_node;
b96c: e583c004 str ip, [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;
b970: e58c3000 str r3, [ip]
before_node->previous = the_node;
b974: e1a0c006 mov ip, r6
b978: eaffffd9 b b8e4 <rtems_bdbuf_swapout_modified_processing+0xb8>
if (update_timers)
{
if (bd->hold_timer > timer_delta)
bd->hold_timer -= timer_delta;
else
bd->hold_timer = 0;
b97c: e58cb02c str fp, [ip, #44] ; 0x2c
b980: e5903000 ldr r3, [r0]
b984: e59c4014 ldr r4, [ip, #20]
b988: eaffffce b b8c8 <rtems_bdbuf_swapout_modified_processing+0x9c>
* or someone waits for a buffer written force all the timers to 0.
*
* @note Lots of sync requests will skew this timer. It should be based
* on TOD to be accurate. Does it matter ?
*/
if (sync_all || (sync_active && (*dd_ptr == bd->dd))
b98c: e1a04003 mov r4, r3
|| rtems_bdbuf_has_buffer_waiters ())
bd->hold_timer = 0;
b990: e58ca02c str sl, [ip, #44] ; 0x2c
b994: eaffffcb b b8c8 <rtems_bdbuf_swapout_modified_processing+0x9c>
0000cc4c <rtems_bdbuf_swapout_task>:
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
cc4c: 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;
cc50: e59f7330 ldr r7, [pc, #816] ; cf88 <rtems_bdbuf_swapout_task+0x33c>
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
cc54: e24dd02c sub sp, sp, #44 ; 0x2c
rtems_bdbuf_swapout_transfer transfer; uint32_t period_in_ticks; const uint32_t period_in_msecs = bdbuf_config.swapout_period;
cc58: e597900c ldr r9, [r7, #12]
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
cc5c: ebfffbf6 bl bc3c <rtems_bdbuf_swapout_writereq_alloc>
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
cc60: e0692289 rsb r2, r9, r9, lsl #5
cc64: e59f1320 ldr r1, [pc, #800] ; cf8c <rtems_bdbuf_swapout_task+0x340>
cc68: e0892102 add r2, r9, r2, lsl #2
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
cc6c: e3a03000 mov r3, #0
tail->previous = head;
cc70: e28dc010 add ip, sp, #16
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
cc74: e58d0024 str r0, [sp, #36] ; 0x24
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
cc78: e591100c ldr r1, [r1, #12]
cc7c: e1a00182 lsl r0, r2, #3
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
cc80: e28d2014 add r2, sp, #20
cc84: e58d2010 str r2, [sp, #16]
head->previous = NULL;
cc88: e58d3014 str r3, [sp, #20]
tail->previous = head;
cc8c: e58dc018 str ip, [sp, #24]
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;
cc90: e58d301c str r3, [sp, #28]
transfer.syncing = false;
cc94: e5cd3020 strb r3, [sp, #32]
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
cc98: eb0037d9 bl 1ac04 <__aeabi_uidiv>
cc9c: e58d000c str r0, [sp, #12]
rtems_bdbuf_swapout_workers_open (void)
{
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
cca0: ebfffb41 bl b9ac <rtems_bdbuf_lock_cache>
for (w = 0; w < bdbuf_config.swapout_workers; w++)
cca4: e5978014 ldr r8, [r7, #20]
cca8: e3580000 cmp r8, #0
ccac: 059f62dc ldreq r6, [pc, #732] ; cf90 <rtems_bdbuf_swapout_task+0x344>
ccb0: 0a00002a beq cd60 <rtems_bdbuf_swapout_task+0x114>
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
ccb4: e59f52d4 ldr r5, [pc, #724] ; cf90 <rtems_bdbuf_swapout_task+0x344><== 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)
ccb8: e2888061 add r8, r8, #97 ; 0x61 <== NOT EXECUTED
ccbc: e3a04061 mov r4, #97 ; 0x61 <== NOT EXECUTED
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
if (!worker)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
ccc0: e1a06009 mov r6, r9 <== NOT EXECUTED
the_node->next = tail;
ccc4: e285a00c add sl, r5, #12 <== NOT EXECUTED
ccc8: e1a09008 mov r9, r8 <== NOT EXECUTED
cccc: e3a0b001 mov fp, #1 <== NOT EXECUTED
ccd0: e1a08004 mov r8, r4 <== NOT EXECUTED
for (w = 0; w < bdbuf_config.swapout_workers; w++)
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
ccd4: e3a00028 mov r0, #40 ; 0x28 <== NOT EXECUTED
ccd8: ebffdc0d bl 3d14 <malloc> <== NOT EXECUTED
if (!worker)
ccdc: e2504000 subs r4, r0, #0 <== NOT EXECUTED
cce0: 0a0000a6 beq cf80 <rtems_bdbuf_swapout_task+0x334> <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
cce4: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
the_node->next = tail;
cce8: e584a000 str sl, [r4] <== NOT EXECUTED
tail->previous = the_node; old_last->next = the_node; the_node->previous = old_last;
ccec: e5843004 str r3, [r4, #4] <== 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;
ccf0: e5834000 str r4, [r3] <== NOT EXECUTED
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
ccf4: e5854010 str r4, [r5, #16] <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
ccf8: e5c4b00c strb fp, [r4, #12] <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
ccfc: ebfffbce bl bc3c <rtems_bdbuf_swapout_writereq_alloc> <== NOT EXECUTED
cd00: e5840024 str r0, [r4, #36] ; 0x24 <== 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),
cd04: e59f0288 ldr r0, [pc, #648] ; cf94 <rtems_bdbuf_swapout_task+0x348><== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
cd08: e3a03000 mov r3, #0 <== 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 );
cd0c: e2842010 add r2, r4, #16 <== NOT EXECUTED
cd10: e284c014 add ip, r4, #20 <== NOT EXECUTED
head->next = tail;
cd14: e584c010 str ip, [r4, #16] <== NOT EXECUTED
head->previous = NULL;
cd18: e5843014 str r3, [r4, #20] <== NOT EXECUTED
tail->previous = head;
cd1c: e5842018 str r2, [r4, #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;
cd20: e584301c str r3, [r4, #28] <== NOT EXECUTED
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
cd24: e284c008 add ip, r4, #8 <== NOT EXECUTED
cd28: e1a03004 mov r3, r4 <== NOT EXECUTED
cd2c: e5971018 ldr r1, [r7, #24] <== NOT EXECUTED
cd30: e1880000 orr r0, r8, r0 <== NOT EXECUTED
cd34: e59f225c ldr r2, [pc, #604] ; cf98 <rtems_bdbuf_swapout_task+0x34c><== NOT EXECUTED
cd38: e58dc000 str ip, [sp] <== NOT EXECUTED
cd3c: ebfffc1f bl bdc0 <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)
cd40: e3500000 cmp r0, #0 <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
cd44: e59f3244 ldr r3, [pc, #580] ; cf90 <rtems_bdbuf_swapout_task+0x344><== NOT EXECUTED
cd48: 1a00008a bne cf78 <rtems_bdbuf_swapout_task+0x32c> <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);
cd4c: e2888001 add r8, r8, #1 <== NOT EXECUTED
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
cd50: e1580009 cmp r8, r9 <== NOT EXECUTED
cd54: 1affffde bne ccd4 <rtems_bdbuf_swapout_task+0x88> <== NOT EXECUTED
cd58: e1a09006 mov r9, r6 <== NOT EXECUTED
cd5c: e1a06003 mov r6, r3 <== NOT EXECUTED
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);
}
rtems_bdbuf_unlock_cache ();
cd60: ebfffb2a bl ba10 <rtems_bdbuf_unlock_cache>
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
cd64: e59fb224 ldr fp, [pc, #548] ; cf90 <rtems_bdbuf_swapout_task+0x344>
cd68: e1a07006 mov r7, r6
cd6c: e5d74004 ldrb r4, [r7, #4]
cd70: e3540000 cmp r4, #0
cd74: e59f5214 ldr r5, [pc, #532] ; cf90 <rtems_bdbuf_swapout_task+0x344>
cd78: 0a000069 beq cf24 <rtems_bdbuf_swapout_task+0x2d8>
cd7c: e3a0c001 mov ip, #1
cd80: e58dc008 str ip, [sp, #8]
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
cd84: ebfffb08 bl b9ac <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)
cd88: e5d73030 ldrb r3, [r7, #48] ; 0x30
cd8c: e3530000 cmp r3, #0
cd90: 1a000038 bne ce78 <rtems_bdbuf_swapout_task+0x22c>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
cd94: e59b6008 ldr r6, [fp, #8]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
cd98: e59f21fc ldr r2, [pc, #508] ; cf9c <rtems_bdbuf_swapout_task+0x350>
cd9c: e1560002 cmp r6, r2
cda0: 01a06003 moveq r6, 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,
cda4: 028d4010 addeq r4, sp, #16
cda8: 0a000004 beq cdc0 <rtems_bdbuf_swapout_task+0x174>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
cdac: e1a04006 mov r4, r6 <== NOT EXECUTED
cdb0: e4943010 ldr r3, [r4], #16 <== NOT EXECUTED
head->next = new_first;
new_first->previous = head;
cdb4: e242c004 sub ip, r2, #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;
cdb8: e58b3008 str r3, [fp, #8] <== NOT EXECUTED
new_first->previous = head;
cdbc: e583c004 str ip, [r3, #4] <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
cdc0: e3a03000 mov r3, #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 );
cdc4: e2848004 add r8, r4, #4
head->next = tail;
head->previous = NULL;
tail->previous = head;
cdc8: e9840018 stmib r4, {r3, r4}
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
cdcc: e5848000 str r8, [r4]
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
cdd0: e584300c str r3, [r4, #12]
transfer->syncing = bdbuf_cache.sync_active;
cdd4: e5c43010 strb r3, [r4, #16]
/*
* If we have any buffers in the sync queue move them to the modified
* list. The first sync buffer will select the device we use.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
cdd8: e284500c add r5, r4, #12
cddc: e1a00005 mov r0, r5
cde0: e59f11b8 ldr r1, [pc, #440] ; cfa0 <rtems_bdbuf_swapout_task+0x354>
cde4: e1a02004 mov r2, r4
cde8: e3a03001 mov r3, #1
cdec: e3a0a000 mov sl, #0
cdf0: e58da000 str sl, [sp]
cdf4: e58d9004 str r9, [sp, #4]
cdf8: ebfffa8b bl b82c <rtems_bdbuf_swapout_modified_processing>
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
cdfc: e59dc008 ldr ip, [sp, #8]
ce00: e5d73030 ldrb r3, [r7, #48] ; 0x30
ce04: e1a00005 mov r0, r5
ce08: e59f1194 ldr r1, [pc, #404] ; cfa4 <rtems_bdbuf_swapout_task+0x358>
ce0c: e1a02004 mov r2, r4
ce10: e58dc000 str ip, [sp]
ce14: e58d9004 str r9, [sp, #4]
ce18: ebfffa83 bl b82c <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 ();
ce1c: ebfffafb bl ba10 <rtems_bdbuf_unlock_cache>
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
ce20: e5943000 ldr r3, [r4]
ce24: e1530008 cmp r3, r8
ce28: 0a000007 beq ce4c <rtems_bdbuf_swapout_task+0x200>
{
if (worker)
ce2c: e156000a cmp r6, sl
ce30: 0a000037 beq cf14 <rtems_bdbuf_swapout_task+0x2c8>
{
rtems_status_code sc = rtems_event_send (worker->id,
ce34: e5960008 ldr r0, [r6, #8] <== NOT EXECUTED
ce38: e3a01004 mov r1, #4 <== NOT EXECUTED
ce3c: ebffea0d bl 7678 <rtems_event_send> <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
ce40: e150000a cmp r0, sl <== NOT EXECUTED
ce44: 1a000049 bne cf70 <rtems_bdbuf_swapout_task+0x324> <== NOT EXECUTED
else
{
rtems_bdbuf_swapout_write (transfer);
}
transfered_buffers = true;
ce48: e3a0a001 mov sl, #1 <== NOT EXECUTED
}
if (bdbuf_cache.sync_active && !transfered_buffers)
ce4c: e5d73030 ldrb r3, [r7, #48] ; 0x30
ce50: e3530000 cmp r3, #0
ce54: 0a000014 beq ceac <rtems_bdbuf_swapout_task+0x260>
ce58: e35a0000 cmp sl, #0
ce5c: 0a00001e beq cedc <rtems_bdbuf_swapout_task+0x290>
ce60: e3a0c000 mov ip, #0
ce64: e58dc008 str ip, [sp, #8]
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
ce68: ebfffacf bl b9ac <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)
ce6c: e5d73030 ldrb r3, [r7, #48] ; 0x30
ce70: e3530000 cmp r3, #0
ce74: 0affffc6 beq cd94 <rtems_bdbuf_swapout_task+0x148>
ce78: e28d2014 add r2, sp, #20
* When the sync is for a device limit the sync to that device. If the sync
* is for a buffer handle process the devices in the order on the sync
* list. This means the dev is BDBUF_INVALID_DEV.
*/
if (bdbuf_cache.sync_active)
transfer->dd = bdbuf_cache.sync_device;
ce7c: e59b3038 ldr r3, [fp, #56] ; 0x38
head->previous = NULL; tail->previous = head;
ce80: e28dc010 add ip, sp, #16
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
ce84: e3a06000 mov r6, #0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ce88: e58d2010 str r2, [sp, #16]
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
transfer->syncing = bdbuf_cache.sync_active;
ce8c: e3a02001 mov r2, #1
head->previous = NULL;
ce90: e58d6014 str r6, [sp, #20]
tail->previous = head;
ce94: e58dc018 str ip, [sp, #24]
ce98: e5cd2020 strb r2, [sp, #32]
* 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;
ce9c: e58d301c str r3, [sp, #28]
/*
* 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,
cea0: e1a0400c mov r4, ip
cea4: e28d8014 add r8, sp, #20
cea8: eaffffca b cdd8 <rtems_bdbuf_swapout_task+0x18c>
ceac: e35a0000 cmp sl, #0
ceb0: 1a000015 bne cf0c <rtems_bdbuf_swapout_task+0x2c0>
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
ceb4: e3a00004 mov r0, #4
ceb8: e3a01000 mov r1, #0
cebc: e59d200c ldr r2, [sp, #12]
cec0: e28d3028 add r3, sp, #40 ; 0x28
cec4: ebffe988 bl 74ec <rtems_event_receive>
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
cec8: e3500006 cmp r0, #6
cecc: 13500000 cmpne r0, #0
ced0: 0affffa5 beq cd6c <rtems_bdbuf_swapout_task+0x120>
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);
ced4: e3a00018 mov r0, #24 <== NOT EXECUTED
ced8: ebfffaaf bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
}
if (bdbuf_cache.sync_active && !transfered_buffers)
{
rtems_id sync_requester;
rtems_bdbuf_lock_cache ();
cedc: ebfffab2 bl b9ac <rtems_bdbuf_lock_cache>
sync_requester = bdbuf_cache.sync_requester;
cee0: e59f20a8 ldr r2, [pc, #168] ; cf90 <rtems_bdbuf_swapout_task+0x344>
cee4: e5924034 ldr r4, [r2, #52] ; 0x34
bdbuf_cache.sync_active = false;
cee8: e5c2a030 strb sl, [r2, #48] ; 0x30
bdbuf_cache.sync_requester = 0;
ceec: e582a034 str sl, [r2, #52] ; 0x34
rtems_bdbuf_unlock_cache ();
cef0: ebfffac6 bl ba10 <rtems_bdbuf_unlock_cache>
if (sync_requester)
cef4: e3540000 cmp r4, #0
cef8: 0affffed beq ceb4 <rtems_bdbuf_swapout_task+0x268>
cefc: e1a00004 mov r0, r4
cf00: e3a01102 mov r1, #-2147483648 ; 0x80000000
cf04: ebffeb67 bl 7ca8 <rtems_event_system_send>
cf08: eaffffe9 b ceb4 <rtems_bdbuf_swapout_task+0x268>
/*
* 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,
cf0c: e58d3008 str r3, [sp, #8]
cf10: eaffff9b b cd84 <rtems_bdbuf_swapout_task+0x138>
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_2);
}
else
{
rtems_bdbuf_swapout_write (transfer);
cf14: e1a00004 mov r0, r4
cf18: ebfffeef bl cadc <rtems_bdbuf_swapout_write>
}
transfered_buffers = true;
cf1c: e3a0a001 mov sl, #1
cf20: eaffffc9 b ce4c <rtems_bdbuf_swapout_task+0x200>
static void
rtems_bdbuf_swapout_workers_close (void)
{
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
cf24: ebfffaa0 bl b9ac <rtems_bdbuf_lock_cache> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
cf28: e5956008 ldr r6, [r5, #8] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
cf2c: e285500c add r5, r5, #12 <== NOT EXECUTED
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
cf30: e1560005 cmp r6, r5 <== NOT EXECUTED
cf34: 0a000006 beq cf54 <rtems_bdbuf_swapout_task+0x308> <== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
cf38: e5c6400c strb r4, [r6, #12] <== NOT EXECUTED
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
cf3c: e5960008 ldr r0, [r6, #8] <== NOT EXECUTED
cf40: e3a01004 mov r1, #4 <== NOT EXECUTED
cf44: ebffe9cb bl 7678 <rtems_event_send> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
cf48: e5966000 ldr r6, [r6] <== 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))
cf4c: e1560005 cmp r6, r5 <== NOT EXECUTED
cf50: 1afffff8 bne cf38 <rtems_bdbuf_swapout_task+0x2ec> <== NOT EXECUTED
worker->enabled = false;
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
node = rtems_chain_next (node);
}
rtems_bdbuf_unlock_cache ();
cf54: ebfffaad bl ba10 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);
}
rtems_bdbuf_swapout_workers_close ();
free (transfer.write_req);
cf58: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED
cf5c: ebffda31 bl 3828 <free> <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
cf60: e3a00000 mov r0, #0 <== NOT EXECUTED
cf64: ebffebb7 bl 7e48 <rtems_task_delete> <== NOT EXECUTED
}
cf68: e28dd02c add sp, sp, #44 ; 0x2c <== NOT EXECUTED
cf6c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (worker)
{
rtems_status_code sc = rtems_event_send (worker->id,
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_2);
cf70: e3a0000c mov r0, #12 <== NOT EXECUTED
cf74: ebfffa88 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_WORKER_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);
cf78: e3a0000d mov r0, #13 <== NOT EXECUTED
cf7c: ebfffa86 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
if (!worker)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);
cf80: e3a0000a mov r0, #10 <== NOT EXECUTED
cf84: ebfffa84 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
0000cfa8 <rtems_bdbuf_swapout_worker_task>:
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
cfa8: e5d0300c ldrb r3, [r0, #12] <== NOT EXECUTED
cfac: e3530000 cmp r3, #0 <== NOT EXECUTED
* @param arg A pointer to the worker thread's private data.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
cfb0: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
cfb4: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
cfb8: 0a000016 beq d018 <rtems_bdbuf_swapout_worker_task+0x70> <== NOT EXECUTED
cfbc: e59f5070 ldr r5, [pc, #112] ; d034 <rtems_bdbuf_swapout_worker_task+0x8c><== NOT EXECUTED
cfc0: e2807010 add r7, r0, #16 <== NOT EXECUTED
cfc4: e280a014 add sl, r0, #20 <== NOT EXECUTED
cfc8: e285800c add r8, r5, #12 <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
cfcc: e3a06000 mov r6, #0 <== NOT EXECUTED
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
cfd0: e3a00004 mov r0, #4 <== NOT EXECUTED
cfd4: ebfffb06 bl bbf4 <rtems_bdbuf_wait_for_event> <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
cfd8: e1a00007 mov r0, r7 <== NOT EXECUTED
cfdc: ebfffebe bl cadc <rtems_bdbuf_swapout_write> <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
cfe0: ebfffa71 bl b9ac <rtems_bdbuf_lock_cache> <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
cfe4: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
cfe8: e584a010 str sl, [r4, #16] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
cfec: e584601c str r6, [r4, #28] <== NOT EXECUTED
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
cff0: e5848000 str r8, [r4] <== NOT EXECUTED
tail->previous = the_node;
cff4: e5854010 str r4, [r5, #16] <== NOT EXECUTED
old_last->next = the_node;
cff8: e5834000 str r4, [r3] <== NOT EXECUTED
the_node->previous = old_last;
cffc: e5843004 str r3, [r4, #4] <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
d000: e5846014 str r6, [r4, #20] <== NOT EXECUTED
tail->previous = head;
d004: e5847018 str r7, [r4, #24] <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
d008: ebfffa80 bl ba10 <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)
d00c: e5d4300c ldrb r3, [r4, #12] <== NOT EXECUTED
d010: e3530000 cmp r3, #0 <== NOT EXECUTED
d014: 1affffed bne cfd0 <rtems_bdbuf_swapout_worker_task+0x28> <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
}
free (worker->transfer.write_req);
d018: e5940024 ldr r0, [r4, #36] ; 0x24 <== NOT EXECUTED
d01c: ebffda01 bl 3828 <free> <== NOT EXECUTED
free (worker);
d020: e1a00004 mov r0, r4 <== NOT EXECUTED
d024: ebffd9ff bl 3828 <free> <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
d028: e3a00000 mov r0, #0 <== NOT EXECUTED
}
d02c: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
}
free (worker->transfer.write_req);
free (worker);
rtems_task_delete (RTEMS_SELF);
d030: eaffeb84 b 7e48 <rtems_task_delete> <== NOT EXECUTED
0000cadc <rtems_bdbuf_swapout_write>:
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
cadc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
cae0: e1a05000 mov r5, r0
cae4: e4953004 ldr r3, [r5], #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))
cae8: e1530005 cmp r3, r5
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
caec: e24dd004 sub sp, sp, #4
caf0: 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))
caf4: 0a00004c beq cc2c <rtems_bdbuf_swapout_write+0x150>
* 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;
caf8: e590700c ldr r7, [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;
cafc: e5972008 ldr r2, [r7, #8]
* 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;
cb00: e5901014 ldr r1, [r0, #20]
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
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;
cb04: e592b00c ldr fp, [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;
cb08: e597c02c ldr ip, [r7, #44] ; 0x2c
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
cb0c: e3a02000 mov r2, #0
* should be possible to make this change with little effect in this
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
cb10: e3a0000c mov r0, #12
{
/*
* The last block number used when the driver only supports
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
cb14: e1a06002 mov r6, r2
rtems_disk_device *dd = transfer->dd;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
cb18: e58dc000 str ip, [sp]
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
cb1c: e20bb001 and fp, fp, #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;
cb20: e581000c str r0, [r1, #12]
transfer->write_req->bufnum = 0;
cb24: e5812010 str r2, [r1, #16]
* 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))
cb28: e59f8118 ldr r8, [pc, #280] ; cc48 <rtems_bdbuf_swapout_write+0x16c>
cb2c: ea00001d b cba8 <rtems_bdbuf_swapout_write+0xcc>
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 &&
cb30: e5910010 ldr r0, [r1, #16]
cb34: e3500000 cmp r0, #0
cb38: e593a018 ldr sl, [r3, #24]
cb3c: 0a00001f beq cbc0 <rtems_bdbuf_swapout_write+0xe4>
bd->block != last_block + media_blocks_per_block)
cb40: e59dc000 ldr ip, [sp]
cb44: e086000c add r0, r6, ip
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 &&
cb48: e15a0000 cmp sl, r0
cb4c: 0a00001b beq cbc0 <rtems_bdbuf_swapout_write+0xe4>
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
cb50: e5843000 str r3, [r4]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
cb54: e8830014 stm r3, {r2, r4}
before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; before_node->previous = the_node;
cb58: e5823004 str r3, [r2, #4]
cb5c: e5943000 ldr r3, [r4]
bd->block != last_block + media_blocks_per_block)
{
rtems_chain_prepend_unprotected (&transfer->bds, &bd->link);
write = true;
cb60: e3a00001 mov r0, #1
/*
* 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) ||
cb64: e1550003 cmp r5, r3
cb68: 0a000003 beq cb7c <rtems_bdbuf_swapout_write+0xa0>
cb6c: e591c010 ldr ip, [r1, #16]
cb70: e5982004 ldr r2, [r8, #4]
cb74: e15c0002 cmp ip, r2
cb78: 3a000020 bcc cc00 <rtems_bdbuf_swapout_write+0x124>
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
cb7c: e1a00007 mov r0, r7
cb80: e3a02000 mov r2, #0
cb84: ebffff54 bl c8dc <rtems_bdbuf_execute_transfer_request>
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
cb88: e5941014 ldr r1, [r4, #20]
cb8c: e3a0300c mov r3, #12
cb90: e581300c str r3, [r1, #12]
transfer->write_req->bufnum = 0;
cb94: e5943000 ldr r3, [r4]
cb98: e3a00000 mov r0, #0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
cb9c: e1550003 cmp r5, r3
cba0: e5810010 str r0, [r1, #16]
cba4: 0a000019 beq cc10 <rtems_bdbuf_swapout_write+0x134>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
cba8: 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 &&
cbac: e35b0000 cmp fp, #0
head->next = new_first;
cbb0: e5842000 str r2, [r4]
new_first->previous = head;
cbb4: e5824004 str r4, [r2, #4]
cbb8: 1affffdc bne cb30 <rtems_bdbuf_swapout_write+0x54>
cbbc: e593a018 ldr sl, [r3, #24]
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
cbc0: e5919010 ldr r9, [r1, #16]
cbc4: e1a0c209 lsl ip, r9, #4
cbc8: e28cc018 add ip, ip, #24
transfer->write_req->bufnum++;
cbcc: e2899001 add r9, r9, #1
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
cbd0: e081000c add r0, r1, ip
transfer->write_req->bufnum++;
cbd4: e5819010 str r9, [r1, #16]
buf->user = bd;
buf->block = bd->block;
cbd8: e781a00c str sl, [r1, ip]
buf->length = dd->block_size;
cbdc: e597c024 ldr ip, [r7, #36] ; 0x24
cbe0: e580c004 str ip, [r0, #4]
buf->buffer = bd->buffer;
cbe4: e593c01c ldr ip, [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;
cbe8: e1a0600a mov r6, sl
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
cbec: e580300c str r3, [r0, #12]
buf->block = bd->block;
buf->length = dd->block_size;
buf->buffer = bd->buffer;
cbf0: e580c008 str ip, [r0, #8]
cbf4: e1a03002 mov r3, r2
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;
cbf8: e3a00000 mov r0, #0
cbfc: eaffffd8 b cb64 <rtems_bdbuf_swapout_write+0x88>
if (rtems_chain_is_empty (&transfer->bds) ||
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
cc00: e3500000 cmp r0, #0
cc04: 1affffdc bne cb7c <rtems_bdbuf_swapout_write+0xa0>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
cc08: e1550003 cmp r5, r3
cc0c: 1affffe5 bne cba8 <rtems_bdbuf_swapout_write+0xcc>
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
cc10: e5d43010 ldrb r3, [r4, #16]
cc14: e3530000 cmp r3, #0
cc18: 0a000003 beq cc2c <rtems_bdbuf_swapout_write+0x150>
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
cc1c: e5970008 ldr r0, [r7, #8]
cc20: 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 &&
cc24: e3130002 tst r3, #2
cc28: 1a000001 bne cc34 <rtems_bdbuf_swapout_write+0x158>
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
/* How should the error be handled ? */
}
}
}
cc2c: e28dd004 add sp, sp, #4
cc30: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* call perform the call.
*/
if (transfer->syncing &&
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
cc34: e3a01002 mov r1, #2 <== NOT EXECUTED
cc38: e3a02000 mov r2, #0 <== NOT EXECUTED
cc3c: e1a0e00f mov lr, pc <== NOT EXECUTED
cc40: e597f038 ldr pc, [r7, #56] ; 0x38 <== NOT EXECUTED
cc44: eafffff8 b cc2c <rtems_bdbuf_swapout_write+0x150> <== NOT EXECUTED
0000bc3c <rtems_bdbuf_swapout_writereq_alloc>:
* have been a rtems_chain_control. Simple, fast and less storage as the node
* is already part of the buffer structure.
*/
rtems_blkdev_request* write_req =
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
bc3c: e59f3040 ldr r3, [pc, #64] ; bc84 <rtems_bdbuf_swapout_writereq_alloc+0x48>
bc40: e5930004 ldr r0, [r3, #4]
bc44: e1a00200 lsl r0, r0, #4
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
bc48: e92d4010 push {r4, lr}
* @note chrisj The rtems_blkdev_request and the array at the end is a hack. * I am disappointment at finding code like this in RTEMS. The request should * have been a rtems_chain_control. Simple, fast and less storage as the node * is already part of the buffer structure. */ rtems_blkdev_request* write_req =
bc4c: e2800018 add r0, r0, #24
bc50: ebffe02f bl 3d14 <malloc>
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
if (!write_req)
bc54: e2504000 subs r4, r0, #0
bc58: 0a000007 beq bc7c <rtems_bdbuf_swapout_writereq_alloc+0x40>
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_REQ_NOMEM);
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
bc5c: e3a03001 mov r3, #1
bc60: e5843000 str r3, [r4]
write_req->done = rtems_bdbuf_transfer_done;
bc64: e59f301c ldr r3, [pc, #28] ; bc88 <rtems_bdbuf_swapout_writereq_alloc+0x4c>
bc68: e5843004 str r3, [r4, #4]
write_req->io_task = rtems_task_self ();
bc6c: eb000fb1 bl fb38 <rtems_task_self>
bc70: e5840014 str r0, [r4, #20]
return write_req;
}
bc74: e1a00004 mov r0, r4
bc78: e8bd8010 pop {r4, pc}
rtems_blkdev_request* write_req =
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
if (!write_req)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_REQ_NOMEM);
bc7c: e3a00009 mov r0, #9 <== NOT EXECUTED
bc80: ebffff45 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
0000daac <rtems_bdbuf_sync>:
}
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
daac: e92d4070 push {r4, r5, r6, lr}
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (bd == NULL)
dab0: e2504000 subs r4, r0, #0
dab4: 0a00002a beq db64 <rtems_bdbuf_sync+0xb8>
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
dab8: ebfff7bb bl b9ac <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
dabc: e5940020 ldr r0, [r4, #32]
dac0: e3500003 cmp r0, #3
dac4: 2a000001 bcs dad0 <rtems_bdbuf_sync+0x24>
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_5);
dac8: e3a01011 mov r1, #17 <== NOT EXECUTED
dacc: ebfff7cc bl ba04 <rtems_bdbuf_fatal_with_state> <== NOT EXECUTED
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
dad0: e3500005 cmp r0, #5
dad4: 9a000006 bls daf4 <rtems_bdbuf_sync+0x48>
dad8: e3500006 cmp r0, #6
dadc: 1afffff9 bne dac8 <rtems_bdbuf_sync+0x1c>
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);
dae0: e1a00004 mov r0, r4
dae4: ebfffb5d bl c860 <rtems_bdbuf_discard_buffer_after_access>
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
dae8: ebfff7c8 bl ba10 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
daec: e3a00000 mov r0, #0
daf0: e8bd8070 pop {r4, r5, r6, pc}
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
daf4: e59f50e4 ldr r5, [pc, #228] ; dbe0 <rtems_bdbuf_sync+0x134>
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
daf8: e5941024 ldr r1, [r4, #36] ; 0x24
dafc: e5953060 ldr r3, [r5, #96] ; 0x60
the_node->next = tail;
db00: e285205c add r2, r5, #92 ; 0x5c
db04: e3510000 cmp r1, #0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
db08: e3a01008 mov r1, #8
db0c: e5841020 str r1, [r4, #32]
db10: e5842000 str r2, [r4]
tail->previous = the_node;
db14: e5854060 str r4, [r5, #96] ; 0x60
old_last->next = the_node;
db18: e5834000 str r4, [r3]
the_node->previous = old_last;
db1c: 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)
db20: 1a000021 bne dbac <rtems_bdbuf_sync+0x100>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
rtems_bdbuf_wake_swapper ();
db24: ebfff7cb bl ba58 <rtems_bdbuf_wake_swapper>
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
db28: e5940020 ldr r0, [r4, #32]
db2c: e2403001 sub r3, r0, #1
db30: e3530009 cmp r3, #9
db34: 979ff103 ldrls pc, [pc, r3, lsl #2]
db38: ea000015 b db94 <rtems_bdbuf_sync+0xe8> <== NOT EXECUTED
db3c: 0000db6c .word 0x0000db6c <== NOT EXECUTED
db40: 0000db6c .word 0x0000db6c <== NOT EXECUTED
db44: 0000db6c .word 0x0000db6c <== NOT EXECUTED
db48: 0000db6c .word 0x0000db6c <== NOT EXECUTED
db4c: 0000db6c .word 0x0000db6c <== NOT EXECUTED
db50: 0000db6c .word 0x0000db6c <== NOT EXECUTED
db54: 0000db6c .word 0x0000db6c <== NOT EXECUTED
db58: 0000db9c .word 0x0000db9c <== NOT EXECUTED
db5c: 0000db9c .word 0x0000db9c <== NOT EXECUTED
db60: 0000db9c .word 0x0000db9c <== NOT EXECUTED
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;
db64: e3a00009 mov r0, #9 <== NOT EXECUTED
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
return RTEMS_SUCCESSFUL;
}
db68: e8bd8070 pop {r4, r5, r6, pc} <== 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
db6c: e5946024 ldr r6, [r4, #36] ; 0x24
db70: e3560000 cmp r6, #0
db74: 1affffdb bne dae8 <rtems_bdbuf_sync+0x3c>
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
db78: e3530001 cmp r3, #1
db7c: 8affffd9 bhi dae8 <rtems_bdbuf_sync+0x3c>
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
db80: e3500001 cmp r0, #1
db84: 0a00000b beq dbb8 <rtems_bdbuf_sync+0x10c>
{
rtems_bdbuf_remove_from_tree (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
}
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
db88: e59f0054 ldr r0, [pc, #84] ; dbe4 <rtems_bdbuf_sync+0x138>
db8c: ebfff850 bl bcd4 <rtems_bdbuf_wake>
db90: eaffffd4 b dae8 <rtems_bdbuf_sync+0x3c>
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_9);
db94: e3a01015 mov r1, #21 <== NOT EXECUTED
db98: ebfff799 bl ba04 <rtems_bdbuf_fatal_with_state> <== 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);
db9c: e1a00004 mov r0, r4
dba0: e59f1040 ldr r1, [pc, #64] ; dbe8 <rtems_bdbuf_sync+0x13c>
dba4: ebfff7fb bl bb98 <rtems_bdbuf_wait>
dba8: eaffffde b db28 <rtems_bdbuf_sync+0x7c>
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
dbac: e2850064 add r0, r5, #100 ; 0x64
dbb0: ebfff847 bl bcd4 <rtems_bdbuf_wake>
dbb4: eaffffda b db24 <rtems_bdbuf_sync+0x78>
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
{
rtems_bdbuf_remove_from_tree (bd);
dbb8: e1a00004 mov r0, r4
dbbc: ebfff89b bl be30 <rtems_bdbuf_remove_from_tree>
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
dbc0: e5953040 ldr r3, [r5, #64] ; 0x40
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
dbc4: e59f2020 ldr r2, [pc, #32] ; dbec <rtems_bdbuf_sync+0x140>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
dbc8: e5846020 str r6, [r4, #32]
dbcc: e5842004 str r2, [r4, #4]
before_node = after_node->next; after_node->next = the_node;
dbd0: e5854040 str r4, [r5, #64] ; 0x40
the_node->next = before_node; before_node->previous = the_node;
dbd4: 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;
dbd8: e5843000 str r3, [r4]
dbdc: eaffffe9 b db88 <rtems_bdbuf_sync+0xdc>
0000ba10 <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);
ba10: e59f3018 ldr r3, [pc, #24] ; ba30 <rtems_bdbuf_unlock_cache+0x20>
/**
* Unlock the cache.
*/
static void
rtems_bdbuf_unlock_cache (void)
{
ba14: 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);
ba18: e5930028 ldr r0, [r3, #40] ; 0x28
ba1c: ebfff078 bl 7c04 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ba20: e3500000 cmp r0, #0
ba24: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_bdbuf_fatal (fatal_error_code);
ba28: e3a00001 mov r0, #1 <== NOT EXECUTED
ba2c: ebffffda bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
0000ba34 <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,
ba34: e59f3018 ldr r3, [pc, #24] ; ba54 <rtems_bdbuf_unlock_sync+0x20>
/**
* Unlock the cache's sync lock. Any blocked writers are woken.
*/
static void
rtems_bdbuf_unlock_sync (void)
{
ba38: 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);
ba3c: e593002c ldr r0, [r3, #44] ; 0x2c
ba40: ebfff06f bl 7c04 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ba44: e3500000 cmp r0, #0
ba48: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_bdbuf_fatal (fatal_error_code);
ba4c: e3a0001a mov r0, #26 <== NOT EXECUTED
ba50: ebffffd1 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
0000bbf4 <rtems_bdbuf_wait_for_event>:
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
bbf4: e92d4010 push {r4, lr}
bbf8: e24dd004 sub sp, sp, #4
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_event_set out = 0;
bbfc: e3a01000 mov r1, #0
bc00: e28d3004 add r3, sp, #4
bc04: e5231004 str r1, [r3, #-4]!
sc = rtems_event_receive (event,
bc08: e1a02001 mov r2, r1
bc0c: e1a0300d mov r3, sp
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
bc10: e1a04000 mov r4, r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
sc = rtems_event_receive (event,
bc14: ebffee34 bl 74ec <rtems_event_receive>
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
bc18: e3500000 cmp r0, #0
bc1c: 1a000004 bne bc34 <rtems_bdbuf_wait_for_event+0x40>
bc20: e59d3000 ldr r3, [sp]
bc24: e1530004 cmp r3, r4
bc28: 1a000001 bne bc34 <rtems_bdbuf_wait_for_event+0x40>
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);
}
bc2c: e28dd004 add sp, sp, #4
bc30: e8bd8010 pop {r4, pc}
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);
bc34: e3a0001c mov r0, #28 <== NOT EXECUTED
bc38: ebffff57 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
0000ba80 <rtems_bdbuf_wait_for_transient_event>:
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);
}
static void
rtems_bdbuf_wait_for_transient_event (void)
{
ba80: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
ba84: e3a01000 mov r1, #0
ba88: e24dd004 sub sp, sp, #4
ba8c: e3a00102 mov r0, #-2147483648 ; 0x80000000
ba90: e1a02001 mov r2, r1
ba94: e1a0300d mov r3, sp
ba98: eb000fa8 bl f940 <rtems_event_system_receive>
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_event_transient_receive (RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ba9c: e3500000 cmp r0, #0
baa0: 1a000001 bne baac <rtems_bdbuf_wait_for_transient_event+0x2c>
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_TRANS_EVNT);
}
baa4: e28dd004 add sp, sp, #4
baa8: e8bd8000 pop {pc}
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_event_transient_receive (RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_TRANS_EVNT);
baac: e3a0001d mov r0, #29 <== NOT EXECUTED
bab0: ebffffb9 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
0000bcd4 <rtems_bdbuf_wake>:
static void
rtems_bdbuf_wake (const rtems_bdbuf_waiters *waiters)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
bcd4: e5903000 ldr r3, [r0]
bcd8: 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)
{
bcdc: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
bce0: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
{
sc = rtems_semaphore_flush (waiters->sema);
bce4: e5900004 ldr r0, [r0, #4]
bce8: eb000ee9 bl f894 <rtems_semaphore_flush>
if (sc != RTEMS_SUCCESSFUL)
bcec: e3500000 cmp r0, #0
bcf0: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAKE);
bcf4: e3a00004 mov r0, #4 <== NOT EXECUTED
bcf8: ebffff27 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
0000ba58 <rtems_bdbuf_wake_swapper>:
}
static void
rtems_bdbuf_wake_swapper (void)
{
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
ba58: e59f301c ldr r3, [pc, #28] ; ba7c <rtems_bdbuf_wake_swapper+0x24>
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
ba5c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
ba60: e3a01004 mov r1, #4
ba64: e5930000 ldr r0, [r3]
ba68: ebffef02 bl 7678 <rtems_event_send>
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
ba6c: e3500000 cmp r0, #0
ba70: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_1);
ba74: e3a0000b mov r0, #11 <== NOT EXECUTED
ba78: ebffffc7 bl b99c <rtems_bdbuf_fatal> <== NOT EXECUTED
00001e44 <rtems_bdpart_create>:
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
1e44: 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;
1e48: e2514000 subs r4, r1, #0
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
1e4c: e24dd020 sub sp, sp, #32
1e50: e1a06002 mov r6, r2
1e54: e1a07003 mov r7, r3
1e58: e59d5044 ldr r5, [sp, #68] ; 0x44
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
1e5c: 0a000002 beq 1e6c <rtems_bdpart_create+0x28>
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
1e60: e5943000 ldr r3, [r4]
1e64: e3530000 cmp r3, #0
1e68: 0a00000e beq 1ea8 <rtems_bdpart_create+0x64>
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
1e6c: e3a0a000 mov sl, #0 <== NOT EXECUTED
1e70: e58da01c str sl, [sp, #28] <== NOT EXECUTED
rtems_blkdev_bnum pos = 0; rtems_blkdev_bnum dist_sum = 0; rtems_blkdev_bnum record_space =
1e74: e3a08001 mov r8, #1 <== NOT EXECUTED
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) {
1e78: e3550000 cmp r5, #0
/* Nothing to do */
return RTEMS_SUCCESSFUL;
1e7c: 01a09005 moveq r9, r5
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) {
1e80: 0a000005 beq 1e9c <rtems_bdpart_create+0x58>
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL || dist == NULL) {
1e84: e3540000 cmp r4, #0
1e88: 13560000 cmpne r6, #0
1e8c: 13a01000 movne r1, #0
1e90: 03a01001 moveq r1, #1
1e94: 1a00000a bne 1ec4 <rtems_bdpart_create+0x80>
return RTEMS_INVALID_ADDRESS;
1e98: e3a09009 mov r9, #9 <== NOT EXECUTED
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
return RTEMS_SUCCESSFUL;
}
1e9c: e1a00009 mov r0, r9
1ea0: e28dd020 add sp, sp, #32
1ea4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
1ea8: e5d42008 ldrb r2, [r4, #8]
1eac: e3520000 cmp r2, #0
1eb0: 0affffed beq 1e6c <rtems_bdpart_create+0x28>
rtems_blkdev_bnum disk_end = 0;
1eb4: e58d301c str r3, [sp, #28]
const unsigned *dist,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
1eb8: e3a0a001 mov sl, #1
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
1ebc: e3a0803f mov r8, #63 ; 0x3f
1ec0: eaffffec b 1e78 <rtems_bdpart_create+0x34>
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL || dist == NULL) {
1ec4: e3570000 cmp r7, #0
1ec8: 0afffff2 beq 1e98 <rtems_bdpart_create+0x54>
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, NULL, NULL, &disk_end);
1ecc: e1a02001 mov r2, r1
1ed0: e28d301c add r3, sp, #28
1ed4: eb000120 bl 235c <rtems_bdpart_get_disk_data>
if (sc != RTEMS_SUCCESSFUL) {
1ed8: e2509000 subs r9, r0, #0
1edc: 1affffee bne 1e9c <rtems_bdpart_create+0x58>
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
unsigned prev_sum = dist_sum;
dist_sum += dist [i];
1ee0: e597b000 ldr fp, [r7]
if (dist_sum < prev_sum) {
return RTEMS_INVALID_NUMBER;
}
if (dist [i] == 0) {
1ee4: e35b0000 cmp fp, #0
1ee8: 0a00005b beq 205c <rtems_bdpart_create+0x218>
1eec: e1a03007 mov r3, r7
1ef0: e1a00007 mov r0, r7
1ef4: e1a01009 mov r1, r9
1ef8: e1a0700b mov r7, fp
1efc: ea000004 b 1f14 <rtems_bdpart_create+0xd0>
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
unsigned prev_sum = dist_sum;
dist_sum += dist [i];
1f00: e5b02004 ldr r2, [r0, #4]!
if (dist_sum < prev_sum) {
1f04: e0927007 adds r7, r2, r7
1f08: 2a000053 bcs 205c <rtems_bdpart_create+0x218>
return RTEMS_INVALID_NUMBER;
}
if (dist [i] == 0) {
1f0c: e3520000 cmp r2, #0
1f10: 0a000051 beq 205c <rtems_bdpart_create+0x218>
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
1f14: e2811001 add r1, r1, #1
1f18: e1510005 cmp r1, r5
1f1c: 1afffff7 bne 1f00 <rtems_bdpart_create+0xbc>
return RTEMS_INVALID_NUMBER;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
1f20: e5942000 ldr r2, [r4]
1f24: e3520000 cmp r2, #0
return RTEMS_NOT_IMPLEMENTED;
1f28: 13a09018 movne r9, #24
return RTEMS_INVALID_NUMBER;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
1f2c: 1affffda bne 1e9c <rtems_bdpart_create+0x58>
return RTEMS_NOT_IMPLEMENTED;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
1f30: e35a0000 cmp sl, #0
1f34: 1a00004a bne 2064 <rtems_bdpart_create+0x220>
1f38: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED
1f3c: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
/*
* In case we need an extended partition and logical partitions we have to
* account for the space of each EBR.
*/
if (count > 4) {
1f40: e3550004 cmp r5, #4
overhead += (count - 3) * record_space;
1f44: 82452003 subhi r2, r5, #3
1f48: 80228298 mlahi r2, r8, r2, r8
/*
* We need at least space for the MBR and the compatibility space for the
* first primary partition.
*/
overhead += record_space;
1f4c: 91a02008 movls r2, r8
/*
* Account space to align every partition on cylinder boundaries if
* necessary.
*/
if (dos_compatibility) {
1f50: e35a0000 cmp sl, #0
overhead += (count - 1) * record_space;
1f54: 12451001 subne r1, r5, #1
1f58: 10222891 mlane r2, r1, r8, r2
}
/* Check disk space */
if ((overhead + count) > disk_end) {
1f5c: e59d0010 ldr r0, [sp, #16]
1f60: e0821005 add r1, r2, r5
1f64: e1510000 cmp r1, r0
return RTEMS_IO_ERROR;
1f68: 83a0901b movhi r9, #27
if (dos_compatibility) {
overhead += (count - 1) * record_space;
}
/* Check disk space */
if ((overhead + count) > disk_end) {
1f6c: 8affffca bhi 1e9c <rtems_bdpart_create+0x58>
/* Begin of first primary partition */
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
1f70: e062a000 rsb sl, r2, r0
for (i = 0; i < count; ++i) {
rtems_bdpart_partition *p = pt + i;
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
1f74: e0000a9b mul r0, fp, sl
if (s < free_space || s < dist [i]) {
1f78: e15a0000 cmp sl, r0
1f7c: 8a000036 bhi 205c <rtems_bdpart_create+0x218>
1f80: e15b0000 cmp fp, r0
1f84: 8a000034 bhi 205c <rtems_bdpart_create+0x218>
1f88: e3550004 cmp r5, #4
1f8c: 93a02000 movls r2, #0
1f90: 83a02001 movhi r2, #1
#endif
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_create(
1f94: e286c030 add ip, r6, #48 ; 0x30
1f98: e58d9014 str r9, [sp, #20]
1f9c: e58d700c str r7, [sp, #12]
for (i = 0; i < count; ++i) {
rtems_bdpart_partition *p = pt + i;
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
if (s < free_space || s < dist [i]) {
1fa0: e58d2008 str r2, [sp, #8]
if ((overhead + count) > disk_end) {
return RTEMS_IO_ERROR;
}
/* Begin of first primary partition */
pos = record_space;
1fa4: e1a04008 mov r4, r8
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
1fa8: e3a0b000 mov fp, #0
1fac: e1a09003 mov r9, r3
1fb0: e1a0700c mov r7, ip
1fb4: e58d6018 str r6, [sp, #24]
1fb8: e58d5004 str r5, [sp, #4]
1fbc: ea000007 b 1fe0 <rtems_bdpart_create+0x19c>
rtems_bdpart_partition *p = pt + i;
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
1fc0: e5b93004 ldr r3, [r9, #4]!
1fc4: e000039a mul r0, sl, r3
if (s < free_space || s < dist [i]) {
1fc8: e15a0000 cmp sl, r0
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
rtems_bdpart_partition *p = pt + i;
1fcc: e1a06007 mov r6, r7
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
if (s < free_space || s < dist [i]) {
1fd0: 8a000021 bhi 205c <rtems_bdpart_create+0x218>
1fd4: e1530000 cmp r3, r0
1fd8: e2877030 add r7, r7, #48 ; 0x30
1fdc: 8a00001e bhi 205c <rtems_bdpart_create+0x218>
/* TODO: Calculate without overflow */
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
1fe0: e59d100c ldr r1, [sp, #12]
1fe4: eb007775 bl 1fdc0 <__aeabi_uidiv>
/* Ensure that the partition is not empty */
if (s == 0) {
s = 1;
1fe8: e3500000 cmp r0, #0
1fec: 11a05000 movne r5, r0
1ff0: 03a05001 moveq r5, #1
}
/* Align partition upwards */
s += record_space - (s % record_space);
1ff4: e1a00005 mov r0, r5
1ff8: e1a01008 mov r1, r8
1ffc: eb0077b5 bl 1fed8 <__umodsi3>
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
2000: e59d3008 ldr r3, [sp, #8]
2004: e35b0002 cmp fp, #2
2008: 93a03000 movls r3, #0
200c: 82033001 andhi r3, r3, #1
2010: e3530000 cmp r3, #0
if (s == 0) {
s = 1;
}
/* Align partition upwards */
s += record_space - (s % record_space);
2014: e0855008 add r5, r5, r8
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
2018: e59d3004 ldr r3, [sp, #4]
/* Align partition upwards */
s += record_space - (s % record_space);
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
pos += record_space;
201c: 10844008 addne r4, r4, r8
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
2020: e28bb001 add fp, fp, #1
if (s == 0) {
s = 1;
}
/* Align partition upwards */
s += record_space - (s % record_space);
2024: e0605005 rsb r5, r0, r5
if (count > 4 && i > 2) {
pos += record_space;
}
/* Partition begin and end */
p->begin = pos;
2028: e5864000 str r4, [r6]
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
202c: e153000b cmp r3, fp
pos += record_space;
}
/* Partition begin and end */
p->begin = pos;
pos += s;
2030: e0844005 add r4, r4, r5
p->end = pos;
2034: e5864004 str r4, [r6, #4]
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
2038: 8affffe0 bhi 1fc0 <rtems_bdpart_create+0x17c>
203c: e59d6018 ldr r6, [sp, #24]
pos += s;
p->end = pos;
}
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
2040: e2435001 sub r5, r3, #1
2044: e3a03030 mov r3, #48 ; 0x30
2048: e0266593 mla r6, r3, r5, r6
204c: e59d2010 ldr r2, [sp, #16]
2050: e59d9014 ldr r9, [sp, #20]
2054: e5862004 str r2, [r6, #4]
return RTEMS_SUCCESSFUL;
2058: eaffff8f b 1e9c <rtems_bdpart_create+0x58>
/* 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;
205c: e3a0900a mov r9, #10 <== NOT EXECUTED
2060: eaffff8d b 1e9c <rtems_bdpart_create+0x58> <== NOT EXECUTED
return RTEMS_NOT_IMPLEMENTED;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
disk_end -= (disk_end % record_space);
2064: e59d401c ldr r4, [sp, #28]
2068: e1a01008 mov r1, r8
206c: e1a00004 mov r0, r4
2070: e58d3000 str r3, [sp]
2074: eb007797 bl 1fed8 <__umodsi3>
2078: e0604004 rsb r4, r0, r4
207c: e58d4010 str r4, [sp, #16]
2080: e58d401c str r4, [sp, #28]
2084: e59d3000 ldr r3, [sp]
2088: eaffffac b 1f40 <rtems_bdpart_create+0xfc>
0000208c <rtems_bdpart_dump>:
{
uuid_unparse_lower( type, str);
}
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
208c: e92d40f0 push {r4, r5, r6, r7, lr}
2090: e1a06001 mov r6, r1
2094: e24dd038 sub sp, sp, #56 ; 0x38
2098: e1a04000 mov r4, r0
size_t i = 0;
printf(
209c: e59f00f4 ldr r0, [pc, #244] ; 2198 <rtems_bdpart_dump+0x10c>
20a0: eb0046e5 bl 13c3c <puts>
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
20a4: e3560000 cmp r6, #0
20a8: 0a00002a beq 2158 <rtems_bdpart_dump+0xcc>
20ac: e3a05000 mov r5, #0
20b0: ea000015 b 210c <rtems_bdpart_dump+0x80>
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) {
20b4: e5dd3037 ldrb r3, [sp, #55] ; 0x37
20b8: 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";
20bc: 059f30d8 ldreq r3, [pc, #216] ; 219c <rtems_bdpart_dump+0x110>
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) {
20c0: 0a00000a beq 20f0 <rtems_bdpart_dump+0x64>
20c4: 8a000027 bhi 2168 <rtems_bdpart_dump+0xdc> <== NOT EXECUTED
20c8: e3530001 cmp r3, #1 <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_12:
type = "FAT 12";
20cc: 059f30cc ldreq r3, [pc, #204] ; 21a0 <rtems_bdpart_dump+0x114><== 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) {
20d0: 0a000006 beq 20f0 <rtems_bdpart_dump+0x64> <== NOT EXECUTED
20d4: e3530004 cmp r3, #4 <== NOT EXECUTED
20d8: 0a00002c beq 2190 <rtems_bdpart_dump+0x104> <== NOT EXECUTED
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
20dc: e1a0000d mov r0, sp <== NOT EXECUTED
20e0: e3a01034 mov r1, #52 ; 0x34 <== NOT EXECUTED
20e4: e59f20b8 ldr r2, [pc, #184] ; 21a4 <rtems_bdpart_dump+0x118><== NOT EXECUTED
20e8: eb004771 bl 13eb4 <snprintf> <== NOT EXECUTED
type = type_buffer;
20ec: e1a0300d mov r3, sp <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
20f0: e8940006 ldm r4, {r1, r2}
20f4: e59f00ac ldr r0, [pc, #172] ; 21a8 <rtems_bdpart_dump+0x11c>
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
20f8: e2855001 add r5, r5, #1
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
20fc: eb004697 bl 13b60 <printf>
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
2100: e1550006 cmp r5, r6
2104: e2844030 add r4, r4, #48 ; 0x30
2108: 0a000012 beq 2158 <rtems_bdpart_dump+0xcc>
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)) {
210c: 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;
2110: e3a03000 mov r3, #0
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
2114: e1a00007 mov r0, r7
2118: 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;
211c: e5cd3037 strb r3, [sp, #55] ; 0x37
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
2120: eb000083 bl 2334 <rtems_bdpart_to_mbr_partition_type>
2124: e3500000 cmp r0, #0
2128: 1affffe1 bne 20b4 <rtems_bdpart_dump+0x28>
static void rtems_bdpart_type_to_string(
const uuid_t type,
char str [37]
)
{
uuid_unparse_lower( type, str);
212c: e1a00007 mov r0, r7 <== NOT EXECUTED
2130: e1a0100d mov r1, sp <== NOT EXECUTED
2134: eb002b02 bl cd44 <uuid_unparse_lower> <== NOT EXECUTED
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
2138: e2855001 add r5, r5, #1 <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
213c: e8940006 ldm r4, {r1, r2} <== NOT EXECUTED
type = type_buffer;
break;
}
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
2140: e1a0300d mov r3, sp <== NOT EXECUTED
}
printf(
2144: e59f005c ldr r0, [pc, #92] ; 21a8 <rtems_bdpart_dump+0x11c><== NOT EXECUTED
2148: eb004684 bl 13b60 <printf> <== NOT EXECUTED
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
214c: e1550006 cmp r5, r6 <== NOT EXECUTED
2150: e2844030 add r4, r4, #48 ; 0x30 <== NOT EXECUTED
2154: 1affffec bne 210c <rtems_bdpart_dump+0x80> <== NOT EXECUTED
p->end,
type
);
}
puts( "------------+------------+-----------------------------------------------------");
2158: e59f004c ldr r0, [pc, #76] ; 21ac <rtems_bdpart_dump+0x120>
215c: eb0046b6 bl 13c3c <puts>
}
2160: e28dd038 add sp, sp, #56 ; 0x38
2164: e8bd80f0 pop {r4, r5, r6, r7, pc}
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) {
2168: 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";
216c: 059f303c ldreq r3, [pc, #60] ; 21b0 <rtems_bdpart_dump+0x124><== 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) {
2170: 0affffde beq 20f0 <rtems_bdpart_dump+0x64> <== NOT EXECUTED
2174: 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";
2178: 059f3034 ldreq r3, [pc, #52] ; 21b4 <rtems_bdpart_dump+0x128><== 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) {
217c: 0affffdb beq 20f0 <rtems_bdpart_dump+0x64> <== NOT EXECUTED
2180: e353000c cmp r3, #12 <== NOT EXECUTED
2184: 1affffd4 bne 20dc <rtems_bdpart_dump+0x50> <== NOT EXECUTED
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
2188: e59f3028 ldr r3, [pc, #40] ; 21b8 <rtems_bdpart_dump+0x12c><== NOT EXECUTED
break;
218c: eaffffd7 b 20f0 <rtems_bdpart_dump+0x64> <== NOT EXECUTED
switch (type_mbr) {
case RTEMS_BDPART_MBR_FAT_12:
type = "FAT 12";
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
2190: e59f3024 ldr r3, [pc, #36] ; 21bc <rtems_bdpart_dump+0x130><== NOT EXECUTED
2194: eaffffd5 b 20f0 <rtems_bdpart_dump+0x64> <== NOT EXECUTED
0000235c <rtems_bdpart_get_disk_data>:
const char *disk_name,
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
235c: e92d40f0 push {r4, r5, r6, r7, lr}
2360: e1a05001 mov r5, r1
2364: e24dd004 sub sp, sp, #4
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);
2368: e3a01002 mov r1, #2
const char *disk_name,
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
236c: e1a07003 mov r7, r3
rtems_status_code sc = RTEMS_SUCCESSFUL; int rv = 0; int fd = -1; rtems_disk_device *dd = NULL;
2370: e3a03000 mov r3, #0
const char *disk_name,
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
2374: e1a04002 mov r4, r2
rtems_status_code sc = RTEMS_SUCCESSFUL; int rv = 0; int fd = -1; rtems_disk_device *dd = NULL;
2378: 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);
237c: eb000d02 bl 578c <open>
if (fd < 0) {
2380: e2506000 subs r6, r0, #0
2384: aa000005 bge 23a0 <rtems_bdpart_get_disk_data+0x44>
}
/* Get disk handle */
rv = rtems_disk_fd_get_disk_device( fd, &dd);
if (rv != 0) {
sc = RTEMS_INVALID_NAME;
2388: e3a05003 mov r5, #3 <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
*fd_ptr = fd;
*dd_ptr = dd;
} else {
close( fd);
238c: e1a00006 mov r0, r6
2390: eb0008ba bl 4680 <close>
}
return sc;
}
2394: e1a00005 mov r0, r5
2398: e28dd004 add sp, sp, #4
239c: e8bd80f0 pop {r4, r5, r6, r7, pc}
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
23a0: e59f105c ldr r1, [pc, #92] ; 2404 <rtems_bdpart_get_disk_data+0xa8>
23a4: e1a0200d mov r2, sp
23a8: eb0009d2 bl 4af8 <ioctl>
goto error;
}
/* Get disk handle */
rv = rtems_disk_fd_get_disk_device( fd, &dd);
if (rv != 0) {
23ac: e3500000 cmp r0, #0
23b0: 1afffff4 bne 2388 <rtems_bdpart_get_disk_data+0x2c>
sc = RTEMS_INVALID_NAME;
goto error;
}
/* Get disk begin, end and block size */
disk_begin = dd->start;
23b4: e59d3000 ldr r3, [sp]
*disk_end = dd->size;
23b8: e593101c ldr r1, [r3, #28]
sc = RTEMS_INVALID_NAME;
goto error;
}
/* Get disk begin, end and block size */
disk_begin = dd->start;
23bc: e5932018 ldr r2, [r3, #24]
*disk_end = dd->size;
23c0: e5871000 str r1, [r7]
block_size = dd->block_size;
/* Check block size */
if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
23c4: e5931024 ldr r1, [r3, #36] ; 0x24
23c8: e3510c02 cmp r1, #512 ; 0x200
23cc: 2a000001 bcs 23d8 <rtems_bdpart_get_disk_data+0x7c>
goto error;
}
/* Check that we have do not have a logical disk */
if (disk_begin != 0) {
sc = RTEMS_IO_ERROR;
23d0: e3a0501b mov r5, #27 <== NOT EXECUTED
23d4: eaffffec b 238c <rtems_bdpart_get_disk_data+0x30> <== NOT EXECUTED
sc = RTEMS_IO_ERROR;
goto error;
}
/* Check that we have do not have a logical disk */
if (disk_begin != 0) {
23d8: e3520000 cmp r2, #0
23dc: 1afffffb bne 23d0 <rtems_bdpart_get_disk_data+0x74>
goto error;
}
error:
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
23e0: e3550000 cmp r5, #0
23e4: 0affffe8 beq 238c <rtems_bdpart_get_disk_data+0x30>
23e8: e3540000 cmp r4, #0
*fd_ptr = fd;
23ec: 15856000 strne r6, [r5]
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
23f0: 11a05002 movne r5, r2
error:
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
*fd_ptr = fd;
*dd_ptr = dd;
23f4: 15843000 strne r3, [r4]
goto error;
}
error:
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
23f8: 1affffe5 bne 2394 <rtems_bdpart_get_disk_data+0x38>
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
23fc: e1a05004 mov r5, r4 <== NOT EXECUTED
2400: eaffffe1 b 238c <rtems_bdpart_get_disk_data+0x30> <== NOT EXECUTED
000209b4 <rtems_bdpart_mount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
209b4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL; const char *disk_file_name = strrchr( disk_name, '/');
209b8: 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
)
{
209bc: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 209c0: e1a08002 mov r8, r2 <== NOT EXECUTED 209c4: e1a09003 mov r9, r3 <== NOT EXECUTED 209c8: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL; const char *disk_file_name = strrchr( disk_name, '/');
209cc: eb007419 bl 3da38 <strrchr> <== NOT EXECUTED 209d0: e1a05000 mov r5, r0 <== NOT EXECUTED
char *logical_disk_name = NULL; char *logical_disk_marker = NULL; char *mount_point = NULL; char *mount_marker = NULL; size_t disk_file_name_size = 0; size_t disk_name_size = strlen( disk_name);
209d4: e1a00004 mov r0, r4 <== NOT EXECUTED 209d8: eb006ff8 bl 3c9c0 <strlen> <== NOT EXECUTED 209dc: e1a06000 mov r6, r0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
209e0: e1a00009 mov r0, r9 <== NOT EXECUTED 209e4: eb006ff5 bl 3c9c0 <strlen> <== NOT EXECUTED 209e8: e1a0a000 mov sl, r0 <== NOT EXECUTED
size_t i = 0;
/* Create logical disk name base */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
209ec: e2860004 add r0, r6, #4 <== NOT EXECUTED 209f0: ebff89bb bl 30e4 <malloc> <== NOT EXECUTED
if (logical_disk_name == NULL) {
209f4: e2507000 subs r7, r0, #0 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
209f8: 03a0801a moveq r8, #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) {
209fc: 0a000046 beq 20b1c <rtems_bdpart_mount+0x168> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
20a00: e1a01004 mov r1, r4 <== NOT EXECUTED 20a04: e1a02006 mov r2, r6 <== NOT EXECUTED 20a08: eb00708e bl 3cc48 <strncpy> <== NOT EXECUTED
/* Get disk file name */
if (disk_file_name != NULL) {
20a0c: e3550000 cmp r5, #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;
20a10: 058d6004 streq r6, [sp, #4] <== 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;
20a14: 01a0b004 moveq fp, 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) {
20a18: 0a000003 beq 20a2c <rtems_bdpart_mount+0x78> <== NOT EXECUTED
disk_file_name += 1;
20a1c: e285b001 add fp, r5, #1 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
20a20: e1a0000b mov r0, fp <== NOT EXECUTED 20a24: eb006fe5 bl 3c9c0 <strlen> <== NOT EXECUTED 20a28: e58d0004 str r0, [sp, #4] <== 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);
20a2c: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 20a30: e083400a add r4, r3, sl <== NOT EXECUTED 20a34: e2840005 add r0, r4, #5 <== NOT EXECUTED 20a38: ebff89a9 bl 30e4 <malloc> <== NOT EXECUTED
if (mount_point == NULL) {
20a3c: e2505000 subs r5, r0, #0 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
20a40: 03a0801a moveq r8, #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) {
20a44: 0a000030 beq 20b0c <rtems_bdpart_mount+0x158> <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
20a48: e1a0200a mov r2, sl <== NOT EXECUTED 20a4c: e1a01009 mov r1, r9 <== NOT EXECUTED 20a50: eb00707c bl 3cc48 <strncpy> <== NOT EXECUTED
mount_point [mount_base_size] = '/'; strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
20a54: e28a0001 add r0, sl, #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] = '/';
20a58: e3a0302f mov r3, #47 ; 0x2f <== NOT EXECUTED 20a5c: e7c5300a strb r3, [r5, sl] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
20a60: e0850000 add r0, r5, r0 <== NOT EXECUTED 20a64: e1a0100b mov r1, fp <== NOT EXECUTED 20a68: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 20a6c: eb007075 bl 3cc48 <strncpy> <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
20a70: e284a001 add sl, r4, #1 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
20a74: e3580000 cmp r8, #0 <== NOT EXECUTED
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
20a78: e0876006 add r6, r7, r6 <== NOT EXECUTED
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
20a7c: e085a00a add sl, r5, sl <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
20a80: 0a000021 beq 20b0c <rtems_bdpart_mount+0x158> <== NOT EXECUTED 20a84: e3a04000 mov r4, #0 <== NOT EXECUTED 20a88: ea000001 b 20a94 <rtems_bdpart_mount+0xe0> <== NOT EXECUTED 20a8c: e1540008 cmp r4, r8 <== NOT EXECUTED 20a90: 0a00001c beq 20b08 <rtems_bdpart_mount+0x154> <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
20a94: e2844001 add r4, r4, #1 <== NOT EXECUTED 20a98: e3a01004 mov r1, #4 <== NOT EXECUTED 20a9c: e59f2094 ldr r2, [pc, #148] ; 20b38 <rtems_bdpart_mount+0x184><== NOT EXECUTED 20aa0: e1a03004 mov r3, r4 <== NOT EXECUTED 20aa4: e1a00006 mov r0, r6 <== NOT EXECUTED 20aa8: eb006bdf bl 3ba2c <snprintf> <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
20aac: e3500003 cmp r0, #3 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
20ab0: e3a02004 mov r2, #4 <== NOT EXECUTED 20ab4: e1a01006 mov r1, r6 <== NOT EXECUTED 20ab8: e1a0000a mov r0, sl <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
20abc: ca000019 bgt 20b28 <rtems_bdpart_mount+0x174> <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
20ac0: eb007060 bl 3cc48 <strncpy> <== NOT EXECUTED
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
20ac4: e59f1070 ldr r1, [pc, #112] ; 20b3c <rtems_bdpart_mount+0x188><== NOT EXECUTED 20ac8: e1a00005 mov r0, r5 <== NOT EXECUTED 20acc: eb000ebb bl 245c0 <rtems_mkdir> <== NOT EXECUTED
if (rv != 0) {
20ad0: e250c000 subs ip, r0, #0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
20ad4: e1a01005 mov r1, r5 <== NOT EXECUTED 20ad8: e59f2060 ldr r2, [pc, #96] ; 20b40 <rtems_bdpart_mount+0x18c><== NOT EXECUTED 20adc: e1a0300c mov r3, ip <== NOT EXECUTED 20ae0: e1a00007 mov r0, r7 <== NOT EXECUTED
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv != 0) {
20ae4: 1a000011 bne 20b30 <rtems_bdpart_mount+0x17c> <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
20ae8: e58dc000 str ip, [sp] <== NOT EXECUTED 20aec: ebff89f3 bl 32c0 <mount> <== NOT EXECUTED
mount_point,
"msdos",
0,
NULL
);
if (rv != 0) {
20af0: e3500000 cmp r0, #0 <== NOT EXECUTED 20af4: 0affffe4 beq 20a8c <rtems_bdpart_mount+0xd8> <== NOT EXECUTED
rmdir( mount_point);
20af8: e1a00005 mov r0, r5 <== NOT EXECUTED 20afc: eb000e82 bl 2450c <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) {
20b00: e1540008 cmp r4, r8 <== NOT EXECUTED 20b04: 1affffe2 bne 20a94 <rtems_bdpart_mount+0xe0> <== NOT EXECUTED
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
rtems_status_code esc = RTEMS_SUCCESSFUL;
20b08: e3a08000 mov r8, #0 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
20b0c: e1a00007 mov r0, r7 <== NOT EXECUTED 20b10: ebff88a5 bl 2dac <free> <== NOT EXECUTED
free( mount_point);
20b14: e1a00005 mov r0, r5 <== NOT EXECUTED 20b18: ebff88a3 bl 2dac <free> <== NOT EXECUTED
return esc;
}
20b1c: e1a00008 mov r0, r8 <== NOT EXECUTED
20b20: e28dd008 add sp, sp, #8 <== NOT EXECUTED
20b24: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== 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;
20b28: e3a08003 mov r8, #3 <== NOT EXECUTED 20b2c: eafffff6 b 20b0c <rtems_bdpart_mount+0x158> <== 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;
20b30: e3a0801b mov r8, #27 <== NOT EXECUTED 20b34: eafffff4 b 20b0c <rtems_bdpart_mount+0x158> <== NOT EXECUTED
00002408 <rtems_bdpart_read>:
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
2408: e92d45f0 push {r4, r5, r6, r7, r8, sl, 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);
240c: e2536000 subs r6, r3, #0
2410: 15967000 ldrne r7, [r6]
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
2414: e24dd018 sub sp, sp, #24
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_status_code esc = RTEMS_SUCCESSFUL; rtems_bdbuf_buffer *block = NULL;
2418: e3a03000 mov r3, #0
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
241c: e1a04002 mov r4, r2
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);
2420: 10877087 addne r7, r7, r7, lsl #1
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
rtems_bdpart_partition *p = pt - 1;
2424: e2422030 sub r2, r2, #48 ; 0x30
size_t *count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
2428: e58d3000 str r3, [sp]
rtems_bdpart_partition *p = pt - 1; const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0); rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */
242c: e3a03000 mov 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;
2430: e58d2004 str r2, [sp, #4]
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
2434: 11a07207 lslne r7, r7, #4
2438: 01a07006 moveq r7, r6
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;
243c: e3e02000 mvn r2, #0
rtems_disk_device *dd = NULL;
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
2440: e1510003 cmp r1, r3
2444: 11540003 cmpne r4, r3
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
2448: e1a05001 mov r5, 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); rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */
244c: e58d3008 str r3, [sp, #8]
const uint8_t *data = NULL;
int fd = -1;
rtems_disk_device *dd = NULL;
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
2450: 13a01000 movne r1, #0
2454: 03a01001 moveq r1, #1
rtems_bdbuf_buffer *block = NULL; rtems_bdpart_partition *p = pt - 1; const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0); rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */ rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */ rtems_blkdev_bnum disk_end = 0;
2458: e58d300c str r3, [sp, #12]
size_t i = 0; const uint8_t *data = NULL; int fd = -1;
245c: e58d2010 str r2, [sp, #16]
rtems_disk_device *dd = NULL;
2460: e58d3014 str r3, [sp, #20]
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
2464: 1a000003 bne 2478 <rtems_bdpart_read+0x70>
return RTEMS_INVALID_ADDRESS;
2468: e3a01009 mov r1, #9 <== NOT EXECUTED
if (block != NULL) {
rtems_bdbuf_release( block);
}
return esc;
}
246c: e1a00001 mov r0, r1
2470: e28dd018 add sp, sp, #24
2474: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
const uint8_t *data = NULL;
int fd = -1;
rtems_disk_device *dd = NULL;
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
2478: e1560003 cmp r6, r3
247c: 0afffff9 beq 2468 <rtems_bdpart_read+0x60>
return RTEMS_INVALID_ADDRESS;
}
/* Set count to a save value */
*count = 0;
2480: e5861000 str r1, [r6]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2484: e28d2014 add r2, sp, #20
2488: e28d1010 add r1, sp, #16
248c: e28d300c add r3, sp, #12
2490: ebffffb1 bl 235c <rtems_bdpart_get_disk_data>
if (sc != RTEMS_SUCCESSFUL) {
2494: e2501000 subs r1, r0, #0
2498: 1afffff3 bne 246c <rtems_bdpart_read+0x64>
return sc;
}
/* Read MBR */
sc = rtems_bdpart_read_record( dd, 0, &block);
249c: e59d0014 ldr r0, [sp, #20]
24a0: e1a0200d mov r2, sp
24a4: ebffff45 bl 21c0 <rtems_bdpart_read_record>
if (sc != RTEMS_SUCCESSFUL) {
24a8: e2503000 subs r3, r0, #0
24ac: 0a00000a beq 24dc <rtems_bdpart_read+0xd4>
ebr = ep_begin;
while (ebr != 0) {
rtems_blkdev_bnum tmp = 0;
/* Read EBR */
sc = rtems_bdpart_read_record( dd, ebr, &block);
24b0: e1a04003 mov r4, r3 <== NOT EXECUTED
/* Return partition count */
*count = (size_t) (p - pt + 1);
cleanup:
if (fd >= 0) {
24b4: e59d0010 ldr r0, [sp, #16]
24b8: e3500000 cmp r0, #0
close( fd);
24bc: ab00086f blge 4680 <close>
}
if (block != NULL) {
24c0: e59d0000 ldr r0, [sp]
24c4: e3500000 cmp r0, #0
rtems_bdbuf_release( block);
}
return esc;
24c8: 01a01004 moveq r1, r4
if (fd >= 0) {
close( fd);
}
if (block != NULL) {
24cc: 0affffe6 beq 246c <rtems_bdpart_read+0x64>
rtems_bdbuf_release( block);
24d0: eb00327a bl eec0 <rtems_bdbuf_release>
}
return esc;
24d4: e1a01004 mov r1, r4
24d8: eaffffe3 b 246c <rtems_bdpart_read+0x64>
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
24dc: e59d3000 ldr r3, [sp]
24e0: e593a01c ldr sl, [r3, #28]
24e4: e28a8f6f add r8, sl, #444 ; 0x1bc
24e8: e2888002 add r8, r8, #2
{
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);
24ec: e0847007 add r7, r4, r7
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
24f0: e28d3008 add r3, sp, #8
24f4: e1a00008 mov r0, r8
24f8: e28d1004 add r1, sp, #4
24fc: e1a02007 mov r2, r7
2500: ebffff55 bl 225c <rtems_bdpart_read_mbr_partition>
if (sc != RTEMS_SUCCESSFUL) {
2504: e2503000 subs r3, r0, #0
2508: 1affffe8 bne 24b0 <rtems_bdpart_read+0xa8>
if (block != NULL) {
rtems_bdbuf_release( block);
}
return esc;
}
250c: 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) {
2510: e5d22008 ldrb r2, [r2, #8]
2514: e35200ee cmp r2, #238 ; 0xee
esc = RTEMS_NOT_IMPLEMENTED;
2518: 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) {
251c: 0affffe4 beq 24b4 <rtems_bdpart_read+0xac>
}
/* 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
2520: e59d2000 ldr r2, [sp]
esc = RTEMS_NOT_IMPLEMENTED;
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
2524: e5853000 str r3, [r5]
format->mbr.disk_id = rtems_uint32_from_little_endian(
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
2528: e592001c ldr r0, [r2, #28]
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
252c: e2802f6f add r2, r0, #444 ; 0x1bc
2530: e2800f6e add r0, r0, #440 ; 0x1b8
value = (value << 8) + data [i];
2534: e5721001 ldrb r1, [r2, #-1]!
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
2538: e1520000 cmp r2, r0
value = (value << 8) + data [i];
253c: e0813403 add r3, r1, r3, lsl #8
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
2540: 1afffffb bne 2534 <rtems_bdpart_read+0x12c>
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
format->mbr.disk_id = rtems_uint32_from_little_endian(
2544: e5853004 str r3, [r5, #4]
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
2548: 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;
254c: e3a03001 mov r3, #1
2550: e5c53008 strb r3, [r5, #8]
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
2554: e28a5002 add r5, sl, #2
);
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;
2558: e2888010 add r8, r8, #16
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
255c: e1a00008 mov r0, r8
2560: e28d1004 add r1, sp, #4
2564: e1a02007 mov r2, r7
2568: e28d3008 add r3, sp, #8
256c: ebffff3a bl 225c <rtems_bdpart_read_mbr_partition>
if (sc != RTEMS_SUCCESSFUL) {
2570: e3500000 cmp r0, #0
2574: 1a00003f bne 2678 <rtems_bdpart_read+0x270>
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) {
2578: e1580005 cmp r8, r5
257c: 1afffff5 bne 2558 <rtems_bdpart_read+0x150>
goto cleanup;
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
2580: e59d5008 ldr r5, [sp, #8]
while (ebr != 0) {
2584: e3550000 cmp r5, #0
2588: 059d1004 ldreq r1, [sp, #4]
258c: 0a000026 beq 262c <rtems_bdpart_read+0x224>
rtems_blkdev_bnum tmp = 0;
/* Read EBR */
sc = rtems_bdpart_read_record( dd, ebr, &block);
2590: e59d0014 ldr r0, [sp, #20]
2594: e1a01005 mov r1, r5
2598: e1a0200d mov r2, sp
259c: ebffff07 bl 21c0 <rtems_bdpart_read_record>
if (sc != RTEMS_SUCCESSFUL) {
25a0: e2503000 subs r3, r0, #0
25a4: 1affffc1 bne 24b0 <rtems_bdpart_read+0xa8>
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
25a8: e59d2000 ldr r2, [sp]
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
25ac: e592001c ldr r0, [r2, #28]
25b0: e2800f6f add r0, r0, #444 ; 0x1bc
25b4: e2800002 add r0, r0, #2
25b8: e28d1004 add r1, sp, #4
25bc: e1a02007 mov r2, r7
25c0: ebffff25 bl 225c <rtems_bdpart_read_mbr_partition>
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
&p,
p_end,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
25c4: e3500000 cmp r0, #0
25c8: 1a00002a bne 2678 <rtems_bdpart_read+0x270>
esc = sc;
goto cleanup;
}
/* Adjust partition begin */
tmp = p->begin + ebr;
25cc: e59d1004 ldr r1, [sp, #4]
25d0: e5913000 ldr r3, [r1]
25d4: e0852003 add r2, r5, r3
if (tmp > p->begin) {
25d8: e1530002 cmp r3, r2
25dc: 2a000023 bcs 2670 <rtems_bdpart_read+0x268>
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Adjust partition end */
tmp = p->end + ebr;
25e0: e5913004 ldr r3, [r1, #4]
25e4: e0855003 add r5, r5, r3
if (tmp > p->end) {
25e8: e1530005 cmp r3, r5
}
/* Adjust partition begin */
tmp = p->begin + ebr;
if (tmp > p->begin) {
p->begin = tmp;
25ec: e5812000 str r2, [r1]
goto cleanup;
}
/* Adjust partition end */
tmp = p->end + ebr;
if (tmp > p->end) {
25f0: 2a00001e bcs 2670 <rtems_bdpart_read+0x268>
goto cleanup;
}
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
25f4: e59d3000 ldr r3, [sp]
25f8: e593801c ldr r8, [r3, #28]
}
/* Adjust partition end */
tmp = p->end + ebr;
if (tmp > p->end) {
p->end = tmp;
25fc: e5815004 str r5, [r1, #4]
}
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);
2600: e288cf75 add ip, r8, #468 ; 0x1d4
2604: e28cc002 add ip, ip, #2
2608: e3a03003 mov r3, #3
value = (value << 8) + data [i];
260c: e7dc2003 ldrb r2, [ip, r3]
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
2610: e2433001 sub r3, r3, #1
2614: e3730001 cmn r3, #1
value = (value << 8) + data [i];
2618: e0820400 add r0, r2, r0, lsl #8
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
261c: 1afffffa bne 260c <rtems_bdpart_read+0x204>
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EXTENDED) {
2620: e5d831d2 ldrb r3, [r8, #466] ; 0x1d2
2624: e3530005 cmp r3, #5
2628: 0a00000a beq 2658 <rtems_bdpart_read+0x250>
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
262c: e0643001 rsb r3, r4, r1
2630: e1a03243 asr r3, r3, #4
2634: e0832103 add r2, r3, r3, lsl #2
2638: e0822202 add r2, r2, r2, lsl #4
263c: e0822402 add r2, r2, r2, lsl #8
2640: e0822802 add r2, r2, r2, lsl #16
2644: e0833082 add r3, r3, r2, lsl #1
2648: e2833001 add r3, r3, #1
264c: e5863000 str r3, [r6]
rtems_bdpart_partition *pt,
size_t *count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
2650: e3a04000 mov r4, #0
2654: eaffff96 b 24b4 <rtems_bdpart_read+0xac>
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
);
if (ebr != 0) {
2658: e3500000 cmp r0, #0
265c: 0afffff2 beq 262c <rtems_bdpart_read+0x224>
/* Adjust partition EBR block index */
tmp = ebr + ep_begin;
2660: e59d5008 ldr r5, [sp, #8]
2664: e0805005 add r5, r0, r5
if (tmp > ebr) {
2668: e1550000 cmp r5, r0
266c: 8affffc7 bhi 2590 <rtems_bdpart_read+0x188>
/* Adjust partition end */
tmp = p->end + ebr;
if (tmp > p->end) {
p->end = tmp;
} else {
esc = RTEMS_IO_ERROR;
2670: e3a0401b mov r4, #27 <== NOT EXECUTED
2674: eaffff8e b 24b4 <rtems_bdpart_read+0xac> <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
2678: e1a04000 mov r4, r0 <== NOT EXECUTED
267c: eaffff8c b 24b4 <rtems_bdpart_read+0xac> <== NOT EXECUTED
0000225c <rtems_bdpart_read_mbr_partition>:
} else {
return 0;
}
}
static rtems_status_code rtems_bdpart_read_mbr_partition(
225c: e280c00c add ip, r0, #12
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
2260: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
2264: e1a05001 mov r5, r1
2268: e1a04000 mov r4, r0
} else {
return 0;
}
}
static rtems_status_code rtems_bdpart_read_mbr_partition(
226c: e1a0100c mov r1, ip
2270: e2807008 add r7, r0, #8
return value;
}
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
2274: e3a06000 mov r6, #0
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
value = (value << 8) + data [i];
2278: e5710001 ldrb r0, [r1, #-1]!
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
227c: e1510007 cmp r1, r7
value = (value << 8) + data [i];
2280: e0806406 add r6, r0, r6, lsl #8
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
2284: 1afffffb bne 2278 <rtems_bdpart_read_mbr_partition+0x1c>
2288: e2841010 add r1, r4, #16
return value;
}
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
228c: e3a08000 mov r8, #0
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
value = (value << 8) + data [i];
2290: e571a001 ldrb sl, [r1, #-1]!
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
2294: e151000c cmp r1, ip
value = (value << 8) + data [i];
2298: e08a8408 add r8, sl, r8, lsl #8
static inline uint32_t rtems_uint32_from_little_endian( const uint8_t *data)
{
uint32_t value = 0;
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
229c: 1afffffb bne 2290 <rtems_bdpart_read_mbr_partition+0x34>
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;
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
22a0: e5d47004 ldrb r7, [r4, #4]
if (type == RTEMS_BDPART_MBR_EMPTY) {
22a4: e3570000 cmp r7, #0
return RTEMS_SUCCESSFUL;
22a8: 01a00007 moveq r0, r7
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) {
22ac: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
22b0: e5950000 ldr r0, [r5]
22b4: e1500002 cmp r0, r2
return RTEMS_TOO_MANY;
22b8: 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) {
22bc: 08bd85f0 popeq {r4, r5, r6, r7, r8, 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;
22c0: e0888006 add r8, r8, r6
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
return RTEMS_TOO_MANY;
} else if (begin >= end) {
22c4: e1580006 cmp r8, r6
return RTEMS_IO_ERROR;
22c8: 93a0001b movls r0, #27
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
return RTEMS_TOO_MANY;
} else if (begin >= end) {
22cc: 98bd85f0 popls {r4, r5, r6, r7, r8, sl, pc}
return RTEMS_IO_ERROR;
} else if (type == RTEMS_BDPART_MBR_EXTENDED) {
22d0: e3570005 cmp r7, #5
22d4: 1a000005 bne 22f0 <rtems_bdpart_read_mbr_partition+0x94>
if (ep_begin != NULL) {
22d8: e3530000 cmp r3, #0
*ep_begin = begin;
22dc: 15836000 strne r6, [r3]
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
}
return RTEMS_SUCCESSFUL;
22e0: 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) {
22e4: 18bd85f0 popne {r4, r5, r6, r7, r8, sl, pc}
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
}
return RTEMS_SUCCESSFUL;
22e8: e1a00003 mov r0, r3 <== NOT EXECUTED
}
22ec: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
if (ep_begin != NULL) {
*ep_begin = begin;
}
} else {
/* Increment partition index */
++(*p);
22f0: e2800030 add r0, r0, #48 ; 0x30
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
22f4: e3a02030 mov r2, #48 ; 0x30
22f8: e3a01000 mov r1, #0
if (ep_begin != NULL) {
*ep_begin = begin;
}
} else {
/* Increment partition index */
++(*p);
22fc: e5850000 str r0, [r5]
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
2300: eb0045cd bl 13a3c <memset>
/* Set values */
(*p)->begin = begin;
2304: e5951000 ldr r1, [r5]
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
2308: e1a00007 mov r0, r7
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
/* Set values */
(*p)->begin = begin;
(*p)->end = end;
230c: e8810140 stm r1, {r6, r8}
rtems_bdpart_to_partition_type( type, (*p)->type);
2310: e2811008 add r1, r1, #8
2314: ebffffc9 bl 2240 <rtems_bdpart_to_partition_type>
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
2318: e5d42000 ldrb r2, [r4]
231c: e5953000 ldr r3, [r5]
2320: e5832028 str r2, [r3, #40] ; 0x28
2324: e3a02000 mov r2, #0
2328: e583202c str r2, [r3, #44] ; 0x2c
}
return RTEMS_SUCCESSFUL;
232c: e1a00002 mov r0, r2
2330: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
000021c0 <rtems_bdpart_read_record>:
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
21c0: e5923000 ldr r3, [r2]
21c4: e3530000 cmp r3, #0
static rtems_status_code rtems_bdpart_read_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
21c8: e92d4070 push {r4, r5, r6, lr}
21cc: e1a04002 mov r4, r2
21d0: e1a05000 mov r5, r0
21d4: e1a06001 mov r6, r1
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
21d8: 0a000003 beq 21ec <rtems_bdpart_read_record+0x2c>
sc = rtems_bdbuf_release( *block);
21dc: e1a00003 mov r0, r3
21e0: eb003336 bl eec0 <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL) {
21e4: e3500000 cmp r0, #0
21e8: 18bd8070 popne {r4, r5, r6, pc}
return sc;
}
}
/* Read the record block */
sc = rtems_bdbuf_read( dd, index, block);
21ec: e1a00005 mov r0, r5
21f0: e1a01006 mov r1, r6
21f4: e1a02004 mov r2, r4
21f8: eb0032b7 bl ecdc <rtems_bdbuf_read>
if (sc != RTEMS_SUCCESSFUL) {
21fc: e3500000 cmp r0, #0
2200: 18bd8070 popne {r4, r5, r6, pc}
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
2204: e5943000 ldr r3, [r4]
2208: e3530000 cmp r3, #0
220c: 0a000009 beq 2238 <rtems_bdpart_read_record+0x78>
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
2210: 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]
2214: e5d321fe ldrb r2, [r3, #510] ; 0x1fe
2218: e3520055 cmp r2, #85 ; 0x55
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
221c: 13a0001b movne r0, #27
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]
2220: 18bd8070 popne {r4, r5, r6, pc}
2224: e5d301ff ldrb r0, [r3, #511] ; 0x1ff
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
2228: e35000aa cmp r0, #170 ; 0xaa
222c: 13a0001b movne r0, #27
2230: 03a00000 moveq r0, #0
2234: e8bd8070 pop {r4, r5, r6, pc}
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
return RTEMS_INVALID_ADDRESS;
2238: e3a00009 mov r0, #9 <== NOT EXECUTED
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
223c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00002680 <rtems_bdpart_register>:
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
2680: 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;
2684: e3a04000 mov r4, #0
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
2688: e24dd01c sub sp, sp, #28
268c: e1a05000 mov r5, r0
2690: e58d100c str r1, [sp, #12]
2694: e1a08002 mov r8, r2
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;
2698: 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);
269c: eb0048fe bl 14a9c <strlen>
size_t i = 0; int fd = -1;
26a0: e3e0c000 mvn ip, #0
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);
26a4: e1a0b000 mov fp, 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);
26a8: e28d1014 add r1, sp, #20
26ac: e1a00005 mov r0, r5
26b0: e28d2018 add r2, sp, #24
26b4: 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;
26b8: e58d4018 str r4, [sp, #24]
dev_t logical_disk = 0; 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;
26bc: e58dc014 str ip, [sp, #20]
rtems_disk_device *dd = NULL;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
26c0: ebffff25 bl 235c <rtems_bdpart_get_disk_data>
if (sc != RTEMS_SUCCESSFUL) {
26c4: e2504000 subs r4, r0, #0
26c8: 0a000002 beq 26d8 <rtems_bdpart_register+0x58>
cleanup:
free( logical_disk_name);
return esc;
}
26cc: e1a00004 mov r0, r4
26d0: e28dd01c add sp, sp, #28
26d4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
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);
26d8: e28d0014 add r0, sp, #20
26dc: e8900009 ldm r0, {r0, r3}
static inline dev_t rtems_disk_get_device_identifier(
const rtems_disk_device *dd
)
{
return dd->dev;
26e0: e8930480 ldm r3, {r7, sl}
26e4: eb0007e5 bl 4680 <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);
26e8: e28b0004 add r0, fp, #4
26ec: eb000a0b bl 4f20 <malloc>
if (logical_disk_name == NULL) {
26f0: e2509000 subs r9, r0, #0
)
{
union __rtems_dev_t temp;
temp.device = device;
return temp.__overlay.minor;
26f4: e1a0600a mov r6, sl
return RTEMS_NO_MEMORY;
26f8: 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) {
26fc: 0afffff2 beq 26cc <rtems_bdpart_register+0x4c>
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
2700: e1a0200b mov r2, fp
2704: e1a01005 mov r1, r5
2708: eb00494b bl 14c3c <strncpy>
logical_disk_marker = logical_disk_name + disk_name_size;
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
270c: e3580000 cmp r8, #0
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
if (logical_disk_name == NULL) {
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
logical_disk_marker = logical_disk_name + disk_name_size;
2710: e089b00b add fp, r9, fp
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
2714: 01a04008 moveq r4, r8
}
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) {
2718: 0a00001b beq 278c <rtems_bdpart_register+0x10c>
271c: e59d500c ldr r5, [sp, #12]
2720: ea00000b b 2754 <rtems_bdpart_register+0xd4>
/* Create logical disk */
sc = rtems_disk_create_log(
logical_disk,
disk,
p->begin,
p->end - p->begin,
2724: e595c000 ldr ip, [r5]
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
2728: e58dc000 str ip, [sp]
272c: e595e004 ldr lr, [r5, #4]
2730: e06cc00e rsb ip, ip, lr
2734: e58dc004 str ip, [sp, #4]
2738: e58d9008 str r9, [sp, #8]
273c: eb00035c bl 34b4 <rtems_disk_create_log>
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
2740: e3500000 cmp r0, #0
2744: 1a000013 bne 2798 <rtems_bdpart_register+0x118>
}
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) {
2748: e1540008 cmp r4, r8
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
274c: e2855030 add r5, r5, #48 ; 0x30
}
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) {
2750: 0a000010 beq 2798 <rtems_bdpart_register+0x118>
/* 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);
2754: e2844001 add r4, r4, #1
2758: e3a01004 mov r1, #4
275c: e59f2044 ldr r2, [pc, #68] ; 27a8 <rtems_bdpart_register+0x128>
2760: e1a03004 mov r3, r4
2764: e1a0000b mov r0, fp
2768: eb0045d1 bl 13eb4 <snprintf>
for (i = 0; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
int rv = 0;
/* New minor number */
++minor;
276c: e2866001 add r6, r6, #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) {
2770: e3500003 cmp r0, #3
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
2774: e1a02007 mov r2, r7
2778: e1a0300a mov r3, sl
277c: e1a00007 mov r0, r7
2780: e1a01006 mov r1, r6
/* 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) {
2784: daffffe6 ble 2724 <rtems_bdpart_register+0xa4>
esc = RTEMS_INVALID_NAME;
2788: e3a04003 mov r4, #3 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
278c: e1a00009 mov r0, r9 <== NOT EXECUTED
2790: eb000863 bl 4924 <free> <== NOT EXECUTED
return esc;
2794: eaffffcc b 26cc <rtems_bdpart_register+0x4c> <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
2798: e1a04000 mov r4, r0
}
}
cleanup:
free( logical_disk_name);
279c: e1a00009 mov r0, r9
27a0: eb00085f bl 4924 <free>
27a4: eaffffc8 b 26cc <rtems_bdpart_register+0x4c>
00020b44 <rtems_bdpart_unmount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
20b44: 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, '/');
20b48: 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
)
{
20b4c: e1a09003 mov r9, r3 <== NOT EXECUTED 20b50: e1a06002 mov r6, r2 <== NOT EXECUTED 20b54: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL; const char *disk_file_name = strrchr( disk_name, '/');
20b58: eb0073b6 bl 3da38 <strrchr> <== NOT EXECUTED 20b5c: e1a05000 mov r5, r0 <== NOT EXECUTED
char *mount_point = NULL; char *mount_marker = NULL; size_t disk_file_name_size = 0; size_t disk_name_size = strlen( disk_name);
20b60: e1a00004 mov r0, r4 <== NOT EXECUTED 20b64: eb006f95 bl 3c9c0 <strlen> <== NOT EXECUTED 20b68: e1a0a000 mov sl, r0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
20b6c: e1a00009 mov r0, r9 <== NOT EXECUTED 20b70: eb006f92 bl 3c9c0 <strlen> <== NOT EXECUTED
size_t i = 0;
/* Get disk file name */
if (disk_file_name != NULL) {
20b74: e3550000 cmp r5, #0 <== NOT EXECUTED
const char *disk_file_name = strrchr( disk_name, '/'); char *mount_point = NULL; char *mount_marker = NULL; size_t disk_file_name_size = 0; size_t disk_name_size = strlen( disk_name); size_t mount_base_size = strlen( mount_base);
20b78: e1a08000 mov r8, r0 <== NOT EXECUTED
size_t i = 0;
/* Get disk file name */
if (disk_file_name != NULL) {
20b7c: 0a000003 beq 20b90 <rtems_bdpart_unmount+0x4c> <== NOT EXECUTED
disk_file_name += 1;
20b80: e2854001 add r4, r5, #1 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
20b84: e1a00004 mov r0, r4 <== NOT EXECUTED 20b88: eb006f8c bl 3c9c0 <strlen> <== NOT EXECUTED 20b8c: e1a0a000 mov sl, r0 <== NOT EXECUTED
disk_file_name = disk_name;
disk_file_name_size = disk_name_size;
}
/* Create mount point base */
mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);
20b90: e08a7008 add r7, sl, r8 <== NOT EXECUTED 20b94: e2870005 add r0, r7, #5 <== NOT EXECUTED 20b98: ebff8951 bl 30e4 <malloc> <== NOT EXECUTED
if (mount_point == NULL) {
20b9c: e2505000 subs r5, r0, #0 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
20ba0: 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) {
20ba4: 0a000022 beq 20c34 <rtems_bdpart_unmount+0xf0> <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
20ba8: e1a01009 mov r1, r9 <== NOT EXECUTED 20bac: e1a02008 mov r2, r8 <== NOT EXECUTED 20bb0: eb007024 bl 3cc48 <strncpy> <== NOT EXECUTED
mount_point [mount_base_size] = '/';
20bb4: e3a0302f mov r3, #47 ; 0x2f <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
20bb8: e2880001 add r0, r8, #1 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
20bbc: e7c53008 strb r3, [r5, r8] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
20bc0: e0850000 add r0, r5, r0 <== NOT EXECUTED 20bc4: e1a01004 mov r1, r4 <== NOT EXECUTED 20bc8: e1a0200a mov r2, sl <== NOT EXECUTED 20bcc: eb00701d bl 3cc48 <strncpy> <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
20bd0: e2877001 add r7, r7, #1 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
20bd4: e3560000 cmp r6, #0 <== NOT EXECUTED
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
20bd8: e0857007 add r7, r5, r7 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
20bdc: 0a000014 beq 20c34 <rtems_bdpart_unmount+0xf0> <== NOT EXECUTED 20be0: e3a04000 mov r4, #0 <== NOT EXECUTED 20be4: ea000001 b 20bf0 <rtems_bdpart_unmount+0xac> <== NOT EXECUTED 20be8: e1540006 cmp r4, r6 <== NOT EXECUTED 20bec: 0a000019 beq 20c58 <rtems_bdpart_unmount+0x114> <== NOT EXECUTED
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
20bf0: e2844001 add r4, r4, #1 <== NOT EXECUTED 20bf4: e3a01004 mov r1, #4 <== NOT EXECUTED 20bf8: e59f206c ldr r2, [pc, #108] ; 20c6c <rtems_bdpart_unmount+0x128><== NOT EXECUTED 20bfc: e1a03004 mov r3, r4 <== NOT EXECUTED 20c00: e1a00007 mov r0, r7 <== NOT EXECUTED 20c04: eb006b88 bl 3ba2c <snprintf> <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
20c08: e3500003 cmp r0, #3 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
20c0c: e1a00005 mov r0, r5 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
20c10: ca00000b bgt 20c44 <rtems_bdpart_unmount+0x100> <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
20c14: eb000fe0 bl 24b9c <unmount> <== NOT EXECUTED
if (rv == 0) {
20c18: e3500000 cmp r0, #0 <== NOT EXECUTED 20c1c: 1afffff1 bne 20be8 <rtems_bdpart_unmount+0xa4> <== NOT EXECUTED
/* Remove mount point */
rv = rmdir( mount_point);
20c20: e1a00005 mov r0, r5 <== NOT EXECUTED 20c24: eb000e38 bl 2450c <rmdir> <== NOT EXECUTED
if (rv != 0) {
20c28: e3500000 cmp r0, #0 <== NOT EXECUTED 20c2c: 0affffed beq 20be8 <rtems_bdpart_unmount+0xa4> <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
20c30: e3a0601b mov r6, #27 <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
20c34: e1a00005 mov r0, r5 <== NOT EXECUTED 20c38: ebff885b bl 2dac <free> <== NOT EXECUTED
return esc;
}
20c3c: e1a00006 mov r0, r6 <== NOT EXECUTED
20c40: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
20c44: e1a00005 mov r0, r5 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
esc = RTEMS_INVALID_NAME;
20c48: e3a06003 mov r6, #3 <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
20c4c: ebff8856 bl 2dac <free> <== NOT EXECUTED
return esc;
}
20c50: e1a00006 mov r0, r6 <== NOT EXECUTED
20c54: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
20c58: e1a00005 mov r0, r5 <== NOT EXECUTED
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
rtems_status_code esc = RTEMS_SUCCESSFUL;
20c5c: e3a06000 mov r6, #0 <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
20c60: ebff8851 bl 2dac <free> <== NOT EXECUTED
return esc;
}
20c64: e1a00006 mov r0, r6 <== NOT EXECUTED
20c68: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
000027ec <rtems_bdpart_unregister>:
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count
)
{
27ec: e92d40f0 push {r4, r5, r6, r7, lr}
27f0: e24dd00c sub sp, sp, #12
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_device_major_number major = 0; rtems_device_minor_number minor = 0; rtems_blkdev_bnum disk_end = 0;
27f4: e3a0c000 mov ip, #0
dev_t disk = 0; dev_t logical_disk = 0; size_t i = 0; int fd = -1;
27f8: e3e0e000 mvn lr, #0
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count
)
{
27fc: e1a04002 mov r4, r2
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);
2800: e28d1004 add r1, sp, #4
2804: e28d2008 add r2, sp, #8
2808: e1a0300d mov r3, sp
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_blkdev_bnum disk_end = 0;
280c: e58dc000 str ip, [sp]
dev_t disk = 0; dev_t logical_disk = 0; size_t i = 0; int fd = -1;
2810: e58de004 str lr, [sp, #4]
rtems_disk_device *dd = NULL;
2814: e58dc008 str ip, [sp, #8]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2818: ebfffecf bl 235c <rtems_bdpart_get_disk_data>
if (sc != RTEMS_SUCCESSFUL) {
281c: e2507000 subs r7, r0, #0
2820: 0a000002 beq 2830 <rtems_bdpart_unregister+0x44>
return sc;
}
}
return RTEMS_SUCCESSFUL;
}
2824: e1a00007 mov r0, r7
2828: e28dd00c add sp, sp, #12
282c: e8bd80f0 pop {r4, r5, r6, r7, pc}
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);
2830: e99d0009 ldmib sp, {r0, r3}
2834: e5935004 ldr r5, [r3, #4]
2838: e5936000 ldr r6, [r3]
283c: eb00078f bl 4680 <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) {
2840: e3540000 cmp r4, #0
2844: 0afffff6 beq 2824 <rtems_bdpart_unregister+0x38>
/* Register partitions */
return rtems_bdpart_register( disk_name, pt, count);
}
rtems_status_code rtems_bdpart_unregister(
2848: e0844005 add r4, r4, r5
284c: ea000001 b 2858 <rtems_bdpart_unregister+0x6c>
/* 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) {
2850: e1550004 cmp r5, r4
2854: 0afffff2 beq 2824 <rtems_bdpart_unregister+0x38>
/* New minor number */
++minor;
2858: e2855001 add r5, r5, #1
/* Get the device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Delete logical disk */
sc = rtems_disk_delete( logical_disk);
285c: e1a00006 mov r0, r6
2860: e1a01005 mov r1, r5
2864: eb0002a4 bl 32fc <rtems_disk_delete>
if (sc != RTEMS_SUCCESSFUL) {
2868: e2507000 subs r7, r0, #0
286c: 0afffff7 beq 2850 <rtems_bdpart_unregister+0x64>
2870: eaffffeb b 2824 <rtems_bdpart_unregister+0x38> <== NOT EXECUTED
00002900 <rtems_bdpart_write>:
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
2900: 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;
2904: e2515000 subs r5, r1, #0
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
2908: e24dd018 sub sp, sp, #24
290c: e1a06002 mov r6, r2
2910: e1a04003 mov r4, 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;
2914: 0a000002 beq 2924 <rtems_bdpart_write+0x24>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
2918: e5953000 ldr r3, [r5]
291c: e3530000 cmp r3, #0
2920: 0a00000f beq 2964 <rtems_bdpart_write+0x64>
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;
2924: e3e03000 mvn r3, #0 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
2928: e3a07000 mov r7, #0 <== NOT EXECUTED
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;
292c: e58d300c str r3, [sp, #12] <== NOT EXECUTED
rtems_disk_device *dd = NULL;
/* Check if we have something to do */
if (count == 0) {
2930: e3540000 cmp r4, #0 <== NOT EXECUTED
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;
rtems_disk_device *dd = NULL;
2934: e3a03000 mov r3, #0 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
2938: e58d7004 str r7, [sp, #4] <== NOT EXECUTED
rtems_blkdev_bnum disk_end = 0;
293c: e58d7008 str r7, [sp, #8] <== NOT EXECUTED
rtems_blkdev_bnum record_space =
2940: e3a08001 mov r8, #1 <== NOT EXECUTED
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;
rtems_disk_device *dd = NULL;
2944: e58d3010 str r3, [sp, #16] <== NOT EXECUTED
/* Check if we have something to do */
if (count == 0) {
2948: 0a000012 beq 2998 <rtems_bdpart_write+0x98> <== NOT EXECUTED
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
294c: e1550003 cmp r5, r3
2950: 11560003 cmpne r6, r3
return RTEMS_INVALID_ADDRESS;
2954: 03a00009 moveq r0, #9
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
2958: 1a000010 bne 29a0 <rtems_bdpart_write+0xa0>
if (block != NULL) {
rtems_bdbuf_sync( block);
}
return esc;
}
295c: e28dd018 add sp, sp, #24
2960: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
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;
2964: e5d52008 ldrb r2, [r5, #8]
2968: e3520000 cmp r2, #0
296c: 0affffec beq 2924 <rtems_bdpart_write+0x24>
rtems_bdbuf_buffer *block = NULL;
2970: e58d3004 str r3, [sp, #4]
rtems_blkdev_bnum disk_end = 0;
2974: e58d3008 str r3, [sp, #8]
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;
2978: e3e03000 mvn r3, #0
297c: e58d300c str r3, [sp, #12]
rtems_disk_device *dd = NULL;
/* Check if we have something to do */
if (count == 0) {
2980: e3540000 cmp r4, #0
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;
rtems_disk_device *dd = NULL;
2984: e3a03000 mov r3, #0
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
2988: e3a07001 mov r7, #1
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
298c: e3a0803f mov r8, #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;
rtems_disk_device *dd = NULL;
2990: e58d3010 str r3, [sp, #16]
/* Check if we have something to do */
if (count == 0) {
2994: 1affffec bne 294c <rtems_bdpart_write+0x4c>
if (block != NULL) {
rtems_bdbuf_sync( block);
}
return esc;
2998: e1a00004 mov r0, r4 <== NOT EXECUTED
299c: eaffffee b 295c <rtems_bdpart_write+0x5c> <== NOT EXECUTED
if (format == NULL || pt == NULL) {
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
29a0: e28d100c add r1, sp, #12
29a4: e28d2010 add r2, sp, #16
29a8: e28d3008 add r3, sp, #8
29ac: ebfffe6a bl 235c <rtems_bdpart_get_disk_data>
if (sc != RTEMS_SUCCESSFUL) {
29b0: e3500000 cmp r0, #0
29b4: 1affffe8 bne 295c <rtems_bdpart_write+0x5c>
return sc;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
29b8: e3570000 cmp r7, #0
29bc: 059d0008 ldreq r0, [sp, #8]
29c0: 0a000005 beq 29dc <rtems_bdpart_write+0xdc>
disk_end -= (disk_end % record_space);
29c4: e59da008 ldr sl, [sp, #8]
29c8: e1a01008 mov r1, r8
29cc: e1a0000a mov r0, sl
29d0: eb007540 bl 1fed8 <__umodsi3>
29d4: e060000a rsb r0, r0, sl
29d8: e58d0008 str r0, [sp, #8]
/* 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) {
29dc: e596c000 ldr ip, [r6]
29e0: e15c0000 cmp ip, r0
29e4: 2a000019 bcs 2a50 <rtems_bdpart_write+0x150>
29e8: e5963004 ldr r3, [r6, #4]
29ec: e1500003 cmp r0, r3
29f0: 3a000016 bcc 2a50 <rtems_bdpart_write+0x150>
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that begin and end are valid */
if (p->begin >= p->end) {
29f4: e15c0003 cmp ip, r3
29f8: 31a09006 movcc r9, r6
29fc: 31a03006 movcc r3, r6
if (dos_compatibility) {
disk_end -= (disk_end % record_space);
}
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
2a00: 33a0b000 movcc fp, #0
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that begin and end are valid */
if (p->begin >= p->end) {
2a04: 2a000011 bcs 2a50 <rtems_bdpart_write+0x150>
if (dos_compatibility) {
disk_end -= (disk_end % record_space);
}
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
2a08: e28bb001 add fp, fp, #1
2a0c: e15b0004 cmp fp, r4
2a10: 0a000018 beq 2a78 <rtems_bdpart_write+0x178>
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) {
2a14: e5932030 ldr r2, [r3, #48] ; 0x30
2a18: e1520000 cmp r2, r0
2a1c: 2a00000b bcs 2a50 <rtems_bdpart_write+0x150>
2a20: e5931034 ldr r1, [r3, #52] ; 0x34
2a24: e1510000 cmp r1, r0
2a28: 8a000008 bhi 2a50 <rtems_bdpart_write+0x150>
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that begin and end are valid */
if (p->begin >= p->end) {
2a2c: e1520001 cmp r2, r1
2a30: 2a000006 bcs 2a50 <rtems_bdpart_write+0x150>
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that partitions do not overlap */
if (i > 0 && pt [i - 1].end > p->begin) {
2a34: e35b0000 cmp fp, #0
2a38: 0a000002 beq 2a48 <rtems_bdpart_write+0x148>
2a3c: e5931004 ldr r1, [r3, #4]
2a40: e1520001 cmp r2, r1
2a44: 3a000001 bcc 2a50 <rtems_bdpart_write+0x150>
2a48: e2833030 add r3, r3, #48 ; 0x30
2a4c: eaffffed b 2a08 <rtems_bdpart_write+0x108>
* 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;
2a50: e3a0400a mov r4, #10 <== NOT EXECUTED
}
}
cleanup:
if (fd >= 0) {
2a54: e59d000c ldr r0, [sp, #12]
2a58: e3500000 cmp r0, #0
close( fd);
2a5c: ab000707 blge 4680 <close>
}
if (block != NULL) {
2a60: e59d0004 ldr r0, [sp, #4]
2a64: e3500000 cmp r0, #0
2a68: 0affffca beq 2998 <rtems_bdpart_write+0x98>
rtems_bdbuf_sync( block);
2a6c: eb00315d bl efe8 <rtems_bdbuf_sync>
}
return esc;
2a70: e1a00004 mov r0, r4
2a74: eaffffb8 b 295c <rtems_bdpart_write+0x5c>
goto cleanup;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
2a78: e5953000 ldr r3, [r5]
2a7c: e3530000 cmp r3, #0
esc = RTEMS_NOT_IMPLEMENTED;
2a80: 13a04018 movne r4, #24
goto cleanup;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
2a84: 1afffff2 bne 2a54 <rtems_bdpart_write+0x154>
* 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;
2a88: e35b0004 cmp fp, #4
2a8c: 83a0b003 movhi fp, #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) {
2a90: e3570000 cmp r7, #0
2a94: 0a000001 beq 2aa0 <rtems_bdpart_write+0x1a0>
2a98: e35c003f cmp ip, #63 ; 0x3f
2a9c: 1affffeb bne 2a50 <rtems_bdpart_write+0x150>
* 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) {
2aa0: e15b0004 cmp fp, r4
2aa4: 2a000016 bcs 2b04 <rtems_bdpart_write+0x204>
if ((pt [i].begin - pt [i - 1].end) < record_space) {
2aa8: e24b2001 sub r2, fp, #1
2aac: e08b308b add r3, fp, fp, lsl #1
2ab0: e0822082 add r2, r2, r2, lsl #1
2ab4: e1a03203 lsl r3, r3, #4
2ab8: e0862202 add r2, r6, r2, lsl #4
2abc: e7961003 ldr r1, [r6, r3]
2ac0: e5922004 ldr r2, [r2, #4]
2ac4: e0622001 rsb r2, r2, r1
2ac8: e1580002 cmp r8, r2
2acc: e0862003 add r2, r6, r3
2ad0: 91a0300b movls r3, fp
2ad4: 9a000006 bls 2af4 <rtems_bdpart_write+0x1f4>
2ad8: eaffffdc b 2a50 <rtems_bdpart_write+0x150> <== NOT EXECUTED
2adc: e5910030 ldr r0, [r1, #48] ; 0x30
2ae0: e5911004 ldr r1, [r1, #4]
2ae4: e0611000 rsb r1, r1, r0
2ae8: e1580001 cmp r8, r1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2aec: 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) {
2af0: 8affffd6 bhi 2a50 <rtems_bdpart_write+0x150>
* 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) {
2af4: e2833001 add r3, r3, #1
2af8: e1540003 cmp r4, r3
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2afc: e1a01002 mov r1, r2
* 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) {
2b00: 8afffff5 bhi 2adc <rtems_bdpart_write+0x1dc>
2b04: e28d3017 add r3, sp, #23
esc = RTEMS_INVALID_ID;
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
2b08: e58d8000 str r8, [sp]
* 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) {
2b0c: e1a07006 mov r7, r6
esc = RTEMS_INVALID_ID;
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
2b10: e1a08005 mov r8, r5
* 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) {
2b14: e3a0a000 mov sl, #0
esc = RTEMS_INVALID_ID;
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
2b18: e1a05003 mov r5, r3
2b1c: ea000009 b 2b48 <rtems_bdpart_write+0x248>
2b20: e2873028 add r3, r7, #40 ; 0x28
2b24: e893000c ldm r3, {r2, r3}
2b28: e3a000ff mov r0, #255 ; 0xff
2b2c: e3a01000 mov r1, #0
2b30: e1510003 cmp r1, r3
2b34: 01500002 cmpeq r0, r2
2b38: 3a00000a bcc 2b68 <rtems_bdpart_write+0x268>
goto cleanup;
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
2b3c: e15a0004 cmp sl, r4
2b40: e2877030 add r7, r7, #48 ; 0x30
2b44: 0a000009 beq 2b70 <rtems_bdpart_write+0x270>
uint8_t type = 0;
2b48: e3a02000 mov r2, #0
const rtems_bdpart_partition *p = pt + i;
/* Check type */
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
2b4c: e2870008 add r0, r7, #8
2b50: e1a01005 mov r1, r5
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
uint8_t type = 0;
2b54: e5cd2017 strb r2, [sp, #23]
const rtems_bdpart_partition *p = pt + i;
/* Check type */
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
2b58: ebfffdf5 bl 2334 <rtems_bdpart_to_mbr_partition_type>
2b5c: e3500000 cmp r0, #0
goto cleanup;
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
2b60: e28aa001 add sl, sl, #1
uint8_t type = 0;
const rtems_bdpart_partition *p = pt + i;
/* Check type */
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
2b64: 1affffed bne 2b20 <rtems_bdpart_write+0x220>
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
esc = RTEMS_INVALID_ID;
2b68: e3a04004 mov r4, #4 <== NOT EXECUTED
2b6c: eaffffb8 b 2a54 <rtems_bdpart_write+0x154> <== NOT EXECUTED
/* Check ID */
/* TODO */
}
/* New MBR */
sc = rtems_bdpart_new_record( dd, 0, &block);
2b70: e59d0010 ldr r0, [sp, #16]
2b74: e3a01000 mov r1, #0
2b78: e28d2004 add r2, sp, #4
2b7c: e1a05008 mov r5, r8
2b80: e59d8000 ldr r8, [sp]
2b84: ebffff3a bl 2874 <rtems_bdpart_new_record>
if (sc != RTEMS_SUCCESSFUL) {
2b88: e3500000 cmp r0, #0
2b8c: 1a00008d bne 2dc8 <rtems_bdpart_write+0x4c8>
}
/* Write disk ID */
rtems_uint32_to_little_endian(
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
2b90: e59d3004 ldr r3, [sp, #4]
2b94: e593101c ldr r1, [r3, #28]
esc = sc;
goto cleanup;
}
/* Write disk ID */
rtems_uint32_to_little_endian(
2b98: e5952004 ldr r2, [r5, #4]
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2b9c: e2813f6d add r3, r1, #436 ; 0x1b4
2ba0: e2811f6e add r1, r1, #440 ; 0x1b8
2ba4: e2833003 add r3, r3, #3
2ba8: e2811003 add r1, r1, #3
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
data [i] = (uint8_t) value;
2bac: e5e32001 strb r2, [r3, #1]!
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2bb0: e1530001 cmp r3, r1
data [i] = (uint8_t) value;
value >>= 8;
2bb4: 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) {
2bb8: 1afffffb bne 2bac <rtems_bdpart_write+0x2ac>
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;
2bbc: e59d3004 ldr r3, [sp, #4]
2bc0: e593301c ldr r3, [r3, #28]
2bc4: e2832f6f add r2, r3, #444 ; 0x1bc
2bc8: e2822002 add r2, r2, #2
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2bcc: e2833f72 add r3, r3, #456 ; 0x1c8
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;
2bd0: e58d2000 str r2, [sp]
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2bd4: e2831001 add r1, r3, #1
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;
2bd8: e1a00002 mov r0, r2
for (i = 0; i < ppc; ++i) {
2bdc: e3a0c000 mov ip, #0
2be0: e1a0a008 mov sl, r8
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
data,
p->begin,
p->end - p->begin,
2be4: e5993000 ldr r3, [r9]
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
for (i = 0; i < ppc; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
2be8: e5992004 ldr r2, [r9, #4]
if (block != NULL) {
rtems_bdbuf_sync( block);
}
return esc;
}
2bec: e5d97008 ldrb r7, [r9, #8]
rtems_bdpart_write_mbr_partition(
data,
p->begin,
p->end - p->begin,
rtems_bdpart_mbr_partition_type( p->type),
(uint8_t) p->flags
2bf0: e5d95028 ldrb r5, [r9, #40] ; 0x28
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
for (i = 0; i < ppc; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
2bf4: e0632002 rsb r2, r3, r2
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2bf8: e2808007 add r8, r0, #7
data [i] = (uint8_t) value;
2bfc: e5e83001 strb r3, [r8, #1]!
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2c00: e1580001 cmp r8, r1
data [i] = (uint8_t) value;
value >>= 8;
2c04: e1a03423 lsr r3, r3, #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) {
2c08: 1afffffb bne 2bfc <rtems_bdpart_write+0x2fc>
2c0c: e280800f add r8, r0, #15
2c10: e1a03001 mov r3, r1
data [i] = (uint8_t) value;
2c14: e5e32001 strb r2, [r3, #1]!
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2c18: e1530008 cmp r3, r8
data [i] = (uint8_t) value;
value >>= 8;
2c1c: 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) {
2c20: 1afffffb bne 2c14 <rtems_bdpart_write+0x314>
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) {
2c24: e28cc001 add ip, ip, #1
2c28: e15c000b cmp ip, fp
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
2c2c: e5c07004 strb r7, [r0, #4]
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) {
2c30: e2899030 add r9, r9, #48 ; 0x30
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
2c34: e541500b strb r5, [r1, #-11]
p->end - p->begin,
rtems_bdpart_mbr_partition_type( p->type),
(uint8_t) p->flags
);
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
2c38: e2800010 add r0, r0, #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) {
2c3c: e2811010 add r1, r1, #16
2c40: 1affffe7 bne 2be4 <rtems_bdpart_write+0x2e4>
2c44: e59d1000 ldr r1, [sp]
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2c48: e1a0720b lsl r7, fp, #4
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
}
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
2c4c: e15b0004 cmp fp, r4
2c50: e1a0800a mov r8, 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) {
2c54: e0813007 add r3, r1, r7
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
}
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
2c58: 0a00005c beq 2dd0 <rtems_bdpart_write+0x4d0>
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
/* Begin of extended partition */
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
2c5c: e3a05030 mov r5, #48 ; 0x30
2c60: e005059b mul r5, fp, r5
2c64: e796a005 ldr sl, [r6, r5]
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
2c68: e59d1008 ldr r1, [sp, #8]
/* 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;
2c6c: e068a00a rsb sl, r8, sl
2c70: e0865005 add r5, r6, r5
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
2c74: e06a1001 rsb r1, sl, r1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2c78: e2832007 add r2, r3, #7
2c7c: e283c00b add ip, r3, #11
2c80: e1a0000a mov r0, sl
data [i] = (uint8_t) value;
2c84: e5e20001 strb r0, [r2, #1]!
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2c88: e152000c cmp r2, ip
data [i] = (uint8_t) value;
value >>= 8;
2c8c: e1a00420 lsr r0, r0, #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) {
2c90: 1afffffb bne 2c84 <rtems_bdpart_write+0x384>
2c94: e283000f add r0, r3, #15
data [i] = (uint8_t) value;
2c98: e5e21001 strb r1, [r2, #1]!
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2c9c: e1520000 cmp r2, r0
data [i] = (uint8_t) value;
value >>= 8;
2ca0: e1a01421 lsr r1, r1, #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) {
2ca4: 1afffffb bne 2c98 <rtems_bdpart_write+0x398>
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
2ca8: e3a02005 mov r2, #5
2cac: e5c32004 strb r2, [r3, #4]
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
2cb0: e59d3000 ldr r3, [sp]
2cb4: e3a00000 mov r0, #0
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
2cb8: e15b0004 cmp fp, r4
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
2cbc: e7c30007 strb r0, [r3, r7]
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
2cc0: 2a000040 bcs 2dc8 <rtems_bdpart_write+0x4c8>
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2cc4: e28b3001 add r3, fp, #1
2cc8: e3a01030 mov r1, #48 ; 0x30
2ccc: e0266391 mla r6, r1, r3, r6
2cd0: e1a0700b mov r7, fp
2cd4: e1a09000 mov r9, r0
0
);
}
/* New EBR */
ebr = p->begin - record_space;
2cd8: e5951000 ldr r1, [r5]
sc = rtems_bdpart_new_record( dd, ebr, &block);
2cdc: e59d0010 ldr r0, [sp, #16]
2ce0: e0681001 rsb r1, r8, r1
2ce4: e28d2004 add r2, sp, #4
2ce8: ebfffee1 bl 2874 <rtems_bdpart_new_record>
if (sc != RTEMS_SUCCESSFUL) {
2cec: e3500000 cmp r0, #0
2cf0: 1a000034 bne 2dc8 <rtems_bdpart_write+0x4c8>
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
2cf4: e59d3004 ldr r3, [sp, #4]
2cf8: e593201c ldr r2, [r3, #28]
if (block != NULL) {
rtems_bdbuf_sync( block);
}
return esc;
}
2cfc: e5d5c008 ldrb ip, [r5, #8]
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
2d00: e895000a ldm r5, {r1, r3}
2d04: e0433001 sub r3, r3, r1
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
record_space,
p->end - p->begin,
rtems_bdpart_mbr_partition_type( p->type),
(uint8_t) p->flags
2d08: e5d55028 ldrb r5, [r5, #40] ; 0x28
uint8_t type,
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
2d0c: e2821f72 add r1, r2, #456 ; 0x1c8
data [i] = (uint8_t) value;
2d10: e5c281c6 strb r8, [r2, #454] ; 0x1c6
2d14: e5c201c7 strb r0, [r2, #455] ; 0x1c7
2d18: e5c201c8 strb r0, [r2, #456] ; 0x1c8
2d1c: e5c201c9 strb r0, [r2, #457] ; 0x1c9
2d20: e2811002 add r1, r1, #2
2d24: e7c13000 strb r3, [r1, r0]
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2d28: e2800001 add r0, r0, #1
2d2c: e3500004 cmp r0, #4
data [i] = (uint8_t) value;
value >>= 8;
2d30: e1a03423 lsr r3, r3, #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) {
2d34: 1afffffa bne 2d24 <rtems_bdpart_write+0x424>
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
2d38: e2877001 add r7, r7, #1
2d3c: e1540007 cmp r4, r7
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
2d40: e5c2c1c2 strb ip, [r2, #450] ; 0x1c2
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
2d44: e5c251be strb r5, [r2, #446] ; 0x1be
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
2d48: 9a000020 bls 2dd0 <rtems_bdpart_write+0x4d0>
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
2d4c: e15b0007 cmp fp, r7
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
2d50: e1a05006 mov r5, r6
/* Write second partition entry */
if (i > ppc) {
2d54: 2a000019 bcs 2dc0 <rtems_bdpart_write+0x4c0>
rtems_blkdev_bnum begin = p->begin - record_space;
rtems_bdpart_write_mbr_partition(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,
2d58: e59d2004 ldr r2, [sp, #4]
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;
2d5c: e5963000 ldr r3, [r6]
rtems_bdpart_write_mbr_partition(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,
2d60: e592001c ldr r0, [r2, #28]
/* Write second partition entry */
if (i > ppc) {
rtems_blkdev_bnum begin = p->begin - record_space;
rtems_bdpart_write_mbr_partition(
2d64: e59d2008 ldr r2, [sp, #8]
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;
2d68: e0683003 rsb r3, r8, r3
uint32_t size,
uint8_t type,
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
2d6c: e280cf75 add ip, r0, #468 ; 0x1d4
/* Write second partition entry */
if (i > ppc) {
rtems_blkdev_bnum begin = p->begin - record_space;
rtems_bdpart_write_mbr_partition(
2d70: e06a1003 rsb r1, sl, r3
2d74: e0632002 rsb r2, r3, r2
uint32_t size,
uint8_t type,
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
2d78: e28cc002 add ip, ip, #2
2d7c: e3a03000 mov r3, #0
data [i] = (uint8_t) value;
2d80: e7cc1003 strb r1, [ip, r3]
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2d84: e2833001 add r3, r3, #1
2d88: e3530004 cmp r3, #4
data [i] = (uint8_t) value;
value >>= 8;
2d8c: e1a01421 lsr r1, r1, #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) {
2d90: 1afffffa bne 2d80 <rtems_bdpart_write+0x480>
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
2d94: e2801f76 add r1, r0, #472 ; 0x1d8
2d98: e2811002 add r1, r1, #2
2d9c: e3a03000 mov r3, #0
data [i] = (uint8_t) value;
2da0: e7c12003 strb r2, [r1, r3]
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2da4: e2833001 add r3, r3, #1
2da8: e3530004 cmp r3, #4
data [i] = (uint8_t) value;
value >>= 8;
2dac: 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) {
2db0: 1afffffa bne 2da0 <rtems_bdpart_write+0x4a0>
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
2db4: e3a01005 mov r1, #5
2db8: e5c011d2 strb r1, [r0, #466] ; 0x1d2
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
2dbc: e5c091ce strb r9, [r0, #462] ; 0x1ce
2dc0: e2866030 add r6, r6, #48 ; 0x30
2dc4: eaffffc3 b 2cd8 <rtems_bdpart_write+0x3d8>
);
}
/* New EBR */
ebr = p->begin - record_space;
sc = rtems_bdpart_new_record( dd, ebr, &block);
2dc8: e1a04000 mov r4, r0 <== NOT EXECUTED
2dcc: eaffff20 b 2a54 <rtems_bdpart_write+0x154> <== NOT EXECUTED
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
2dd0: e3a04000 mov r4, #0
2dd4: eaffff1e b 2a54 <rtems_bdpart_write+0x154>
0000e0d8 <rtems_blkdev_generic_read>:
rtems_device_driver
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
e0d8: e92d4ff0 push {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;
e0dc: e5923000 ldr r3, [r2]
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
e0e0: e5924010 ldr r4, [r2, #16]
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;
e0e4: e593b02c ldr fp, [r3, #44] ; 0x2c
rtems_device_driver
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
e0e8: e1a05002 mov r5, r2
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);
args->bytes_moved = 0;
e0ec: e3a08000 mov r8, #0
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
e0f0: e592600c ldr r6, [r2, #12]
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
e0f4: e992000c ldmib r2, {r2, r3}
rtems_device_driver
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
e0f8: e24dd00c sub sp, sp, #12
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)
e0fc: e1540008 cmp r4, r8
{
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;
e100: e59b9024 ldr r9, [fp, #36] ; 0x24
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
e104: e88d000c stm sp, {r2, r3}
uint32_t blkofs = (uint32_t) (args->offset % block_size);
args->bytes_moved = 0;
e108: e5858018 str r8, [r5, #24]
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
e10c: 01a03004 moveq r3, r4
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)
e110: 0a000026 beq e1b0 <rtems_blkdev_generic_read+0xd8>
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);
e114: e1a00002 mov r0, r2
e118: e1a01003 mov r1, r3
e11c: e1a02009 mov r2, r9
e120: e1a03008 mov r3, r8
e124: eb0035a9 bl 1b7d0 <__divdi3>
uint32_t blkofs = (uint32_t) (args->offset % block_size);
e128: e1a02009 mov r2, r9
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);
e12c: e1a07000 mov r7, r0
uint32_t blkofs = (uint32_t) (args->offset % block_size);
e130: e1a03008 mov r3, r8
e134: e89d0003 ldm sp, {r0, r1}
e138: eb0036df bl 1bcbc <__moddi3>
e13c: e1a0a000 mov sl, r0
e140: ea000012 b e190 <rtems_blkdev_generic_read+0xb8>
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
e144: e59d3008 ldr r3, [sp, #8]
e148: e593101c ldr r1, [r3, #28]
uint32_t copy;
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
e14c: e1580004 cmp r8, r4
e150: 21a08004 movcs r8, r4
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
e154: e1a02008 mov r2, r8
e158: e081100a add r1, r1, sl
e15c: eb00112c bl 12614 <memcpy>
rc = rtems_bdbuf_release(diskbuf);
e160: e59d0008 ldr r0, [sp, #8]
e164: ebfffe06 bl d984 <rtems_bdbuf_release>
args->bytes_moved += copy;
e168: e5952018 ldr r2, [r5, #24]
if (rc != RTEMS_SUCCESSFUL)
e16c: e2503000 subs r3, r0, #0
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
rc = rtems_bdbuf_release(diskbuf);
args->bytes_moved += copy;
e170: e0822008 add r2, r2, r8
e174: e5852018 str r2, [r5, #24]
if (rc != RTEMS_SUCCESSFUL)
e178: 1a00000c bne e1b0 <rtems_blkdev_generic_read+0xd8>
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)
e17c: e0544008 subs r4, r4, r8
rc = rtems_bdbuf_release(diskbuf);
args->bytes_moved += copy;
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
e180: e0866008 add r6, r6, r8
blkofs = 0;
block++;
e184: e2877001 add r7, r7, #1
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)
e188: 0a000008 beq e1b0 <rtems_blkdev_generic_read+0xd8>
args->bytes_moved += copy;
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
blkofs = 0;
e18c: e1a0a003 mov sl, r3 <== NOT EXECUTED
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dd, block, &diskbuf);
e190: e1a01007 mov r1, r7
e194: e28d2008 add r2, sp, #8
e198: e1a0000b mov r0, fp
e19c: ebfffd7f bl d7a0 <rtems_bdbuf_read>
if (rc != RTEMS_SUCCESSFUL)
e1a0: e2503000 subs r3, r0, #0
break;
copy = block_size - blkofs;
e1a4: e06a8009 rsb r8, sl, r9
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
e1a8: e1a00006 mov r0, r6
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
e1ac: 0affffe4 beq e144 <rtems_blkdev_generic_read+0x6c>
blkofs = 0;
block++;
}
return rc;
}
e1b0: e1a00003 mov r0, r3
e1b4: e28dd00c add sp, sp, #12
e1b8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000e1bc <rtems_blkdev_generic_write>:
rtems_device_driver
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
e1bc: e92d4ff0 push {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;
e1c0: e5923000 ldr r3, [r2]
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
e1c4: e5924010 ldr r4, [r2, #16]
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;
e1c8: e593b02c ldr fp, [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)
{
e1cc: e1a05002 mov r5, r2
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);
args->bytes_moved = 0;
e1d0: e3a08000 mov r8, #0
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
e1d4: e592600c ldr r6, [r2, #12]
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
e1d8: e992000c ldmib r2, {r2, r3}
rtems_device_driver
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
e1dc: e24dd00c sub sp, sp, #12
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)
e1e0: e1540008 cmp r4, r8
{
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;
e1e4: e59b9024 ldr r9, [fp, #36] ; 0x24
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
e1e8: e88d000c stm sp, {r2, r3}
uint32_t blkofs = (uint32_t) (args->offset % block_size);
args->bytes_moved = 0;
e1ec: e5858018 str r8, [r5, #24]
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
e1f0: 01a00004 moveq r0, r4
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)
e1f4: 0a000031 beq e2c0 <rtems_blkdev_generic_write+0x104>
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);
e1f8: e1a00002 mov r0, r2
e1fc: e1a01003 mov r1, r3
e200: e1a02009 mov r2, r9
e204: e1a03008 mov r3, r8
e208: eb003570 bl 1b7d0 <__divdi3>
uint32_t blkofs = (uint32_t) (args->offset % block_size);
e20c: e1a02009 mov r2, r9
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);
e210: e1a07000 mov r7, r0
uint32_t blkofs = (uint32_t) (args->offset % block_size);
e214: e1a03008 mov r3, r8
e218: e89d0003 ldm sp, {r0, r1}
e21c: eb0036a6 bl 1bcbc <__moddi3>
e220: e1a0a000 mov sl, r0
e224: ea00001a b e294 <rtems_blkdev_generic_write+0xd8>
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dd, block, &diskbuf);
e228: e1a01007 mov r1, r7
e22c: e1a0000b mov r0, fp
e230: e28d2008 add r2, sp, #8
e234: ebfffd1b bl d6a8 <rtems_bdbuf_get>
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
e238: e3500000 cmp r0, #0
break;
copy = block_size - blkofs;
e23c: e06a8009 rsb r8, sl, r9
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
e240: e1a01006 mov r1, r6
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dd, block, &diskbuf);
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
e244: 1a00001d bne e2c0 <rtems_blkdev_generic_write+0x104>
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
e248: e59d3008 ldr r3, [sp, #8]
e24c: e593001c ldr r0, [r3, #28]
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
e250: e1580004 cmp r8, r4
e254: 21a08004 movcs r8, r4
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
e258: e1a02008 mov r2, r8
e25c: e080000a add r0, r0, sl
e260: eb0010eb bl 12614 <memcpy>
args->bytes_moved += copy;
e264: e5953018 ldr r3, [r5, #24]
e268: e0833008 add r3, r3, r8
e26c: e5853018 str r3, [r5, #24]
rc = rtems_bdbuf_release_modified(diskbuf);
e270: e59d0008 ldr r0, [sp, #8]
e274: ebfffdf3 bl da48 <rtems_bdbuf_release_modified>
if (rc != RTEMS_SUCCESSFUL)
e278: e3500000 cmp r0, #0
e27c: 1a00000f bne e2c0 <rtems_blkdev_generic_write+0x104>
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)
e280: e0544008 subs r4, r4, r8
rc = rtems_bdbuf_release_modified(diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
e284: e0866008 add r6, r6, r8
blkofs = 0;
block++;
e288: e2877001 add r7, r7, #1
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)
e28c: 0a00000b beq e2c0 <rtems_blkdev_generic_write+0x104>
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
blkofs = 0;
e290: e1a0a000 mov sl, r0 <== NOT EXECUTED
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
e294: e1540009 cmp r4, r9
e298: 235a0000 cmpcs sl, #0
e29c: 0affffe1 beq e228 <rtems_blkdev_generic_write+0x6c>
rc = rtems_bdbuf_get(dd, block, &diskbuf);
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
e2a0: e1a01007 mov r1, r7 <== NOT EXECUTED
e2a4: e28d2008 add r2, sp, #8 <== NOT EXECUTED
e2a8: e1a0000b mov r0, fp <== NOT EXECUTED
e2ac: ebfffd3b bl d7a0 <rtems_bdbuf_read> <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
e2b0: e3500000 cmp r0, #0 <== NOT EXECUTED
break;
copy = block_size - blkofs;
e2b4: e06a8009 rsb r8, sl, r9 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
e2b8: e1a01006 mov r1, r6 <== NOT EXECUTED
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dd, block, &diskbuf);
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
e2bc: 0affffe1 beq e248 <rtems_blkdev_generic_write+0x8c> <== NOT EXECUTED
blkofs = 0;
block++;
}
return rc;
}
e2c0: e28dd00c add sp, sp, #12
e2c4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00002888 <rtems_blkdev_imfs_fsync_or_fdatasync>:
}
static int rtems_blkdev_imfs_fsync_or_fdatasync(
rtems_libio_t *iop
)
{
2888: e52de004 push {lr} ; (str lr, [sp, #-4]!)
288c: 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);
2890: e5930050 ldr r0, [r3, #80] ; 0x50
2894: eb002f7d bl e690 <rtems_bdbuf_syncdev>
if (sc != RTEMS_SUCCESSFUL) {
2898: e3500000 cmp r0, #0
289c: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
errno = EIO;
28a0: eb003e7c bl 12298 <__errno> <== NOT EXECUTED
28a4: e3a03005 mov r3, #5 <== NOT EXECUTED
28a8: e5803000 str r3, [r0] <== NOT EXECUTED
28ac: e3e00000 mvn r0, #0 <== NOT EXECUTED
rv = -1;
}
return rv;
}
28b0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
000028b4 <rtems_blkdev_imfs_ioctl>:
void *buffer
)
{
int rv = 0;
if (request != RTEMS_BLKIO_REQUEST) {
28b4: e59f3034 ldr r3, [pc, #52] ; 28f0 <rtems_blkdev_imfs_ioctl+0x3c>
28b8: e1510003 cmp r1, r3
static int rtems_blkdev_imfs_ioctl(
rtems_libio_t *iop,
uint32_t request,
void *buffer
)
{
28bc: e52de004 push {lr} ; (str lr, [sp, #-4]!)
int rv = 0;
if (request != RTEMS_BLKIO_REQUEST) {
28c0: 0a000005 beq 28dc <rtems_blkdev_imfs_ioctl+0x28>
28c4: e5903018 ldr r3, [r0, #24]
28c8: 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);
28cc: e1a00003 mov r0, r3
28d0: e1a0e00f mov lr, pc
28d4: e593f038 ldr pc, [r3, #56] ; 0x38
28d8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
} else {
/*
* It is not allowed to directly access the driver circumventing the cache.
*/
errno = EINVAL;
28dc: eb003e6d bl 12298 <__errno> <== NOT EXECUTED
28e0: e3a03016 mov r3, #22 <== NOT EXECUTED
28e4: e5803000 str r3, [r0] <== NOT EXECUTED
28e8: e3e00000 mvn r0, #0 <== NOT EXECUTED
rv = -1;
}
return rv;
}
28ec: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
000026f0 <rtems_blkdev_imfs_read>:
static ssize_t rtems_blkdev_imfs_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
26f0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
26f4: e5903018 ldr r3, [r0, #24]
26f8: e5937050 ldr r7, [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;
26fc: e9900018 ldmib r0, {r3, r4}
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
2700: e597b024 ldr fp, [r7, #36] ; 0x24
static ssize_t rtems_blkdev_imfs_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
2704: e24dd010 sub sp, sp, #16
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;
2708: e98d0018 stmib sp, {r3, r4}
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd); rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
270c: e1a05fcb asr r5, fp, #31
static ssize_t rtems_blkdev_imfs_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
2710: e58d2000 str r2, [sp]
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);
2714: e1a03005 mov r3, r5
2718: e1a0200b mov r2, fp
static ssize_t rtems_blkdev_imfs_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
271c: e1a09000 mov r9, r0
2720: e1a0a001 mov sl, 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);
2724: e99d0003 ldmib sp, {r0, r1}
2728: eb0065d1 bl 1be74 <__divdi3>
ssize_t block_offset = (ssize_t) (offset % block_size);
272c: e1a0200b mov r2, fp
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);
2730: e1a06000 mov r6, r0
ssize_t block_offset = (ssize_t) (offset % block_size);
2734: e1a03005 mov r3, r5
2738: e99d0003 ldmib sp, {r0, r1}
273c: eb006707 bl 1c360 <__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;
2740: e59d4000 ldr r4, [sp]
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) {
2744: e3540000 cmp r4, #0
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);
2748: e1a08000 mov r8, r0
char *dst = buffer;
while (remaining > 0) {
rtems_bdbuf_buffer *bd;
rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);
274c: e1a01006 mov r1, r6
2750: e28d200c add r2, sp, #12
2754: e1a00007 mov r0, r7
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) {
2758: da00001d ble 27d4 <rtems_blkdev_imfs_read+0xe4>
rtems_bdbuf_buffer *bd;
rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);
275c: eb002eb7 bl e240 <rtems_bdbuf_read>
if (sc == RTEMS_SUCCESSFUL) {
2760: e3500000 cmp r0, #0
2764: 0a000005 beq 2780 <rtems_blkdev_imfs_read+0x90>
if (remaining >= 0) {
iop->offset += count;
rv = (ssize_t) count;
} else {
errno = EIO;
2768: eb003eca bl 12298 <__errno> <== NOT EXECUTED
276c: e3a03005 mov r3, #5 <== NOT EXECUTED
2770: e5803000 str r3, [r0] <== NOT EXECUTED
rv = -1;
2774: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return rv;
}
2778: e28dd010 add sp, sp, #16
277c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if (copy > remaining) {
copy = remaining;
}
memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
2780: e59d300c ldr r3, [sp, #12]
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;
2784: e068500b rsb r5, r8, fp
if (copy > remaining) {
copy = remaining;
}
memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
2788: 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;
278c: e1550004 cmp r5, r4
2790: a1a05004 movge r5, r4
if (copy > remaining) {
copy = remaining;
}
memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
2794: e0811008 add r1, r1, r8
2798: e1a02005 mov r2, r5
279c: e1a0000a mov r0, sl
27a0: eb004123 bl 12c34 <memcpy>
sc = rtems_bdbuf_release(bd);
27a4: e59d000c ldr r0, [sp, #12]
27a8: eb002f1d bl e424 <rtems_bdbuf_release>
if (sc == RTEMS_SUCCESSFUL) {
27ac: e2508000 subs r8, r0, #0
27b0: 1a00000f bne 27f4 <rtems_blkdev_imfs_read+0x104>
block_offset = 0;
remaining -= copy;
27b4: e0654004 rsb r4, r5, r4
dst += copy;
++block;
27b8: e2866001 add r6, r6, #1
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) {
27bc: e3540000 cmp r4, #0
sc = rtems_bdbuf_release(bd);
if (sc == RTEMS_SUCCESSFUL) {
block_offset = 0;
remaining -= copy;
dst += copy;
27c0: e08aa005 add sl, sl, r5
ssize_t block_offset = (ssize_t) (offset % block_size);
char *dst = buffer;
while (remaining > 0) {
rtems_bdbuf_buffer *bd;
rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);
27c4: e1a01006 mov r1, r6
27c8: e28d200c add r2, sp, #12
27cc: e1a00007 mov r0, r7
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) {
27d0: caffffe1 bgt 275c <rtems_blkdev_imfs_read+0x6c>
} else {
remaining = -1;
}
}
if (remaining >= 0) {
27d4: 1affffe3 bne 2768 <rtems_blkdev_imfs_read+0x78>
iop->offset += count;
27d8: e999000c ldmib r9, {r2, r3}
27dc: e59d4000 ldr r4, [sp]
27e0: e0922004 adds r2, r2, r4
27e4: e2a33000 adc r3, r3, #0
27e8: e989000c stmib r9, {r2, r3}
rv = (ssize_t) count;
27ec: e1a00004 mov r0, r4
27f0: eaffffe0 b 2778 <rtems_blkdev_imfs_read+0x88>
block_offset = 0;
remaining -= copy;
dst += copy;
++block;
} else {
remaining = -1;
27f4: e3e04000 mvn r4, #0 <== NOT EXECUTED
27f8: e3540000 cmp r4, #0 <== NOT EXECUTED
27fc: eafffff4 b 27d4 <rtems_blkdev_imfs_read+0xe4> <== NOT EXECUTED
000025a4 <rtems_blkdev_imfs_write>:
static ssize_t rtems_blkdev_imfs_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
25a4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
25a8: e5903018 ldr r3, [r0, #24]
25ac: e5939050 ldr r9, [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;
25b0: e9900018 ldmib r0, {r3, r4}
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
25b4: e5996024 ldr r6, [r9, #36] ; 0x24
static ssize_t rtems_blkdev_imfs_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
25b8: 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;
25bc: e58d3008 str r3, [sp, #8]
25c0: e58d400c str r4, [sp, #12]
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd); rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
25c4: e1a05fc6 asr r5, r6, #31
25c8: e1a03005 mov r3, r5
static ssize_t rtems_blkdev_imfs_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
25cc: e58d0000 str r0, [sp]
25d0: e58d2004 str r2, [sp, #4]
25d4: e1a0b001 mov fp, 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);
25d8: e1a02006 mov r2, r6
25dc: e28d1008 add r1, sp, #8
25e0: e8910003 ldm r1, {r0, r1}
25e4: eb006622 bl 1be74 <__divdi3>
ssize_t block_offset = (ssize_t) (offset % block_size);
25e8: 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);
25ec: e1a07000 mov r7, r0
ssize_t block_offset = (ssize_t) (offset % block_size);
25f0: e1a02006 mov r2, r6
25f4: e28d1008 add r1, sp, #8
25f8: e8910003 ldm r1, {r0, r1}
25fc: eb006757 bl 1c360 <__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;
2600: e59d5004 ldr r5, [sp, #4]
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) {
2604: e3550000 cmp r5, #0
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);
2608: e1a04006 mov r4, r6
ssize_t block_offset = (ssize_t) (offset % block_size);
260c: e1a08000 mov r8, r0
const char *src = buffer;
while (remaining > 0) {
2610: da000029 ble 26bc <rtems_blkdev_imfs_write+0x118>
rtems_status_code sc;
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
2614: e1550006 cmp r5, r6
2618: a3580000 cmpge r8, #0
261c: 1a00000c bne 2654 <rtems_blkdev_imfs_write+0xb0>
sc = rtems_bdbuf_get(dd, block, &bd);
2620: e1a00009 mov r0, r9
2624: e1a01007 mov r1, r7
2628: e28d2010 add r2, sp, #16
262c: eb002ec5 bl e148 <rtems_bdbuf_get>
2630: e1a04000 mov r4, r0
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
}
if (sc == RTEMS_SUCCESSFUL) {
2634: e3540000 cmp r4, #0
2638: 0a00000c beq 2670 <rtems_blkdev_imfs_write+0xcc>
if (remaining >= 0) {
iop->offset += count;
rv = (ssize_t) count;
} else {
errno = EIO;
263c: eb003f15 bl 12298 <__errno> <== NOT EXECUTED
2640: e3a03005 mov r3, #5 <== NOT EXECUTED
2644: e5803000 str r3, [r0] <== NOT EXECUTED
rv = -1;
2648: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return rv;
}
264c: e28dd014 add sp, sp, #20
2650: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
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);
2654: e1a01007 mov r1, r7
2658: e28d2010 add r2, sp, #16
265c: e1a00009 mov r0, r9
2660: eb002ef6 bl e240 <rtems_bdbuf_read>
2664: e1a04000 mov r4, r0
}
if (sc == RTEMS_SUCCESSFUL) {
2668: e3540000 cmp r4, #0
266c: 1afffff2 bne 263c <rtems_blkdev_imfs_write+0x98>
if (copy > remaining) {
copy = remaining;
}
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
2670: e59d3010 ldr r3, [sp, #16]
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
}
if (sc == RTEMS_SUCCESSFUL) {
ssize_t copy = block_size - block_offset;
2674: e068a006 rsb sl, r8, r6
if (copy > remaining) {
copy = remaining;
}
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
2678: e593001c ldr r0, [r3, #28]
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
}
if (sc == RTEMS_SUCCESSFUL) {
ssize_t copy = block_size - block_offset;
267c: e15a0005 cmp sl, r5
2680: a1a0a005 movge sl, r5
if (copy > remaining) {
copy = remaining;
}
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
2684: e1a0100b mov r1, fp
2688: e1a0200a mov r2, sl
268c: e0800008 add r0, r0, r8
2690: eb004167 bl 12c34 <memcpy>
sc = rtems_bdbuf_release_modified(bd);
2694: e59d0010 ldr r0, [sp, #16]
2698: eb002f92 bl e4e8 <rtems_bdbuf_release_modified>
if (sc == RTEMS_SUCCESSFUL) {
269c: e3500000 cmp r0, #0
26a0: 1a00000f bne 26e4 <rtems_blkdev_imfs_write+0x140>
block_offset = 0;
remaining -= copy;
26a4: e06a5005 rsb r5, sl, r5
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) {
26a8: e3550000 cmp r5, #0
sc = rtems_bdbuf_release_modified(bd);
if (sc == RTEMS_SUCCESSFUL) {
block_offset = 0;
remaining -= copy;
src += copy;
26ac: e08bb00a add fp, fp, sl
++block;
26b0: e2877001 add r7, r7, #1
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
sc = rtems_bdbuf_release_modified(bd);
if (sc == RTEMS_SUCCESSFUL) {
block_offset = 0;
26b4: e1a08004 mov r8, r4
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) {
26b8: caffffd5 bgt 2614 <rtems_blkdev_imfs_write+0x70>
} else {
remaining = -1;
}
}
if (remaining >= 0) {
26bc: 1affffde bne 263c <rtems_blkdev_imfs_write+0x98>
iop->offset += count;
26c0: e59d4000 ldr r4, [sp]
26c4: e994000c ldmib r4, {r2, r3}
26c8: e59d4004 ldr r4, [sp, #4]
26cc: e0922004 adds r2, r2, r4
26d0: e59d4000 ldr r4, [sp]
26d4: e2a33000 adc r3, r3, #0
26d8: e984000c stmib r4, {r2, r3}
rv = (ssize_t) count;
26dc: e59d0004 ldr r0, [sp, #4]
26e0: eaffffd9 b 264c <rtems_blkdev_imfs_write+0xa8>
block_offset = 0;
remaining -= copy;
src += copy;
++block;
} else {
remaining = -1;
26e4: e3e05000 mvn r5, #0 <== NOT EXECUTED
26e8: e3550000 cmp r5, #0 <== NOT EXECUTED
26ec: eafffff2 b 26bc <rtems_blkdev_imfs_write+0x118> <== NOT EXECUTED
0000df8c <rtems_blkdev_ioctl>:
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
df8c: e59f3124 ldr r3, [pc, #292] ; e0b8 <rtems_blkdev_ioctl+0x12c>
df90: e1510003 cmp r1, r3
#include <rtems/blkdev.h>
#include <rtems/bdbuf.h>
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
df94: e52de004 push {lr} ; (str lr, [sp, #-4]!)
df98: e1a03000 mov r3, r0
rtems_status_code sc;
int rc = 0;
switch (req)
df9c: 0a000041 beq e0a8 <rtems_blkdev_ioctl+0x11c>
dfa0: 9a000015 bls dffc <rtems_blkdev_ioctl+0x70>
dfa4: e59fc110 ldr ip, [pc, #272] ; e0bc <rtems_blkdev_ioctl+0x130>
dfa8: e151000c cmp r1, ip
rc = -1;
}
break;
case RTEMS_BLKIO_GETDISKDEV:
*(rtems_disk_device **) argp = dd;
dfac: 05820000 streq r0, [r2]
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
dfb0: 03a00000 moveq r0, #0
switch (req)
dfb4: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
dfb8: 9a00001d bls e034 <rtems_blkdev_ioctl+0xa8>
dfbc: e59f30fc ldr r3, [pc, #252] ; e0c0 <rtems_blkdev_ioctl+0x134>
dfc0: e1510003 cmp r1, r3
dfc4: 0a000029 beq e070 <rtems_blkdev_ioctl+0xe4>
dfc8: e243311f sub r3, r3, #-1073741817 ; 0xc0000007
dfcc: e1510003 cmp r1, r3
dfd0: 1a00001a bne e040 <rtems_blkdev_ioctl+0xb4>
case RTEMS_BLKIO_GETBLKSIZE:
*(uint32_t *) argp = dd->block_size;
break;
case RTEMS_BLKIO_SETBLKSIZE:
sc = rtems_bdbuf_set_block_size(dd, *(uint32_t *) argp, true);
dfd4: e5921000 ldr r1, [r2]
dfd8: e3a02001 mov r2, #1
dfdc: ebffff96 bl de3c <rtems_bdbuf_set_block_size>
if (sc != RTEMS_SUCCESSFUL) {
dfe0: e3500000 cmp r0, #0
dfe4: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
break;
case RTEMS_BLKIO_SYNCDEV:
sc = rtems_bdbuf_syncdev(dd);
if (sc != RTEMS_SUCCESSFUL) {
errno = EIO;
dfe8: eb000f4f bl 11d2c <__errno> <== NOT EXECUTED
dfec: e3a03005 mov r3, #5 <== NOT EXECUTED
dff0: e5803000 str r3, [r0] <== NOT EXECUTED
rc = -1;
dff4: e3e00000 mvn r0, #0 <== NOT EXECUTED
dff8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
dffc: e59fc0c0 ldr ip, [pc, #192] ; e0c4 <rtems_blkdev_ioctl+0x138>
e000: e151000c cmp r1, ip
e004: 0a000024 beq e09c <rtems_blkdev_ioctl+0x110>
e008: 9a000011 bls e054 <rtems_blkdev_ioctl+0xc8>
e00c: e59fc0b4 ldr ip, [pc, #180] ; e0c8 <rtems_blkdev_ioctl+0x13c>
e010: e151000c cmp r1, ip
e014: 0a00001d beq e090 <rtems_blkdev_ioctl+0x104>
e018: e59f00ac ldr r0, [pc, #172] ; e0cc <rtems_blkdev_ioctl+0x140>
e01c: e1510000 cmp r1, r0
e020: 1a000006 bne e040 <rtems_blkdev_ioctl+0xb4>
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
e024: e5933020 ldr r3, [r3, #32]
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
e028: e3a00000 mov r0, #0
switch (req)
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
e02c: e5823000 str r3, [r2]
break;
e030: e49df004 pop {pc} ; (ldr pc, [sp], #4)
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
e034: e59f0094 ldr r0, [pc, #148] ; e0d0 <rtems_blkdev_ioctl+0x144>
e038: e1510000 cmp r1, r0
e03c: 0a00000f beq e080 <rtems_blkdev_ioctl+0xf4>
case RTEMS_BLKIO_RESETDEVSTATS:
rtems_bdbuf_reset_device_stats(dd);
break;
default:
errno = EINVAL;
e040: eb000f39 bl 11d2c <__errno>
e044: e3a03016 mov r3, #22
e048: e5803000 str r3, [r0]
rc = -1;
e04c: e3e00000 mvn r0, #0
break;
}
return rc;
}
e050: e49df004 pop {pc} ; (ldr pc, [sp], #4)
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
e054: e59f3078 ldr r3, [pc, #120] ; e0d4 <rtems_blkdev_ioctl+0x148>
e058: e1510003 cmp r1, r3
e05c: 1afffff7 bne e040 <rtems_blkdev_ioctl+0xb4>
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
break;
case RTEMS_BLKIO_SYNCDEV:
sc = rtems_bdbuf_syncdev(dd);
e060: ebfffee2 bl dbf0 <rtems_bdbuf_syncdev>
if (sc != RTEMS_SUCCESSFUL) {
e064: e3500000 cmp r0, #0
e068: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
e06c: eaffffdd b dfe8 <rtems_blkdev_ioctl+0x5c> <== NOT EXECUTED
case RTEMS_BLKIO_PURGEDEV:
rtems_bdbuf_purge_dev(dd);
break;
case RTEMS_BLKIO_GETDEVSTATS:
rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
e070: e1a01002 mov r1, r2
e074: ebffffaf bl df38 <rtems_bdbuf_get_device_stats>
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
e078: e3a00000 mov r0, #0
rtems_bdbuf_purge_dev(dd);
break;
case RTEMS_BLKIO_GETDEVSTATS:
rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
break;
e07c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
e080: e593301c ldr r3, [r3, #28]
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
e084: e3a00000 mov r0, #0
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
e088: e5823000 str r3, [r2]
break;
e08c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case RTEMS_BLKIO_GETDEVSTATS:
rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
break;
case RTEMS_BLKIO_RESETDEVSTATS:
rtems_bdbuf_reset_device_stats(dd);
e090: ebffffb4 bl df68 <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;
e094: 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;
e098: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case RTEMS_BLKIO_GETDISKDEV:
*(rtems_disk_device **) argp = dd;
break;
case RTEMS_BLKIO_PURGEDEV:
rtems_bdbuf_purge_dev(dd);
e09c: ebfffee4 bl dc34 <rtems_bdbuf_purge_dev>
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
e0a0: e3a00000 mov r0, #0
*(rtems_disk_device **) argp = dd;
break;
case RTEMS_BLKIO_PURGEDEV:
rtems_bdbuf_purge_dev(dd);
break;
e0a4: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*(uint32_t *) argp = dd->block_size;
e0a8: e5903024 ldr r3, [r0, #36] ; 0x24
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
e0ac: e3a00000 mov r0, #0
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*(uint32_t *) argp = dd->block_size;
e0b0: e5823000 str r3, [r2]
break;
e0b4: e49df004 pop {pc} ; (ldr pc, [sp], #4)
00021888 <rtems_blkstats>:
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
void rtems_blkstats(FILE *output, const char *device, bool reset)
{
21888: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
2188c: e1a04000 mov r4, r0 <== NOT EXECUTED
21890: e24dd068 sub sp, sp, #104 ; 0x68 <== NOT EXECUTED
int fd = open(device, O_RDONLY);
21894: e1a00001 mov r0, r1 <== NOT EXECUTED 21898: 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)
{
2189c: e20260ff and r6, r2, #255 ; 0xff <== NOT EXECUTED
int fd = open(device, O_RDONLY);
218a0: ebff882a bl 3950 <open> <== NOT EXECUTED
if (fd >= 0) {
218a4: e2505000 subs r5, r0, #0 <== NOT EXECUTED 218a8: ba00001f blt 2192c <rtems_blkstats+0xa4> <== NOT EXECUTED
struct stat st;
int rv;
rv = fstat(fd, &st);
218ac: e1a0100d mov r1, sp <== NOT EXECUTED 218b0: eb000692 bl 23300 <fstat> <== NOT EXECUTED
if (rv == 0) {
218b4: e3500000 cmp r0, #0 <== NOT EXECUTED 218b8: 1a00002b bne 2196c <rtems_blkstats+0xe4> <== NOT EXECUTED
if (S_ISBLK(st.st_mode)) {
218bc: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 218c0: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED 218c4: e3530a06 cmp r3, #24576 ; 0x6000 <== NOT EXECUTED 218c8: 0a00000a beq 218f8 <rtems_blkstats+0x70> <== NOT EXECUTED
} else {
fprintf(output, "error: get stats: %s\n", strerror(errno));
}
}
} else {
fprintf(output, "error: not a block device\n");
218cc: e3a01001 mov r1, #1 <== NOT EXECUTED 218d0: e3a0201a mov r2, #26 <== NOT EXECUTED 218d4: e1a03004 mov r3, r4 <== NOT EXECUTED 218d8: e59f00fc ldr r0, [pc, #252] ; 219dc <rtems_blkstats+0x154> <== NOT EXECUTED 218dc: eb005835 bl 379b8 <fwrite> <== NOT EXECUTED
}
} else {
fprintf(output, "error: get file stats: %s\n", strerror(errno));
}
rv = close(fd);
218e0: e1a00005 mov r0, r5 <== NOT EXECUTED 218e4: eb000605 bl 23100 <close> <== NOT EXECUTED
if (rv != 0) {
218e8: e3500000 cmp r0, #0 <== NOT EXECUTED 218ec: 1a000016 bne 2194c <rtems_blkstats+0xc4> <== NOT EXECUTED
fprintf(output, "error: close device: %s\n", strerror(errno));
}
} else {
fprintf(output, "error: open device: %s\n", strerror(errno));
}
}
218f0: e28dd068 add sp, sp, #104 ; 0x68 <== NOT EXECUTED
218f4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
int rv;
rv = fstat(fd, &st);
if (rv == 0) {
if (S_ISBLK(st.st_mode)) {
if (reset) {
218f8: 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);
218fc: e1a00005 mov r0, r5 <== NOT EXECUTED 21900: 1a000021 bne 2198c <rtems_blkstats+0x104> <== NOT EXECUTED
static inline int rtems_disk_fd_get_device_stats(
int fd,
rtems_blkdev_stats *stats
)
{
return ioctl(fd, RTEMS_BLKIO_GETDEVSTATS, stats);
21904: e59f10d4 ldr r1, [pc, #212] ; 219e0 <rtems_blkstats+0x158> <== NOT EXECUTED 21908: e28d2048 add r2, sp, #72 ; 0x48 <== NOT EXECUTED 2190c: eb000946 bl 23e2c <ioctl> <== NOT EXECUTED
}
} else {
rtems_blkdev_stats stats;
rv = rtems_disk_fd_get_device_stats(fd, &stats);
if (rv == 0) {
21910: e3500000 cmp r0, #0 <== NOT EXECUTED 21914: 1a000028 bne 219bc <rtems_blkstats+0x134> <== NOT EXECUTED
rtems_blkdev_print_stats(
21918: e28d0048 add r0, sp, #72 ; 0x48 <== NOT EXECUTED 2191c: e59f10c0 ldr r1, [pc, #192] ; 219e4 <rtems_blkstats+0x15c> <== NOT EXECUTED 21920: e1a02004 mov r2, r4 <== NOT EXECUTED 21924: eb000035 bl 21a00 <rtems_blkdev_print_stats> <== NOT EXECUTED 21928: eaffffec b 218e0 <rtems_blkstats+0x58> <== NOT EXECUTED
rv = close(fd);
if (rv != 0) {
fprintf(output, "error: close device: %s\n", strerror(errno));
}
} else {
fprintf(output, "error: open device: %s\n", strerror(errno));
2192c: eb0050d2 bl 35c7c <__errno> <== NOT EXECUTED 21930: e5900000 ldr r0, [r0] <== NOT EXECUTED 21934: eb006bfb bl 3c928 <strerror> <== NOT EXECUTED 21938: e59f10a8 ldr r1, [pc, #168] ; 219e8 <rtems_blkstats+0x160> <== NOT EXECUTED 2193c: e1a02000 mov r2, r0 <== NOT EXECUTED 21940: e1a00004 mov r0, r4 <== NOT EXECUTED 21944: eb005374 bl 3671c <fprintf> <== NOT EXECUTED 21948: eaffffe8 b 218f0 <rtems_blkstats+0x68> <== NOT EXECUTED
fprintf(output, "error: get file stats: %s\n", strerror(errno));
}
rv = close(fd);
if (rv != 0) {
fprintf(output, "error: close device: %s\n", strerror(errno));
2194c: eb0050ca bl 35c7c <__errno> <== NOT EXECUTED 21950: e5900000 ldr r0, [r0] <== NOT EXECUTED 21954: eb006bf3 bl 3c928 <strerror> <== NOT EXECUTED 21958: e59f108c ldr r1, [pc, #140] ; 219ec <rtems_blkstats+0x164> <== NOT EXECUTED 2195c: e1a02000 mov r2, r0 <== NOT EXECUTED 21960: e1a00004 mov r0, r4 <== NOT EXECUTED 21964: eb00536c bl 3671c <fprintf> <== NOT EXECUTED 21968: eaffffe0 b 218f0 <rtems_blkstats+0x68> <== NOT EXECUTED
}
} else {
fprintf(output, "error: not a block device\n");
}
} else {
fprintf(output, "error: get file stats: %s\n", strerror(errno));
2196c: eb0050c2 bl 35c7c <__errno> <== NOT EXECUTED 21970: e5900000 ldr r0, [r0] <== NOT EXECUTED 21974: eb006beb bl 3c928 <strerror> <== NOT EXECUTED 21978: e59f1070 ldr r1, [pc, #112] ; 219f0 <rtems_blkstats+0x168> <== NOT EXECUTED 2197c: e1a02000 mov r2, r0 <== NOT EXECUTED 21980: e1a00004 mov r0, r4 <== NOT EXECUTED 21984: eb005364 bl 3671c <fprintf> <== NOT EXECUTED 21988: eaffffd4 b 218e0 <rtems_blkstats+0x58> <== NOT EXECUTED
}
static inline int rtems_disk_fd_reset_device_stats(int fd)
{
return ioctl(fd, RTEMS_BLKIO_RESETDEVSTATS);
2198c: e59f1060 ldr r1, [pc, #96] ; 219f4 <rtems_blkstats+0x16c> <== NOT EXECUTED 21990: eb000925 bl 23e2c <ioctl> <== NOT EXECUTED
rv = fstat(fd, &st);
if (rv == 0) {
if (S_ISBLK(st.st_mode)) {
if (reset) {
rv = rtems_disk_fd_reset_device_stats(fd);
if (rv != 0) {
21994: e3500000 cmp r0, #0 <== NOT EXECUTED 21998: 0affffd0 beq 218e0 <rtems_blkstats+0x58> <== NOT EXECUTED
fprintf(output, "error: reset stats: %s\n", strerror(errno));
2199c: eb0050b6 bl 35c7c <__errno> <== NOT EXECUTED 219a0: e5900000 ldr r0, [r0] <== NOT EXECUTED 219a4: eb006bdf bl 3c928 <strerror> <== NOT EXECUTED 219a8: e59f1048 ldr r1, [pc, #72] ; 219f8 <rtems_blkstats+0x170> <== NOT EXECUTED 219ac: e1a02000 mov r2, r0 <== NOT EXECUTED 219b0: e1a00004 mov r0, r4 <== NOT EXECUTED 219b4: eb005358 bl 3671c <fprintf> <== NOT EXECUTED 219b8: eaffffc8 b 218e0 <rtems_blkstats+0x58> <== NOT EXECUTED
&stats,
(rtems_printk_plugin_t) fprintf,
output
);
} else {
fprintf(output, "error: get stats: %s\n", strerror(errno));
219bc: eb0050ae bl 35c7c <__errno> <== NOT EXECUTED 219c0: e5900000 ldr r0, [r0] <== NOT EXECUTED 219c4: eb006bd7 bl 3c928 <strerror> <== NOT EXECUTED 219c8: e59f102c ldr r1, [pc, #44] ; 219fc <rtems_blkstats+0x174> <== NOT EXECUTED 219cc: e1a02000 mov r2, r0 <== NOT EXECUTED 219d0: e1a00004 mov r0, r4 <== NOT EXECUTED 219d4: eb005350 bl 3671c <fprintf> <== NOT EXECUTED 219d8: eaffffc0 b 218e0 <rtems_blkstats+0x58> <== NOT EXECUTED
000027f8 <rtems_disk_delete>:
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
{
27f8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
27fc: e24dd00c sub sp, sp, #12
2800: e1a04000 mov r4, r0
2804: e1a05001 mov r5, r1
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
sc = disk_lock();
2808: ebffff83 bl 261c <disk_lock>
if (sc != RTEMS_SUCCESSFUL) {
280c: e250b000 subs fp, r0, #0
2810: 0a000002 beq 2820 <rtems_disk_delete+0x28>
rtems_disk_cleanup(dd);
disk_unlock();
return RTEMS_SUCCESSFUL;
}
2814: e1a0000b mov r0, fp
2818: e28dd00c add sp, sp, #12
281c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
dd = get_disk_entry(dev, true);
2820: e1a00004 mov r0, r4
2824: e1a01005 mov r1, r5
2828: e3a02001 mov r2, #1
282c: ebffff44 bl 2544 <get_disk_entry>
if (dd == NULL) {
2830: e2503000 subs r3, r0, #0
2834: 0a000050 beq 297c <rtems_disk_delete+0x184>
disk_unlock();
return RTEMS_INVALID_ID;
}
dd->deleted = true;
2838: e3a0a001 mov sl, #1
283c: e5c3a040 strb sl, [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;
2840: e5936008 ldr r6, [r3, #8]
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
2844: e5d62040 ldrb r2, [r6, #64] ; 0x40
2848: e3520000 cmp r2, #0
284c: 0a00003b beq 2940 <rtems_disk_delete+0x148>
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
2850: e59f7154 ldr r7, [pc, #340] ; 29ac <rtems_disk_delete+0x1b4>
2854: e5973000 ldr r3, [r7]
2858: e3530000 cmp r3, #0
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
285c: e8960018 ldm r6, {r3, r4}
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
2860: e1a0900b mov r9, fp
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;
2864: e98d0018 stmib sp, {r3, r4}
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
2868: 0a00002d beq 2924 <rtems_disk_delete+0x12c>
286c: e1a0800b mov r8, fp
rtems_disk_device_table *dtab = disktab + major;
2870: e5975004 ldr r5, [r7, #4]
2874: e0855188 add r5, r5, r8, lsl #3
for (minor = 0; minor < dtab->size; ++minor) {
2878: e595c004 ldr ip, [r5, #4]
287c: e35c0000 cmp ip, #0
2880: 0a000023 beq 2914 <rtems_disk_delete+0x11c>
2884: e3a04000 mov r4, #0
2888: e58db000 str fp, [sp]
288c: ea000002 b 289c <rtems_disk_delete+0xa4>
2890: e2844001 add r4, r4, #1
2894: e154000c cmp r4, ip
2898: 2a00001c bcs 2910 <rtems_disk_delete+0x118>
rtems_disk_device *dd = dtab->minor [minor];
289c: e5951000 ldr r1, [r5]
28a0: e7910104 ldr r0, [r1, r4, lsl #2]
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
28a4: 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];
28a8: e1a0e104 lsl lr, r4, #2
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
28ac: 0afffff7 beq 2890 <rtems_disk_delete+0x98>
28b0: e5903008 ldr r3, [r0, #8]
28b4: e99d0c00 ldmib sp, {sl, fp}
28b8: e893000c ldm r3, {r2, r3}
28bc: e15b0003 cmp fp, r3
28c0: 015a0002 cmpeq sl, r2
28c4: 13a03000 movne r3, #0
28c8: 03a03001 moveq r3, #1
28cc: e1560000 cmp r6, r0
28d0: 03a03000 moveq r3, #0
28d4: 12033001 andne r3, r3, #1
28d8: e3530000 cmp r3, #0
28dc: 0affffeb beq 2890 <rtems_disk_delete+0x98>
if (dd->uses == 0) {
28e0: e5903014 ldr r3, [r0, #20]
28e4: e3530000 cmp r3, #0
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
} else {
dd->deleted = true;
28e8: 13a0b001 movne fp, #1
28ec: 15c0b040 strbne fp, [r0, #64] ; 0x40
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) {
28f0: 1affffe6 bne 2890 <rtems_disk_delete+0x98>
++deleted_count;
dtab->minor [minor] = NULL;
28f4: e781300e str r3, [r1, lr]
free_disk_device(dd);
28f8: ebffff33 bl 25cc <free_disk_device>
28fc: e595c004 ldr ip, [r5, #4]
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
2900: e2844001 add r4, r4, #1
2904: e154000c cmp r4, ip
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
if (dd->uses == 0) {
++deleted_count;
2908: e2899001 add r9, r9, #1
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
290c: 3affffe2 bcc 289c <rtems_disk_delete+0xa4>
2910: e59db000 ldr fp, [sp]
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
2914: e5973000 ldr r3, [r7]
2918: e2888001 add r8, r8, #1
291c: e1580003 cmp r8, r3
2920: 3affffd2 bcc 2870 <rtems_disk_delete+0x78>
}
}
}
}
physical_disk->uses -= deleted_count;
2924: e5963014 ldr r3, [r6, #20]
2928: e0699003 rsb r9, r9, r3
if (physical_disk->uses == 0) {
292c: e3590000 cmp r9, #0
}
}
}
}
physical_disk->uses -= deleted_count;
2930: e5869014 str r9, [r6, #20]
if (physical_disk->uses == 0) {
2934: 0a000013 beq 2988 <rtems_disk_delete+0x190>
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
2938: ebffff43 bl 264c <disk_unlock>
293c: eaffffb4 b 2814 <rtems_disk_delete+0x1c>
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
2940: e5932014 ldr r2, [r3, #20]
2944: e3520000 cmp r2, #0
2948: 1afffffa bne 2938 <rtems_disk_delete+0x140>
--physical_disk->uses;
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
294c: e59f2058 ldr r2, [pc, #88] ; 29ac <rtems_disk_delete+0x1b4>
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
2950: e593e000 ldr lr, [r3]
disktab [major].minor [minor] = NULL;
2954: e592c004 ldr ip, [r2, #4]
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
2958: e5961014 ldr r1, [r6, #20]
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
295c: e5932004 ldr r2, [r3, #4]
disktab [major].minor [minor] = NULL;
2960: e79c318e ldr r3, [ip, lr, lsl #3]
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
2964: e2411001 sub r1, r1, #1
2968: e5861014 str r1, [r6, #20]
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
296c: e783b102 str fp, [r3, r2, lsl #2]
free_disk_device(disk_to_remove);
2970: ebffff15 bl 25cc <free_disk_device>
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
2974: ebffff34 bl 264c <disk_unlock>
2978: eaffffa5 b 2814 <rtems_disk_delete+0x1c>
return sc;
}
dd = get_disk_entry(dev, true);
if (dd == NULL) {
disk_unlock();
297c: ebffff32 bl 264c <disk_unlock> <== NOT EXECUTED
return RTEMS_INVALID_ID;
2980: e3a0b004 mov fp, #4 <== NOT EXECUTED
2984: eaffffa2 b 2814 <rtems_disk_delete+0x1c> <== NOT EXECUTED
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
2988: e5961000 ldr r1, [r6]
disktab [major].minor [minor] = NULL;
298c: e5973004 ldr r3, [r7, #4]
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
2990: e5962004 ldr r2, [r6, #4]
disktab [major].minor [minor] = NULL;
2994: e7933181 ldr r3, [r3, r1, lsl #3]
free_disk_device(physical_disk);
2998: e1a00006 mov r0, r6
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
disktab [major].minor [minor] = NULL;
299c: e7839102 str r9, [r3, r2, lsl #2]
free_disk_device(physical_disk);
29a0: ebffff09 bl 25cc <free_disk_device>
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
29a4: ebffff28 bl 264c <disk_unlock>
29a8: eaffff99 b 2814 <rtems_disk_delete+0x1c>
00002d1c <rtems_disk_io_initialize>:
}
}
rtems_status_code
rtems_disk_io_initialize(void)
{
2d1c: e92d4030 push {r4, r5, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
2d20: e59f4098 ldr r4, [pc, #152] ; 2dc0 <rtems_disk_io_initialize+0xa4>
2d24: e5945000 ldr r5, [r4]
2d28: e3550000 cmp r5, #0
}
}
rtems_status_code
rtems_disk_io_initialize(void)
{
2d2c: e24dd004 sub sp, sp, #4
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
2d30: 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) {
2d34: 0a000001 beq 2d40 <rtems_disk_io_initialize+0x24>
}
disktab_size = size;
return RTEMS_SUCCESSFUL;
}
2d38: e28dd004 add sp, sp, #4
2d3c: e8bd8030 pop {r4, r5, pc}
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
2d40: e3a00008 mov r0, #8
2d44: e1a01000 mov r1, r0
2d48: eb0001fb bl 353c <calloc>
if (disktab == NULL) {
2d4c: e3500000 cmp r0, #0
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
2d50: e5840004 str r0, [r4, #4]
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
2d54: 03a0001a moveq r0, #26
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
if (disktab == NULL) {
2d58: 0afffff6 beq 2d38 <rtems_disk_io_initialize+0x1c>
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
sc = rtems_semaphore_create(
2d5c: e284c008 add ip, r4, #8
2d60: e59f005c ldr r0, [pc, #92] ; 2dc4 <rtems_disk_io_initialize+0xa8>
2d64: e3a01001 mov r1, #1
2d68: e3a02010 mov r2, #16
2d6c: e1a03005 mov r3, r5
disktab = calloc(size, sizeof(rtems_disk_device_table));
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
2d70: e5c4500c strb r5, [r4, #12]
sc = rtems_semaphore_create(
2d74: e58dc000 str ip, [sp]
2d78: eb0012bf bl 787c <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) {
2d7c: e3500000 cmp r0, #0
2d80: 0a000003 beq 2d94 <rtems_disk_io_initialize+0x78>
free(disktab);
2d84: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED
2d88: eb0002a6 bl 3828 <free> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
2d8c: e3a0001a mov r0, #26 <== NOT EXECUTED
2d90: eaffffe8 b 2d38 <rtems_disk_io_initialize+0x1c> <== NOT EXECUTED
}
sc = rtems_bdbuf_init();
2d94: eb002931 bl d260 <rtems_bdbuf_init>
if (sc != RTEMS_SUCCESSFUL) {
2d98: e3500000 cmp r0, #0
free(disktab);
return RTEMS_UNSATISFIED;
}
disktab_size = size;
2d9c: 03a03008 moveq r3, #8
2da0: 05843000 streq r3, [r4]
return RTEMS_NO_MEMORY;
}
sc = rtems_bdbuf_init();
if (sc != RTEMS_SUCCESSFUL) {
2da4: 0affffe3 beq 2d38 <rtems_disk_io_initialize+0x1c>
rtems_semaphore_delete(diskdevs_mutex);
2da8: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
2dac: eb001322 bl 7a3c <rtems_semaphore_delete> <== NOT EXECUTED
free(disktab);
2db0: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED
2db4: eb00029b bl 3828 <free> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
2db8: e3a0000d mov r0, #13 <== NOT EXECUTED
2dbc: eaffffdd b 2d38 <rtems_disk_io_initialize+0x1c> <== NOT EXECUTED
00002c24 <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) {
2c24: e3e02000 mvn r2, #0
2c28: e3e03000 mvn r3, #0
2c2c: e1510003 cmp r1, r3
2c30: 01500002 cmpeq r0, r2
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
2c34: 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) {
2c38: 0a00002e beq 2cf8 <rtems_disk_next+0xd4>
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
2c3c: e2914001 adds r4, r1, #1
)
{
union __rtems_dev_t temp;
temp.device = device;
return temp.__overlay.major;
2c40: e1a05000 mov r5, r0
2c44: 2a00001c bcs 2cbc <rtems_disk_next+0x98>
} else {
++minor;
}
}
sc = disk_lock();
2c48: ebfffe73 bl 261c <disk_lock>
if (sc != RTEMS_SUCCESSFUL) {
2c4c: e2506000 subs r6, r0, #0
2c50: 1a00002b bne 2d04 <rtems_disk_next+0xe0>
return NULL;
}
if (major >= disktab_size) {
2c54: e59f30bc ldr r3, [pc, #188] ; 2d18 <rtems_disk_next+0xf4>
2c58: e5930000 ldr r0, [r3]
2c5c: e1550000 cmp r5, r0
2c60: 2a000029 bcs 2d0c <rtems_disk_next+0xe8>
disk_unlock();
return NULL;
}
dtab = disktab + major;
2c64: e5931004 ldr r1, [r3, #4]
2c68: e7913185 ldr r3, [r1, r5, lsl #3]
2c6c: e0816185 add r6, r1, r5, lsl #3
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
2c70: e3530000 cmp r3, #0
2c74: 0a000009 beq 2ca0 <rtems_disk_next+0x7c>
2c78: e5962004 ldr r2, [r6, #4]
2c7c: e1540002 cmp r4, r2
2c80: 2a000006 bcs 2ca0 <rtems_disk_next+0x7c>
disk_unlock();
return NULL;
}
dtab = disktab + major;
} else if (dtab->minor [minor] == NULL) {
2c84: e7932104 ldr r2, [r3, r4, lsl #2]
2c88: e3520000 cmp r2, #0
2c8c: e1a07104 lsl r7, r4, #2
2c90: 1a000011 bne 2cdc <rtems_disk_next+0xb8>
return NULL;
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
2c94: e3530000 cmp r3, #0
return NULL;
}
dtab = disktab + major;
} else if (dtab->minor [minor] == NULL) {
++minor;
2c98: e2844001 add r4, r4, #1
return NULL;
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
2c9c: 1afffff5 bne 2c78 <rtems_disk_next+0x54>
minor = 0;
++major;
2ca0: e2855001 add r5, r5, #1
if (major >= disktab_size) {
2ca4: e1500005 cmp r0, r5
2ca8: 9a000008 bls 2cd0 <rtems_disk_next+0xac>
disk_unlock();
return NULL;
}
dtab = disktab + major;
2cac: e0816185 add r6, r1, r5, lsl #3
2cb0: e7913185 ldr r3, [r1, r5, lsl #3]
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
2cb4: e3a04000 mov r4, #0
if (major >= disktab_size) {
disk_unlock();
return NULL;
}
dtab = disktab + major;
2cb8: eaffffec b 2c70 <rtems_disk_next+0x4c>
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
/* If major wraps around */
if ((major + 1) < major) {
2cbc: e2905001 adds r5, r0, #1 <== NOT EXECUTED
return NULL;
}
++major;
minor = 0;
2cc0: 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) {
2cc4: 3affffdf bcc 2c48 <rtems_disk_next+0x24> <== NOT EXECUTED
return NULL;
2cc8: e3a00000 mov r0, #0 <== NOT EXECUTED
2ccc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
++major;
if (major >= disktab_size) {
disk_unlock();
2cd0: ebfffe5d bl 264c <disk_unlock>
return NULL;
2cd4: e3a00000 mov r0, #0
2cd8: e8bd80f0 pop {r4, r5, r6, r7, pc}
}
dtab = disktab + major;
} else if (dtab->minor [minor] == NULL) {
++minor;
} else {
++dtab->minor [minor]->uses;
2cdc: e5923014 ldr r3, [r2, #20]
2ce0: e2833001 add r3, r3, #1
2ce4: e5823014 str r3, [r2, #20]
disk_unlock();
2ce8: ebfffe57 bl 264c <disk_unlock>
return dtab->minor [minor];
2cec: e5963000 ldr r3, [r6]
2cf0: e7930007 ldr r0, [r3, r7]
2cf4: e8bd80f0 pop {r4, r5, r6, r7, pc}
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;
2cf8: 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;
2cfc: e1a05004 mov r5, r4
2d00: eaffffd0 b 2c48 <rtems_disk_next+0x24>
}
}
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return NULL;
2d04: e3a00000 mov r0, #0 <== NOT EXECUTED
disk_unlock();
return dtab->minor [minor];
}
}
}
2d08: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
return NULL;
}
if (major >= disktab_size) {
disk_unlock();
2d0c: ebfffe4e bl 264c <disk_unlock> <== NOT EXECUTED
return NULL;
2d10: e1a00006 mov r0, r6 <== NOT EXECUTED
2d14: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00002b60 <rtems_disk_obtain>:
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
2b60: e92d40f0 push {r4, r5, r6, r7, lr}
2b64: e1a06000 mov r6, r0
2b68: e1a07001 mov r7, r1
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
2b6c: e10f4000 mrs r4, CPSR
2b70: e3843080 orr r3, r4, #128 ; 0x80
2b74: 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) {
2b78: e59f304c ldr r3, [pc, #76] ; 2bcc <rtems_disk_obtain+0x6c>
2b7c: e5d3200c ldrb r2, [r3, #12]
2b80: e21220ff ands r2, r2, #255 ; 0xff
2b84: 0a00000b beq 2bb8 <rtems_disk_obtain+0x58>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
2b88: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
dd = get_disk_entry(dev, false);
rtems_interrupt_enable(level);
} else {
rtems_interrupt_enable(level);
sc = disk_lock();
2b8c: ebfffea2 bl 261c <disk_lock> <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL) {
2b90: 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;
2b94: 13a05000 movne r5, #0 <== NOT EXECUTED
rtems_interrupt_enable(level);
} else {
rtems_interrupt_enable(level);
sc = disk_lock();
if (sc == RTEMS_SUCCESSFUL) {
2b98: 1a000004 bne 2bb0 <rtems_disk_obtain+0x50> <== NOT EXECUTED
dd = get_disk_entry(dev, false);
2b9c: e1a00006 mov r0, r6 <== NOT EXECUTED
2ba0: e1a01007 mov r1, r7 <== NOT EXECUTED
2ba4: ebfffe66 bl 2544 <get_disk_entry> <== NOT EXECUTED
2ba8: e1a05000 mov r5, r0 <== NOT EXECUTED
disk_unlock();
2bac: ebfffea6 bl 264c <disk_unlock> <== NOT EXECUTED
}
}
return dd;
}
2bb0: e1a00005 mov r0, r5 <== NOT EXECUTED
2bb4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
rtems_interrupt_level level;
rtems_interrupt_disable(level);
if (!diskdevs_protected) {
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
2bb8: ebfffe61 bl 2544 <get_disk_entry>
2bbc: e1a05000 mov r5, r0
2bc0: e129f004 msr CPSR_fc, r4
disk_unlock();
}
}
return dd;
}
2bc4: e1a00005 mov r0, r5
2bc8: e8bd80f0 pop {r4, r5, r6, r7, pc}
0000f940 <rtems_event_system_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
f940: e92d4070 push {r4, r5, r6, lr}
rtems_status_code sc;
if ( event_out != NULL ) {
f944: e2535000 subs r5, r3, #0
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
f948: e1a0c000 mov ip, r0
f94c: e24dd010 sub sp, sp, #16
} else {
*event_out = event->pending_events;
sc = RTEMS_SUCCESSFUL;
}
} else {
sc = RTEMS_INVALID_ADDRESS;
f950: 03a00009 moveq r0, #9
rtems_event_set *event_out
)
{
rtems_status_code sc;
if ( event_out != NULL ) {
f954: 0a000007 beq f978 <rtems_event_system_receive+0x38>
Thread_Control *executing = _Thread_Executing;
f958: e59f4058 ldr r4, [pc, #88] ; f9b8 <rtems_event_system_receive+0x78>
f95c: e5944008 ldr r4, [r4, #8]
RTEMS_API_Control *api = executing->API_Extensions[ THREAD_API_RTEMS ];
Event_Control *event = &api->System_event;
if ( !_Event_sets_Is_empty( event_in ) ) {
f960: e35c0000 cmp ip, #0
{
rtems_status_code sc;
if ( event_out != NULL ) {
Thread_Control *executing = _Thread_Executing;
RTEMS_API_Control *api = executing->API_Extensions[ THREAD_API_RTEMS ];
f964: e59460ec ldr r6, [r4, #236] ; 0xec
Event_Control *event = &api->System_event;
if ( !_Event_sets_Is_empty( event_in ) ) {
f968: 1a000004 bne f980 <rtems_event_system_receive+0x40>
);
_Thread_Enable_dispatch();
sc = executing->Wait.return_code;
} else {
*event_out = event->pending_events;
f96c: e5963004 ldr r3, [r6, #4] <== NOT EXECUTED
f970: e5853000 str r3, [r5] <== NOT EXECUTED
sc = RTEMS_SUCCESSFUL;
f974: e1a0000c mov r0, ip <== NOT EXECUTED
} else {
sc = RTEMS_INVALID_ADDRESS;
}
return sc;
}
f978: e28dd010 add sp, sp, #16
f97c: e8bd8070 pop {r4, r5, r6, pc}
*
* 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;
f980: e59fc034 ldr ip, [pc, #52] ; f9bc <rtems_event_system_receive+0x7c>
f984: e59ce000 ldr lr, [ip]
++level;
f988: e28ee001 add lr, lr, #1
_Thread_Dispatch_disable_level = level;
f98c: e58ce000 str lr, [ip]
RTEMS_API_Control *api = executing->API_Extensions[ THREAD_API_RTEMS ];
Event_Control *event = &api->System_event;
if ( !_Event_sets_Is_empty( event_in ) ) {
_Thread_Disable_dispatch();
_Event_Seize(
f990: e59fc028 ldr ip, [pc, #40] ; f9c0 <rtems_event_system_receive+0x80>
rtems_status_code sc;
if ( event_out != NULL ) {
Thread_Control *executing = _Thread_Executing;
RTEMS_API_Control *api = executing->API_Extensions[ THREAD_API_RTEMS ];
Event_Control *event = &api->System_event;
f994: e2866004 add r6, r6, #4
if ( !_Event_sets_Is_empty( event_in ) ) {
_Thread_Disable_dispatch();
_Event_Seize(
f998: e58dc008 str ip, [sp, #8]
f99c: e3a0c701 mov ip, #262144 ; 0x40000
f9a0: e58dc00c str ip, [sp, #12]
f9a4: e88d0050 stm sp, {r4, r6}
f9a8: ebffdeef bl 756c <_Event_Seize>
executing,
event,
&_System_event_Sync_state,
STATES_WAITING_FOR_SYSTEM_EVENT
);
_Thread_Enable_dispatch();
f9ac: ebffea0c bl a1e4 <_Thread_Enable_dispatch>
sc = executing->Wait.return_code;
f9b0: e5940034 ldr r0, [r4, #52] ; 0x34
f9b4: eaffffef b f978 <rtems_event_system_receive+0x38>
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: e92d4010 push {r4, lr} <== NOT EXECUTED
va_list args; va_start (args, format); fprintf (stderr, "fdisk:abort:");
6a0: e59f4058 ldr r4, [pc, #88] ; 700 <bsp_section_fast_text_load_begin+0x68><== NOT EXECUTED
6a4: e5943000 ldr r3, [r4] <== NOT EXECUTED
* @param format The format string. See printf for details.
* @param ... The arguments for the format text.
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
6a8: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
va_list args; va_start (args, format);
6ac: e28dc010 add ip, sp, #16 <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
6b0: e3a01001 mov r1, #1 <== NOT EXECUTED
6b4: e593300c ldr r3, [r3, #12] <== NOT EXECUTED
6b8: e3a0200c mov r2, #12 <== NOT EXECUTED
6bc: e59f0040 ldr r0, [pc, #64] ; 704 <bsp_section_fast_text_load_begin+0x6c><== NOT EXECUTED
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
va_list args;
va_start (args, format);
6c0: e58dc000 str ip, [sp] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
6c4: eb007e38 bl 1ffac <fwrite> <== NOT EXECUTED
vfprintf (stderr, format, args);
6c8: e5943000 ldr r3, [r4] <== NOT EXECUTED
6cc: e59d2000 ldr r2, [sp] <== NOT EXECUTED
6d0: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED
6d4: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
6d8: eb009f56 bl 28438 <vfprintf> <== NOT EXECUTED
fprintf (stderr, "\n");
6dc: e5943000 ldr r3, [r4] <== NOT EXECUTED
6e0: e3a0000a mov r0, #10 <== NOT EXECUTED
6e4: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
6e8: eb007db3 bl 1fdbc <fputc> <== NOT EXECUTED
fflush (stderr);
6ec: e5943000 ldr r3, [r4] <== NOT EXECUTED
6f0: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
6f4: eb007ca3 bl 1f988 <fflush> <== NOT EXECUTED
va_end (args); exit (1);
6f8: e3a00001 mov r0, #1 <== NOT EXECUTED
6fc: eb007ba8 bl 1f5a4 <exit> <== NOT EXECUTED
0000474c <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)
{
474c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
static bool
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
4750: e5902028 ldr r2, [r0, #40] ; 0x28
4754: e5903024 ldr r3, [r0, #36] ; 0x24
4758: 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)
{
475c: e24dd014 sub sp, sp, #20
4760: 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)
4764: 2a00001a bcs 47d4 <rtems_fdisk_compact+0x88>
fd->starvations++;
4768: e5903070 ldr r3, [r0, #112] ; 0x70
476c: e2833001 add r3, r3, #1
4770: 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");
4774: e59f1250 ldr r1, [pc, #592] ; 49cc <rtems_fdisk_compact+0x280>
4778: ebfffccf bl 3abc <rtems_fdisk_printf>
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
477c: e5945040 ldr r5, [r4, #64] ; 0x40
4780: e3550000 cmp r5, #0
4784: 0a000073 beq 4958 <rtems_fdisk_compact+0x20c>
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
4788: e5953000 ldr r3, [r5]
if (!queue->head)
478c: e3530000 cmp r3, #0
{
if (queue->head)
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
4790: e5843040 str r3, [r4, #64] ; 0x40
if (!queue->head)
queue->tail = 0;
4794: 05843044 streq r3, [r4, #68] ; 0x44
queue->count--;
4798: e5943048 ldr r3, [r4, #72] ; 0x48
479c: e2433001 sub r3, r3, #1
47a0: e5843048 str r3, [r4, #72] ; 0x48
sc->next = 0;
47a4: e3a03000 mov r3, #0
47a8: e5853000 str r3, [r5]
if (!ssc)
ssc = rtems_fdisk_segment_queue_pop_head (&fd->available);
if (ssc)
{
dsc = rtems_fdisk_seg_most_available (&fd->available);
47ac: e2840034 add r0, r4, #52 ; 0x34
47b0: ebfffc84 bl 39c8 <rtems_fdisk_seg_most_available>
if (dsc)
47b4: e2502000 subs r2, r0, #0
47b8: 0a000073 beq 498c <rtems_fdisk_compact+0x240>
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
47bc: e1a00004 mov r0, r4
47c0: e1a01005 mov r1, r5
47c4: e28d3010 add r3, sp, #16
47c8: ebfffeda bl 4338 <rtems_fdisk_recycle_segment>
if (ret)
47cc: e3500000 cmp r0, #0
47d0: 1a000038 bne 48b8 <rtems_fdisk_compact+0x16c>
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
47d4: e284c034 add ip, r4, #52 ; 0x34
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
47d8: e5941040 ldr r1, [r4, #64] ; 0x40
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
47dc: e58dc008 str ip, [sp, #8]
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
47e0: e3a0a000 mov sl, #0
rtems_fdisk_error ("compacting: nothing to recycle");
return EIO;
}
}
while (fd->used.head)
47e4: e3510000 cmp r1, #0
47e8: 0a000071 beq 49b4 <rtems_fdisk_compact+0x268>
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
47ec: e59f11dc ldr r1, [pc, #476] ; 49d0 <rtems_fdisk_compact+0x284>
47f0: e1a00004 mov r0, r4
47f4: ebfffcb0 bl 3abc <rtems_fdisk_printf>
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
47f8: e59d0008 ldr r0, [sp, #8]
47fc: ebfffc71 bl 39c8 <rtems_fdisk_seg_most_available>
if (dsc == 0)
4800: e2508000 subs r8, r0, #0
4804: 0a000066 beq 49a4 <rtems_fdisk_compact+0x258>
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
4808: e288601c add r6, r8, #28
{
rtems_fdisk_error ("compacting: no available segments to compact too");
return EIO;
}
ssc = fd->used.head;
480c: e5945040 ldr r5, [r4, #64] ; 0x40
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
4810: e89610c0 ldm r6, {r6, r7, ip}
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
pages = 0;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
4814: e2882008 add r2, r8, #8
}
ssc = fd->used.head;
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
pages = 0;
4818: e3a09000 mov r9, #0
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
481c: e1a00004 mov r0, r4
4820: e59f11ac ldr r1, [pc, #428] ; 49d4 <rtems_fdisk_compact+0x288>
4824: e892000c ldm r2, {r2, r3}
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
4828: e598b014 ldr fp, [r8, #20]
482c: e58dc00c str ip, [sp, #12]
}
ssc = fd->used.head;
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
pages = 0;
4830: e58d9010 str r9, [sp, #16]
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
4834: ebfffca0 bl 3abc <rtems_fdisk_printf>
* 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 &&
4838: e1550009 cmp r5, r9
483c: 0a000019 beq 48a8 <rtems_fdisk_compact+0x15c>
* with the most available number of pages and see if we have
* 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)
4840: e0876006 add r6, r7, r6
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
4844: e59d3010 ldr r3, [sp, #16]
4848: e595c01c ldr ip, [r5, #28]
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
484c: e59d200c ldr r2, [sp, #12]
4850: e066b00b rsb fp, r6, fp
4854: e062b00b rsb fp, r2, fp
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
4858: e083c00c add ip, r3, ip
* 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 &&
485c: e15c000b cmp ip, fp
4860: 2a00004d bcs 499c <rtems_fdisk_compact+0x250>
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
4864: e594100c ldr r1, [r4, #12]
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
4868: e15a0001 cmp sl, r1
486c: 3a000009 bcc 4898 <rtems_fdisk_compact+0x14c>
4870: ea000049 b 499c <rtems_fdisk_compact+0x250> <== NOT EXECUTED
4874: e595301c ldr r3, [r5, #28]
4878: e08c3003 add r3, ip, r3
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
segments++;
487c: e2899001 add r9, r9, #1
* 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 &&
4880: e153000b cmp r3, fp
((pages + ssc->pages_active) < dst_pages) &&
4884: e089200a add r2, r9, sl
* 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 &&
4888: 2a00000c bcs 48c0 <rtems_fdisk_compact+0x174>
((pages + ssc->pages_active) < dst_pages) &&
488c: e1520001 cmp r2, r1
4890: 2a00000a bcs 48c0 <rtems_fdisk_compact+0x174>
4894: e1a0c003 mov ip, r3
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
segments++;
ssc = ssc->next;
4898: e5955000 ldr r5, [r5]
* 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 &&
489c: e3550000 cmp r5, #0
48a0: 1afffff3 bne 4874 <rtems_fdisk_compact+0x128>
48a4: e58dc010 str ip, [sp, #16]
*/
if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " nothing to compact");
48a8: e1a00004 mov r0, r4
48ac: e59f1124 ldr r1, [pc, #292] ; 49d8 <rtems_fdisk_compact+0x28c>
48b0: ebfffc81 bl 3abc <rtems_fdisk_printf>
}
compacted_segs += segments;
}
return 0;
48b4: e3a00000 mov r0, #0
}
48b8: e28dd014 add sp, sp, #20
48bc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
48c0: e58dc010 str ip, [sp, #16]
* 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))
48c4: e35c0000 cmp ip, #0
48c8: 0afffff6 beq 48a8 <rtems_fdisk_compact+0x15c>
48cc: e08aa009 add sl, sl, r9
48d0: e35a0001 cmp sl, #1
48d4: 0afffff3 beq 48a8 <rtems_fdisk_compact+0x15c>
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
48d8: e2852008 add r2, r5, #8
48dc: e892000c ldm r2, {r2, r3}
48e0: e59f10f4 ldr r1, [pc, #244] ; 49dc <rtems_fdisk_compact+0x290>
48e4: e1a00004 mov r0, r4
48e8: e58dc000 str ip, [sp]
48ec: e58d9004 str r9, [sp, #4]
48f0: ebfffc71 bl 3abc <rtems_fdisk_printf>
ssc->device, ssc->segment,
pages, segments);
#endif
rtems_fdisk_segment_queue_remove (&fd->available, dsc);
48f4: e59d0008 ldr r0, [sp, #8]
48f8: e1a01008 mov r1, r8
48fc: ebfffbd4 bl 3854 <rtems_fdisk_segment_queue_remove>
if (!queue->head)
queue->tail = 0;
queue->count--;
sc->next = 0;
4900: e3a05000 mov r5, #0
/*
* We now copy the pages to the new segment.
*/
while (pages)
4904: e59d3010 ldr r3, [sp, #16]
4908: e3530000 cmp r3, #0
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
if (ssc)
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
if (ret)
490c: e5941040 ldr r1, [r4, #64] ; 0x40
/*
* We now copy the pages to the new segment.
*/
while (pages)
4910: 0affffb3 beq 47e4 <rtems_fdisk_compact+0x98>
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
4914: e3510000 cmp r1, #0
4918: 0afffffd beq 4914 <rtems_fdisk_compact+0x1c8>
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
491c: e5913000 ldr r3, [r1]
if (!queue->head)
4920: e3530000 cmp r3, #0
queue->tail = 0;
4924: 05843044 streq r3, [r4, #68] ; 0x44
{
if (queue->head)
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
4928: e5843040 str r3, [r4, #64] ; 0x40
if (!queue->head)
queue->tail = 0;
queue->count--;
492c: e5943048 ldr r3, [r4, #72] ; 0x48
4930: e2433001 sub r3, r3, #1
4934: e5843048 str r3, [r4, #72] ; 0x48
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
if (ssc)
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
4938: e1a00004 mov r0, r4
if (!queue->head)
queue->tail = 0;
queue->count--;
sc->next = 0;
493c: e5815000 str r5, [r1]
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
if (ssc)
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
4940: e1a02008 mov r2, r8
4944: e28d3010 add r3, sp, #16
4948: ebfffe7a bl 4338 <rtems_fdisk_recycle_segment>
if (ret)
494c: e3500000 cmp r0, #0
4950: 0affffeb beq 4904 <rtems_fdisk_compact+0x1b8>
4954: eaffffd7 b 48b8 <rtems_fdisk_compact+0x16c> <== NOT EXECUTED
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
4958: e5945034 ldr r5, [r4, #52] ; 0x34 <== NOT EXECUTED
495c: e3550000 cmp r5, #0 <== NOT EXECUTED
4960: 0a000015 beq 49bc <rtems_fdisk_compact+0x270> <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
4964: e5953000 ldr r3, [r5] <== NOT EXECUTED
if (!queue->head)
4968: e3530000 cmp r3, #0 <== NOT EXECUTED
{
if (queue->head)
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
496c: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED
if (!queue->head)
queue->tail = 0;
4970: 05843038 streq r3, [r4, #56] ; 0x38 <== NOT EXECUTED
queue->count--;
4974: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
4978: e2433001 sub r3, r3, #1 <== NOT EXECUTED
497c: e584303c str r3, [r4, #60] ; 0x3c <== NOT EXECUTED
sc->next = 0;
4980: e3a03000 mov r3, #0 <== NOT EXECUTED
4984: e5853000 str r3, [r5] <== NOT EXECUTED
4988: eaffff87 b 47ac <rtems_fdisk_compact+0x60> <== NOT EXECUTED
if (ret)
return ret;
}
else
{
rtems_fdisk_error ("compacting: starvation");
498c: e59f004c ldr r0, [pc, #76] ; 49e0 <rtems_fdisk_compact+0x294><== NOT EXECUTED
4990: ebfffd26 bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
return EIO;
4994: e3a00005 mov r0, #5 <== NOT EXECUTED
4998: eaffffc6 b 48b8 <rtems_fdisk_compact+0x16c> <== NOT EXECUTED
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
499c: e1a0c003 mov ip, r3
49a0: eaffffc7 b 48c4 <rtems_fdisk_compact+0x178>
dsc = rtems_fdisk_seg_most_available (&fd->available);
if (dsc == 0)
{
rtems_fdisk_error ("compacting: no available segments to compact too");
49a4: e59f0038 ldr r0, [pc, #56] ; 49e4 <rtems_fdisk_compact+0x298><== NOT EXECUTED
49a8: ebfffd20 bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
return EIO;
49ac: e3a00005 mov r0, #5 <== NOT EXECUTED
49b0: eaffffc0 b 48b8 <rtems_fdisk_compact+0x16c> <== NOT EXECUTED
}
compacted_segs += segments;
}
return 0;
49b4: e1a00001 mov r0, r1
49b8: eaffffbe b 48b8 <rtems_fdisk_compact+0x16c>
return EIO;
}
}
else
{
rtems_fdisk_error ("compacting: nothing to recycle");
49bc: e59f0024 ldr r0, [pc, #36] ; 49e8 <rtems_fdisk_compact+0x29c><== NOT EXECUTED
49c0: ebfffd1a bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
return EIO;
49c4: e3a00005 mov r0, #5 <== NOT EXECUTED
49c8: eaffffba b 48b8 <rtems_fdisk_compact+0x16c> <== NOT EXECUTED
00003eb0 <rtems_fdisk_erase_segment>:
/**
* Erase the segment.
*/
static int
rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
3eb0: e92d41f0 push {r4, r5, r6, r7, r8, lr}
3eb4: e1a04001 mov r4, r1
int ret; uint32_t device; uint32_t segment; const rtems_fdisk_segment_desc* sd; const rtems_fdisk_driver_handlers* ops; device = sc->device;
3eb8: e5911008 ldr r1, [r1, #8]
/**
* Erase the segment.
*/
static int
rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
3ebc: 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;
3ec0: e0813081 add r3, r1, r1, lsl #1
3ec4: e590002c ldr r0, [r0, #44] ; 0x2c
3ec8: e1a03103 lsl r3, r3, #2
uint32_t device; uint32_t segment; const rtems_fdisk_segment_desc* sd; const rtems_fdisk_driver_handlers* ops; device = sc->device; segment = sc->segment;
3ecc: e594200c ldr r2, [r4, #12]
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;
3ed0: e080c003 add ip, r0, r3
3ed4: e7900003 ldr r0, [r0, r3]
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;
3ed8: e59c3008 ldr r3, [ip, #8]
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;
3edc: e082c082 add ip, r2, r2, lsl #1
3ee0: e080020c add r0, r0, ip, lsl #4
/**
* Erase the segment.
*/
static int
rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
3ee4: e24dd004 sub sp, sp, #4
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; ret = ops->erase (sd, device, segment);
3ee8: e5933008 ldr r3, [r3, #8]
3eec: e5900004 ldr r0, [r0, #4]
3ef0: e1a0e00f mov lr, pc
3ef4: e593f010 ldr pc, [r3, #16]
if (ret)
3ef8: e2506000 subs r6, r0, #0
3efc: 0a000019 beq 3f68 <rtems_fdisk_erase_segment+0xb8>
{
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
3f00: e5948008 ldr r8, [r4, #8] <== NOT EXECUTED
3f04: e594700c ldr r7, [r4, #12] <== NOT EXECUTED
3f08: eb007613 bl 2175c <strerror> <== NOT EXECUTED
3f0c: e1a02007 mov r2, r7 <== NOT EXECUTED
3f10: e1a03000 mov r3, r0 <== NOT EXECUTED
3f14: e1a01008 mov r1, r8 <== NOT EXECUTED
3f18: e59f00dc ldr r0, [pc, #220] ; 3ffc <rtems_fdisk_erase_segment+0x14c><== NOT EXECUTED
3f1c: e58d6000 str r6, [sp] <== NOT EXECUTED
3f20: ebffffc2 bl 3e30 <rtems_fdisk_error> <== 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;
3f24: e5953058 ldr r3, [r5, #88] ; 0x58 <== NOT EXECUTED
if (ret)
{
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
"segment erase failed: %s (%d)",
sc->device, sc->segment, strerror (ret), ret);
sc->failed = true;
3f28: e3a02001 mov r2, #1 <== 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)
3f2c: e3530000 cmp r3, #0 <== NOT EXECUTED
if (ret)
{
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
"segment erase failed: %s (%d)",
sc->device, sc->segment, strerror (ret), ret);
sc->failed = true;
3f30: e5842028 str r2, [r4, #40] ; 0x28 <== 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)
3f34: 1a000006 bne 3f54 <rtems_fdisk_erase_segment+0xa4> <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
3f38: e5843000 str r3, [r4] <== NOT EXECUTED
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
3f3c: e585405c str r4, [r5, #92] ; 0x5c <== NOT EXECUTED
3f40: e5854058 str r4, [r5, #88] ; 0x58 <== NOT EXECUTED
3f44: ea000028 b 3fec <rtems_fdisk_erase_segment+0x13c> <== NOT EXECUTED
while (it)
{
if (it == sc)
return true;
it = it->next;
3f48: 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)
3f4c: e3530000 cmp r3, #0 <== NOT EXECUTED
3f50: 0a000021 beq 3fdc <rtems_fdisk_erase_segment+0x12c> <== NOT EXECUTED
{
if (it == sc)
3f54: e1540003 cmp r4, r3 <== NOT EXECUTED
3f58: 1afffffa bne 3f48 <rtems_fdisk_erase_segment+0x98> <== NOT EXECUTED
* segment will now get a go.
*/
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
return 0;
}
3f5c: e1a00006 mov r0, r6
3f60: e28dd004 add sp, sp, #4
3f64: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
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;
3f68: e595c028 ldr ip, [r5, #40] ; 0x28
sc->erased++;
3f6c: e594102c ldr r1, [r4, #44] ; 0x2c
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;
3f70: e5940014 ldr r0, [r4, #20]
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
3f74: e5953014 ldr r3, [r5, #20]
3f78: e5942018 ldr r2, [r4, #24]
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;
3f7c: e08c0000 add r0, ip, r0
sc->erased++;
3f80: e2811001 add r1, r1, #1
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;
3f84: e5850028 str r0, [r5, #40] ; 0x28
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
3f88: e0020293 mul r2, r3, r2
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
sc->erased++;
3f8c: e584102c str r1, [r4, #44] ; 0x2c
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
3f90: e5940010 ldr r0, [r4, #16]
3f94: e3a010ff mov r1, #255 ; 0xff
3f98: eb0070d0 bl 202e0 <memset>
{
if (sc)
{
sc->next = 0;
if (queue->head)
3f9c: e5953034 ldr r3, [r5, #52] ; 0x34
3fa0: e3530000 cmp r3, #0
{
queue->tail->next = sc;
3fa4: 15953038 ldrne r3, [r5, #56] ; 0x38
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
3fa8: e5846000 str r6, [r4]
if (queue->head)
{
queue->tail->next = sc;
3fac: 15834000 strne r4, [r3]
else
{
queue->head = queue->tail = sc;
}
queue->count++;
3fb0: e595303c ldr r3, [r5, #60] ; 0x3c
3fb4: e2833001 add r3, r3, #1
fd->erased_blocks += sc->pages;
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
sc->pages_active = 0;
3fb8: e584601c str r6, [r4, #28]
sc->pages_used = 0;
3fbc: e5846020 str r6, [r4, #32]
sc->pages_bad = 0;
3fc0: e5846024 str r6, [r4, #36] ; 0x24
sc->failed = false;
3fc4: e5846028 str r6, [r4, #40] ; 0x28
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
queue->tail = sc;
3fc8: 15854038 strne r4, [r5, #56] ; 0x38
}
else
{
queue->head = queue->tail = sc;
3fcc: 05854038 streq r4, [r5, #56] ; 0x38
3fd0: 05854034 streq r4, [r5, #52] ; 0x34
}
queue->count++;
3fd4: e585303c str r3, [r5, #60] ; 0x3c
3fd8: eaffffdf b 3f5c <rtems_fdisk_erase_segment+0xac>
{
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
3fdc: e595205c ldr r2, [r5, #92] ; 0x5c <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
3fe0: e5843000 str r3, [r4] <== NOT EXECUTED
if (queue->head)
{
queue->tail->next = sc;
3fe4: e5824000 str r4, [r2] <== NOT EXECUTED
queue->tail = sc;
3fe8: e585405c str r4, [r5, #92] ; 0x5c <== NOT EXECUTED
else
{
queue->head = queue->tail = sc;
}
queue->count++;
3fec: e5953060 ldr r3, [r5, #96] ; 0x60 <== NOT EXECUTED
3ff0: e2833001 add r3, r3, #1 <== NOT EXECUTED
3ff4: e5853060 str r3, [r5, #96] ; 0x60 <== NOT EXECUTED
3ff8: eaffffd7 b 3f5c <rtems_fdisk_erase_segment+0xac> <== NOT EXECUTED
00003e30 <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, ...)
{
3e30: e92d000f push {r0, r1, r2, r3} <== NOT EXECUTED
3e34: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
int ret; va_list args; va_start (args, format); fprintf (stderr, "fdisk:error:");
3e38: e59f4068 ldr r4, [pc, #104] ; 3ea8 <rtems_fdisk_error+0x78><== NOT EXECUTED
3e3c: e5943000 ldr r3, [r4] <== NOT EXECUTED
* @param ... The arguments for the format text.
* @return int The number of bytes written to the output.
*/
static int
rtems_fdisk_error (const char *format, ...)
{
3e40: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
int ret; va_list args; va_start (args, format);
3e44: e28dc014 add ip, sp, #20 <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
3e48: e3a01001 mov r1, #1 <== NOT EXECUTED
3e4c: e593300c ldr r3, [r3, #12] <== NOT EXECUTED
3e50: e3a0200c mov r2, #12 <== NOT EXECUTED
3e54: e59f0050 ldr r0, [pc, #80] ; 3eac <rtems_fdisk_error+0x7c> <== NOT EXECUTED
static int
rtems_fdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
3e58: e58dc000 str ip, [sp] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
3e5c: eb007052 bl 1ffac <fwrite> <== NOT EXECUTED
ret = vfprintf (stderr, format, args);
3e60: e5943000 ldr r3, [r4] <== NOT EXECUTED
3e64: e59d2000 ldr r2, [sp] <== NOT EXECUTED
3e68: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
3e6c: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
3e70: eb009170 bl 28438 <vfprintf> <== NOT EXECUTED
fprintf (stderr, "\n");
3e74: e5943000 ldr r3, [r4] <== NOT EXECUTED
{
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "fdisk:error:");
ret = vfprintf (stderr, format, args);
3e78: e1a05000 mov r5, r0 <== NOT EXECUTED
fprintf (stderr, "\n");
3e7c: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
3e80: e3a0000a mov r0, #10 <== NOT EXECUTED
3e84: eb006fcc bl 1fdbc <fputc> <== NOT EXECUTED
fflush (stderr);
3e88: e5943000 ldr r3, [r4] <== NOT EXECUTED
3e8c: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
3e90: eb006ebc bl 1f988 <fflush> <== NOT EXECUTED
va_end (args); return ret; }
3e94: e1a00005 mov r0, r5 <== NOT EXECUTED
3e98: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3e9c: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
3ea0: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3ea4: e12fff1e bx lr <== NOT EXECUTED
00003a2c <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, ...)
{
3a2c: e92d000e push {r1, r2, r3}
3a30: e92d4030 push {r4, r5, lr}
int ret = 0; if (fd->info_level >= 2)
3a34: e590306c ldr r3, [r0, #108] ; 0x6c
3a38: 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, ...)
{
3a3c: e24dd004 sub sp, sp, #4
int ret = 0;
3a40: 93a05000 movls r5, #0
if (fd->info_level >= 2)
3a44: 9a000015 bls 3aa0 <rtems_fdisk_info+0x74>
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:");
3a48: e59f4064 ldr r4, [pc, #100] ; 3ab4 <rtems_fdisk_info+0x88> <== NOT EXECUTED
3a4c: e5943000 ldr r3, [r4] <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
3a50: e28dc014 add ip, sp, #20 <== NOT EXECUTED
fprintf (stdout, "fdisk:");
3a54: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
3a58: e3a01001 mov r1, #1 <== NOT EXECUTED
3a5c: e3a02006 mov r2, #6 <== NOT EXECUTED
3a60: e59f0050 ldr r0, [pc, #80] ; 3ab8 <rtems_fdisk_info+0x8c> <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
3a64: e58dc000 str ip, [sp] <== NOT EXECUTED
fprintf (stdout, "fdisk:");
3a68: eb00714f bl 1ffac <fwrite> <== NOT EXECUTED
ret = vfprintf (stdout, format, args);
3a6c: e5943000 ldr r3, [r4] <== NOT EXECUTED
3a70: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
3a74: e59d2000 ldr r2, [sp] <== NOT EXECUTED
3a78: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
3a7c: eb00926d bl 28438 <vfprintf> <== NOT EXECUTED
fprintf (stdout, "\n");
3a80: 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);
3a84: e1a05000 mov r5, r0 <== NOT EXECUTED
fprintf (stdout, "\n");
3a88: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED
3a8c: e3a0000a mov r0, #10 <== NOT EXECUTED
3a90: eb0070c9 bl 1fdbc <fputc> <== NOT EXECUTED
fflush (stdout);
3a94: e5943000 ldr r3, [r4] <== NOT EXECUTED
3a98: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
3a9c: eb006fb9 bl 1f988 <fflush> <== NOT EXECUTED
va_end (args);
}
return ret;
}
3aa0: e1a00005 mov r0, r5
3aa4: e28dd004 add sp, sp, #4
3aa8: e8bd4030 pop {r4, r5, lr}
3aac: e28dd00c add sp, sp, #12
3ab0: e12fff1e bx lr
000061f4 <rtems_fdisk_initialize>:
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
rtems_device_minor_number minor,
void* arg __attribute__((unused)))
{
61f4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
61f8: e24dd038 sub sp, sp, #56 ; 0x38
61fc: e58d0024 str r0, [sp, #36] ; 0x24
const rtems_flashdisk_config* c = rtems_flashdisk_configuration;
rtems_flashdisk* fd;
rtems_status_code sc;
sc = rtems_disk_io_initialize ();
6200: ebfff543 bl 3714 <rtems_disk_io_initialize>
if (sc != RTEMS_SUCCESSFUL)
6204: e2506000 subs r6, r0, #0
6208: 11a00006 movne r0, r6
620c: 0a000001 beq 6218 <rtems_fdisk_initialize+0x24>
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
return RTEMS_SUCCESSFUL;
}
6210: e28dd038 add sp, sp, #56 ; 0x38
6214: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
static rtems_status_code
rtems_fdisk_crc16_gen_factors (uint16_t pattern)
{
uint32_t b;
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
6218: e3a00c02 mov r0, #512 ; 0x200
621c: eb000584 bl 7834 <malloc>
6220: e59f151c ldr r1, [pc, #1308] ; 6744 <rtems_fdisk_initialize+0x550>
if (!rtems_fdisk_crc16_factor)
6224: 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);
6228: e5810008 str r0, [r1, #8]
if (!rtems_fdisk_crc16_factor)
622c: 0a0000ea beq 65dc <rtems_fdisk_initialize+0x3e8>
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;
6230: e59f2510 ldr r2, [pc, #1296] ; 6748 <rtems_fdisk_initialize+0x554>
* @param major Flash disk major device number. * @param minor Minor device number, not applicable. * @param arg Initialization argument, not applicable. */ rtems_device_driver rtems_fdisk_initialize (rtems_device_major_number major,
6234: e2400002 sub r0, r0, #2
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
6238: e1a03806 lsl r3, r6, #16
623c: e1a03823 lsr r3, r3, #16
6240: e3a04008 mov r4, #8
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
6244: e3130001 tst r3, #1
6248: 102230a3 eorne r3, r2, r3, lsr #1
624c: 11a03803 lslne r3, r3, #16
6250: 11a03823 lsrne r3, r3, #16
6254: 01a030a3 lsreq r3, r3, #1
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
6258: e2544001 subs r4, r4, #1
625c: 1afffff8 bne 6244 <rtems_fdisk_initialize+0x50>
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_fdisk_crc16_factor)
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
6260: e2866001 add r6, r6, #1
6264: e3560c01 cmp r6, #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;
6268: e1e030b2 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++)
626c: 1afffff1 bne 6238 <rtems_fdisk_initialize+0x44>
sc = rtems_fdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
6270: e59f14d4 ldr r1, [pc, #1236] ; 674c <rtems_fdisk_initialize+0x558>
6274: e5915000 ldr r5, [r1]
6278: e3a01074 mov r1, #116 ; 0x74
627c: e1a00005 mov r0, r5
6280: eb000307 bl 6ea4 <calloc>
6284: e59f24b8 ldr r2, [pc, #1208] ; 6744 <rtems_fdisk_initialize+0x550>
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
6288: e3500000 cmp r0, #0
sc = rtems_fdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
628c: e1a03000 mov r3, r0
6290: e5820000 str r0, [r2]
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
6294: 0a0000d0 beq 65dc <rtems_fdisk_initialize+0x3e8>
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
6298: e3550000 cmp r5, #0
629c: 0a0000ec beq 6654 <rtems_fdisk_initialize+0x460>
62a0: e59f54a8 ldr r5, [pc, #1192] ; 6750 <rtems_fdisk_initialize+0x55c>
62a4: e58d4028 str r4, [sp, #40] ; 0x28
62a8: e58d5018 str r5, [sp, #24]
62ac: e58d401c str r4, [sp, #28]
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
62b0: e59f549c ldr r5, [pc, #1180] ; 6754 <rtems_fdisk_initialize+0x560>
62b4: e8950007 ldm r5, {r0, r1, r2}
62b8: e28dc02c add ip, sp, #44 ; 0x2c
62bc: e8ac0003 stmia ip!, {r0, r1}
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
62c0: e59d601c ldr r6, [sp, #28]
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";
62c4: e1a01802 lsl r1, r2, #16
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
62c8: e0861c21 add r1, r6, r1, lsr #24
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";
62cc: e1cc20b0 strh r2, [ip]
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
62d0: e5cd1035 strb r1, [sp, #53] ; 0x35
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++)
62d4: e59dc018 ldr ip, [sp, #24]
62d8: e51cc01c ldr ip, [ip, #-28]
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
fd->minor = minor;
fd->flags = c->flags;
62dc: e59d5018 ldr r5, [sp, #24]
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++)
62e0: e58dc020 str ip, [sp, #32]
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
fd->minor = minor;
fd->flags = c->flags;
62e4: e515e014 ldr lr, [r5, #-20]
fd->compact_segs = c->compact_segs;
62e8: e515c00c ldr ip, [r5, #-12]
fd->avail_compact_segs = c->avail_compact_segs;
62ec: e5150008 ldr r0, [r5, #-8]
fd->block_size = c->block_size;
62f0: e5158020 ldr r8, [r5, #-32]
fd->unavail_blocks = c->unavail_blocks;
62f4: e5151010 ldr r1, [r5, #-16]
fd->info_level = c->info_level;
62f8: e5152004 ldr r2, [r5, #-4]
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
62fc: e59d6028 ldr r6, [sp, #40] ; 0x28
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++)
6300: e59d5020 ldr r5, [sp, #32]
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
6304: e0836006 add r6, r3, 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++)
6308: e3550000 cmp r5, #0
fd = &rtems_flashdisks[minor];
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
630c: e28d5024 add r5, sp, #36 ; 0x24
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
6310: e58d600c str r6, [sp, #12]
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
6314: e8950060 ldm r5, {r5, r6}
6318: e7835006 str r5, [r3, r6]
fd->minor = minor;
631c: e59d500c ldr r5, [sp, #12]
6320: e59d601c ldr r6, [sp, #28]
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
6324: e585c00c str ip, [r5, #12]
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
fd->minor = minor;
fd->flags = c->flags;
6328: e9854040 stmib r5, {r6, lr}
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
632c: e5850010 str r0, [r5, #16]
fd->block_size = c->block_size;
6330: e5858014 str r8, [r5, #20]
fd->unavail_blocks = c->unavail_blocks;
6334: e5851020 str r1, [r5, #32]
fd->info_level = c->info_level;
6338: e585206c str r2, [r5, #108] ; 0x6c
for (device = 0; device < c->device_count; device++)
633c: 0a0000b6 beq 661c <rtems_fdisk_initialize+0x428>
6340: e59dc018 ldr ip, [sp, #24]
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;
6344: e3a06000 mov r6, #0
6348: e58d6014 str r6, [sp, #20]
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++)
634c: e51cb018 ldr fp, [ip, #-24]
6350: e58d6010 str r6, [sp, #16]
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++)
6354: e59b9000 ldr r9, [fp]
6358: e3590000 cmp r9, #0
*/
static uint32_t
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
635c: 01a07009 moveq r7, r9
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
6360: 0a000011 beq 63ac <rtems_fdisk_initialize+0x1b8>
*/
static uint32_t
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
6364: e3a07000 mov r7, #0
uint32_t s; for (s = 0; s < dd->segment_count; s++)
6368: e59b6004 ldr r6, [fp, #4]
636c: e1a05007 mov r5, r7
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
6370: e5960008 ldr r0, [r6, #8]
6374: e1a01008 mov r1, r8
6378: ebffedca bl 1aa8 <__aeabi_uidiv>
637c: e1a0a000 mov sl, 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);
6380: e1a00180 lsl r0, r0, #3
return ((bytes - 1) / page_size) + 1;
6384: e2400001 sub r0, r0, #1
6388: e1a01008 mov r1, r8
638c: ebffedc5 bl 1aa8 <__aeabi_uidiv>
6390: e24aa001 sub sl, sl, #1
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++)
6394: e2855001 add r5, r5, #1
{
const rtems_fdisk_segment_desc* sd = &dd->segments[s];
count +=
(rtems_fdisk_pages_in_segment (sd, page_size) -
rtems_fdisk_page_desc_pages (sd, page_size)) * sd->count;
6398: e0d630bc ldrh r3, [r6], #12
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) -
639c: e060000a rsb r0, r0, sl
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++)
63a0: e1550009 cmp r5, r9
{
const rtems_fdisk_segment_desc* sd = &dd->segments[s];
count +=
63a4: e0277093 mla r7, r3, r0, r7
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++)
63a8: 1afffff0 bne 6370 <rtems_fdisk_initialize+0x17c>
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++)
63ac: e59d2010 ldr r2, [sp, #16]
blocks += rtems_fdisk_blocks_in_device (&c->devices[device],
63b0: e59d5014 ldr r5, [sp, #20]
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++)
63b4: e59d3020 ldr r3, [sp, #32]
63b8: e2822001 add r2, r2, #1
blocks += rtems_fdisk_blocks_in_device (&c->devices[device],
63bc: e0855007 add r5, r5, r7
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++)
63c0: e1520003 cmp r2, r3
63c4: e58d2010 str r2, [sp, #16]
blocks += rtems_fdisk_blocks_in_device (&c->devices[device],
63c8: e58d5014 str r5, [sp, #20]
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++)
63cc: e28bb00c add fp, fp, #12
63d0: 1affffdf bne 6354 <rtems_fdisk_initialize+0x160>
c->block_size);
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
63d4: e1a00008 mov r0, r8
63d8: eb000515 bl 7834 <malloc>
63dc: e59dc00c ldr ip, [sp, #12]
if (!fd->copy_buffer)
63e0: e3500000 cmp r0, #0
c->block_size);
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
63e4: e58c0068 str r0, [ip, #104] ; 0x68
if (!fd->copy_buffer)
63e8: 0a00007b beq 65dc <rtems_fdisk_initialize+0x3e8>
return RTEMS_NO_MEMORY;
fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));
63ec: e59d0014 ldr r0, [sp, #20]
63f0: e3a01008 mov r1, #8
63f4: eb0002aa bl 6ea4 <calloc>
63f8: e59d500c ldr r5, [sp, #12]
if (!fd->blocks)
63fc: 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));
6400: e5850018 str r0, [r5, #24]
if (!fd->blocks)
6404: 0a000074 beq 65dc <rtems_fdisk_initialize+0x3e8>
return RTEMS_NO_MEMORY;
fd->block_count = blocks;
6408: e59d6014 ldr r6, [sp, #20]
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
640c: e59d0020 ldr r0, [sp, #32]
fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));
if (!fd->blocks)
return RTEMS_NO_MEMORY;
fd->block_count = blocks;
6410: e585601c str r6, [r5, #28]
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
6414: e3a0100c mov r1, #12
6418: eb0002a1 bl 6ea4 <calloc>
if (!fd->devices)
641c: 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));
6420: e585002c str r0, [r5, #44] ; 0x2c
if (!fd->devices)
6424: 0a00006c beq 65dc <rtems_fdisk_initialize+0x3e8>
return RTEMS_NO_MEMORY;
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
6428: e285c064 add ip, r5, #100 ; 0x64
642c: e59f0324 ldr r0, [pc, #804] ; 6758 <rtems_fdisk_initialize+0x564>
6430: e3a01001 mov r1, #1
6434: e3a02054 mov r2, #84 ; 0x54
6438: e3a03000 mov r3, #0
643c: e58dc000 str ip, [sp]
6440: eb001552 bl b990 <rtems_semaphore_create>
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &fd->lock);
if (sc != RTEMS_SUCCESSFUL)
6444: e2506000 subs r6, r0, #0
6448: 1a000076 bne 6628 <rtems_fdisk_initialize+0x434>
free (fd->blocks);
free (fd->devices);
return sc;
}
sc = rtems_disk_create_phys(dev, c->block_size,
644c: e59dc018 ldr ip, [sp, #24]
6450: e59d500c ldr r5, [sp, #12]
6454: e51c2020 ldr r2, [ip, #-32]
6458: e5953020 ldr r3, [r5, #32]
645c: e59dc014 ldr ip, [sp, #20]
6460: e063300c rsb r3, r3, ip
6464: e59fc2f0 ldr ip, [pc, #752] ; 675c <rtems_fdisk_initialize+0x568>
6468: e59d0024 ldr r0, [sp, #36] ; 0x24
646c: e59d101c ldr r1, [sp, #28]
6470: e28d502c add r5, sp, #44 ; 0x2c
6474: e58d6004 str r6, [sp, #4]
6478: e58dc000 str ip, [sp]
647c: e58d5008 str r5, [sp, #8]
6480: ebfff401 bl 348c <rtems_disk_create_phys>
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
6484: e2506000 subs r6, r0, #0
6488: 1a00009d bne 6704 <rtems_fdisk_initialize+0x510>
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
648c: e59dc018 ldr ip, [sp, #24]
6490: e51c901c ldr r9, [ip, #-28]
6494: e3590000 cmp r9, #0
6498: 0a000035 beq 6574 <rtems_fdisk_initialize+0x380>
rtems_disk_delete (dev);
free (fd->copy_buffer);
free (fd->blocks);
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
649c: e59dc00c ldr ip, [sp, #12]
64a0: e59d5018 ldr r5, [sp, #24]
64a4: e59ca02c ldr sl, [ip, #44] ; 0x2c
64a8: e5158018 ldr r8, [r5, #-24]
}
for (device = 0; device < c->device_count; device++)
64ac: e1a05006 mov r5, r6
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++)
64b0: e5987000 ldr r7, [r8]
64b4: e3570000 cmp r7, #0
* Count the segments for a device.
*/
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
64b8: 01a06007 moveq r6, r7
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
64bc: 0a000009 beq 64e8 <rtems_fdisk_initialize+0x2f4>
64c0: e3a03000 mov r3, #0
64c4: e5980004 ldr r0, [r8, #4]
* Count the segments for a device.
*/
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
64c8: e1a06003 mov r6, r3
uint32_t segment; for (segment = 0; segment < dd->segment_count; segment++)
64cc: e1a02003 mov r2, r3
count += dd->segments[segment].count;
64d0: e19010b3 ldrh r1, [r0, r3]
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++)
64d4: e2822001 add r2, r2, #1
64d8: e1520007 cmp r2, r7
count += dd->segments[segment].count;
64dc: e0866001 add r6, r6, r1
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++)
64e0: e283300c add r3, r3, #12
64e4: 1afffff9 bne 64d0 <rtems_fdisk_initialize+0x2dc>
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
64e8: e1a00006 mov r0, r6
64ec: e3a01030 mov r1, #48 ; 0x30
64f0: eb00026b bl 6ea4 <calloc>
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
64f4: 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,
64f8: e58a0000 str r0, [sl]
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
64fc: 0a000038 beq 65e4 <rtems_fdisk_initialize+0x3f0>
return RTEMS_NO_MEMORY;
}
sc = fd->devices[device].segments;
for (segment = 0; segment < c->devices[device].segment_count; segment++)
6500: e3570000 cmp r7, #0
6504: 0a000014 beq 655c <rtems_fdisk_initialize+0x368>
rtems_disk_delete (dev);
rtems_semaphore_delete (fd->lock);
free (fd->copy_buffer);
free (fd->blocks);
free (fd->devices);
return RTEMS_NO_MEMORY;
6508: e598c004 ldr ip, [r8, #4]
}
sc = fd->devices[device].segments;
for (segment = 0; segment < c->devices[device].segment_count; segment++)
650c: e3a0e000 mov lr, #0
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++)
6510: e1dc10b0 ldrh r1, [ip]
6514: e3510000 cmp r1, #0
6518: 0a00000b beq 654c <rtems_fdisk_initialize+0x358>
651c: e1a03000 mov r3, r0
6520: e3a02000 mov r2, #0
{
sc->descriptor = sd;
sc->device = device;
sc->segment = seg_segment;
6524: e583200c str r2, [r3, #12]
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++)
6528: e2822001 add r2, r2, #1
652c: e1520001 cmp r2, r1
{
sc->descriptor = sd;
6530: e583c004 str ip, [r3, #4]
sc->device = device;
6534: e5835008 str r5, [r3, #8]
sc->segment = seg_segment;
sc->erased = 0;
6538: e583402c str r4, [r3, #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++)
653c: e2833030 add r3, r3, #48 ; 0x30
6540: 3afffff7 bcc 6524 <rtems_fdisk_initialize+0x330>
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
6544: e0811081 add r1, r1, r1, lsl #1
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++)
6548: e0800201 add r0, r0, r1, lsl #4
return RTEMS_NO_MEMORY;
}
sc = fd->devices[device].segments;
for (segment = 0; segment < c->devices[device].segment_count; segment++)
654c: e28ee001 add lr, lr, #1
6550: e15e0007 cmp lr, r7
6554: e28cc00c add ip, ip, #12
6558: 1affffec bne 6510 <rtems_fdisk_initialize+0x31c>
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
655c: e2855001 add r5, r5, #1
6560: e1550009 cmp r5, r9
sc->segment = seg_segment;
sc->erased = 0;
}
}
fd->devices[device].segment_count = segment_count;
6564: e98a0140 stmib sl, {r6, r8}
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
6568: e288800c add r8, r8, #12
656c: e28aa00c add sl, sl, #12
6570: 1affffce bne 64b0 <rtems_fdisk_initialize+0x2bc>
fd->devices[device].segment_count = segment_count;
fd->devices[device].descriptor = &c->devices[device];
}
fd->device_count = c->device_count;
6574: e59d500c ldr r5, [sp, #12]
6578: e5859030 str r9, [r5, #48] ; 0x30
ret = rtems_fdisk_recover_block_mappings (fd);
657c: e1a00005 mov r0, r5
6580: ebfff919 bl 49ec <rtems_fdisk_recover_block_mappings>
if (ret)
6584: e2506000 subs r6, r0, #0
6588: 1a000049 bne 66b4 <rtems_fdisk_initialize+0x4c0>
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
strerror (ret), ret);
return ret;
}
ret = rtems_fdisk_compact (fd);
658c: e59d000c ldr r0, [sp, #12]
6590: ebfff86d bl 474c <rtems_fdisk_compact>
if (ret)
6594: e2506000 subs r6, r0, #0
6598: 1a000031 bne 6664 <rtems_fdisk_initialize+0x470>
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
659c: e59f61a8 ldr r6, [pc, #424] ; 674c <rtems_fdisk_initialize+0x558>
65a0: e59dc01c ldr ip, [sp, #28]
65a4: e5965000 ldr r5, [r6]
65a8: e28cc001 add ip, ip, #1
65ac: e59d6018 ldr r6, [sp, #24]
65b0: e58dc01c str ip, [sp, #28]
65b4: e155000c cmp r5, ip
65b8: e59dc028 ldr ip, [sp, #40] ; 0x28
65bc: e2866020 add r6, r6, #32
65c0: e28cc074 add ip, ip, #116 ; 0x74
65c4: e58d6018 str r6, [sp, #24]
65c8: e58dc028 str ip, [sp, #40] ; 0x28
65cc: 9a000020 bls 6654 <rtems_fdisk_initialize+0x460>
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_fdisk_crc16_factor)
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
65d0: e59f216c ldr r2, [pc, #364] ; 6744 <rtems_fdisk_initialize+0x550><== NOT EXECUTED
65d4: e5923000 ldr r3, [r2] <== NOT EXECUTED
65d8: eaffff34 b 62b0 <rtems_fdisk_initialize+0xbc> <== NOT EXECUTED
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
return RTEMS_NO_MEMORY;
65dc: e3a0001a mov r0, #26 <== NOT EXECUTED
65e0: eaffff0a b 6210 <rtems_fdisk_initialize+0x1c> <== NOT EXECUTED
65e4: e59d500c ldr r5, [sp, #12] <== NOT EXECUTED
fd->devices[device].segments = calloc (segment_count,
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
{
rtems_disk_delete (dev);
65e8: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED
65ec: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED
65f0: ebfff2fe bl 31f0 <rtems_disk_delete> <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
65f4: e5950064 ldr r0, [r5, #100] ; 0x64 <== NOT EXECUTED
65f8: eb001554 bl bb50 <rtems_semaphore_delete> <== NOT EXECUTED
free (fd->copy_buffer);
65fc: e5950068 ldr r0, [r5, #104] ; 0x68 <== NOT EXECUTED
6600: eb00030c bl 7238 <free> <== NOT EXECUTED
free (fd->blocks);
6604: e5950018 ldr r0, [r5, #24] <== NOT EXECUTED
6608: eb00030a bl 7238 <free> <== NOT EXECUTED
free (fd->devices);
660c: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED
6610: eb000308 bl 7238 <free> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
6614: e3a0001a mov r0, #26 <== NOT EXECUTED
6618: eafffefc b 6210 <rtems_fdisk_initialize+0x1c> <== NOT EXECUTED
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;
661c: e59d6020 ldr r6, [sp, #32] <== NOT EXECUTED
6620: e58d6014 str r6, [sp, #20] <== NOT EXECUTED
6624: eaffff6a b 63d4 <rtems_fdisk_initialize+0x1e0> <== NOT EXECUTED
6628: e59d500c ldr r5, [sp, #12] <== NOT EXECUTED
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &fd->lock);
if (sc != RTEMS_SUCCESSFUL)
{
rtems_fdisk_error ("disk lock create failed");
662c: e59f012c ldr r0, [pc, #300] ; 6760 <rtems_fdisk_initialize+0x56c><== NOT EXECUTED
6630: ebfff5fe bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
free (fd->copy_buffer);
6634: e5950068 ldr r0, [r5, #104] ; 0x68 <== NOT EXECUTED
6638: eb0002fe bl 7238 <free> <== NOT EXECUTED
free (fd->blocks);
663c: e5950018 ldr r0, [r5, #24] <== NOT EXECUTED
6640: eb0002fc bl 7238 <free> <== NOT EXECUTED
free (fd->devices);
6644: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED
6648: eb0002fa bl 7238 <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,
664c: e1a00006 mov r0, r6 <== NOT EXECUTED
{
rtems_fdisk_error ("disk lock create failed");
free (fd->copy_buffer);
free (fd->blocks);
free (fd->devices);
return sc;
6650: eafffeee b 6210 <rtems_fdisk_initialize+0x1c> <== NOT EXECUTED
strerror (ret), ret);
return ret;
}
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
6654: e59f00e8 ldr r0, [pc, #232] ; 6744 <rtems_fdisk_initialize+0x550>
6658: e5805004 str r5, [r0, #4]
return RTEMS_SUCCESSFUL;
665c: e3a00000 mov r0, #0
6660: eafffeea b 6210 <rtems_fdisk_initialize+0x1c>
6664: e59d500c ldr r5, [sp, #12] <== NOT EXECUTED
}
ret = rtems_fdisk_compact (fd);
if (ret)
{
rtems_disk_delete (dev);
6668: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED
666c: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED
6670: ebfff2de bl 31f0 <rtems_disk_delete> <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
6674: e5950064 ldr r0, [r5, #100] ; 0x64 <== NOT EXECUTED
6678: eb001534 bl bb50 <rtems_semaphore_delete> <== NOT EXECUTED
free (fd->copy_buffer);
667c: e5950068 ldr r0, [r5, #104] ; 0x68 <== NOT EXECUTED
6680: eb0002ec bl 7238 <free> <== NOT EXECUTED
free (fd->blocks);
6684: e5950018 ldr r0, [r5, #24] <== NOT EXECUTED
6688: eb0002ea bl 7238 <free> <== NOT EXECUTED
free (fd->devices);
668c: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED
6690: eb0002e8 bl 7238 <free> <== NOT EXECUTED
rtems_fdisk_error ("compacting of disk failed: %s (%d)",
6694: e1a00006 mov r0, r6 <== NOT EXECUTED
6698: eb006c2f bl 2175c <strerror> <== NOT EXECUTED
669c: e1a02006 mov r2, r6 <== NOT EXECUTED
66a0: e1a01000 mov r1, r0 <== NOT EXECUTED
66a4: e59f00b8 ldr r0, [pc, #184] ; 6764 <rtems_fdisk_initialize+0x570><== NOT EXECUTED
66a8: ebfff5e0 bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
strerror (ret), ret);
return ret;
66ac: e1a00006 mov r0, r6 <== NOT EXECUTED
66b0: eafffed6 b 6210 <rtems_fdisk_initialize+0x1c> <== NOT EXECUTED
66b4: e59d500c ldr r5, [sp, #12] <== NOT EXECUTED
fd->device_count = c->device_count;
ret = rtems_fdisk_recover_block_mappings (fd);
if (ret)
{
rtems_disk_delete (dev);
66b8: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED
66bc: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED
66c0: ebfff2ca bl 31f0 <rtems_disk_delete> <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
66c4: e5950064 ldr r0, [r5, #100] ; 0x64 <== NOT EXECUTED
66c8: eb001520 bl bb50 <rtems_semaphore_delete> <== NOT EXECUTED
free (fd->copy_buffer);
66cc: e5950068 ldr r0, [r5, #104] ; 0x68 <== NOT EXECUTED
66d0: eb0002d8 bl 7238 <free> <== NOT EXECUTED
free (fd->blocks);
66d4: e5950018 ldr r0, [r5, #24] <== NOT EXECUTED
66d8: eb0002d6 bl 7238 <free> <== NOT EXECUTED
free (fd->devices);
66dc: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED
66e0: eb0002d4 bl 7238 <free> <== NOT EXECUTED
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
66e4: e1a00006 mov r0, r6 <== NOT EXECUTED
66e8: eb006c1b bl 2175c <strerror> <== NOT EXECUTED
66ec: e1a02006 mov r2, r6 <== NOT EXECUTED
66f0: e1a01000 mov r1, r0 <== NOT EXECUTED
66f4: e59f006c ldr r0, [pc, #108] ; 6768 <rtems_fdisk_initialize+0x574><== NOT EXECUTED
66f8: ebfff5cc bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
strerror (ret), ret);
return ret;
66fc: e1a00006 mov r0, r6 <== NOT EXECUTED
6700: eafffec2 b 6210 <rtems_fdisk_initialize+0x1c> <== NOT EXECUTED
6704: e59d500c ldr r5, [sp, #12] <== NOT EXECUTED
sc = rtems_disk_create_phys(dev, c->block_size,
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
{
rtems_semaphore_delete (fd->lock);
6708: e5950064 ldr r0, [r5, #100] ; 0x64 <== NOT EXECUTED
670c: eb00150f bl bb50 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_disk_delete (dev);
6710: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED
6714: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED
6718: ebfff2b4 bl 31f0 <rtems_disk_delete> <== NOT EXECUTED
free (fd->copy_buffer);
671c: e5950068 ldr r0, [r5, #104] ; 0x68 <== NOT EXECUTED
6720: eb0002c4 bl 7238 <free> <== NOT EXECUTED
free (fd->blocks);
6724: e5950018 ldr r0, [r5, #24] <== NOT EXECUTED
6728: eb0002c2 bl 7238 <free> <== NOT EXECUTED
free (fd->devices);
672c: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED
6730: eb0002c0 bl 7238 <free> <== NOT EXECUTED
rtems_fdisk_error ("disk create phy failed");
6734: e59f0030 ldr r0, [pc, #48] ; 676c <rtems_fdisk_initialize+0x578><== NOT EXECUTED
6738: ebfff5bc bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
free (fd->blocks);
free (fd->devices);
return sc;
}
sc = rtems_disk_create_phys(dev, c->block_size,
673c: e1a00006 mov r0, r6 <== NOT EXECUTED
rtems_disk_delete (dev);
free (fd->copy_buffer);
free (fd->blocks);
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
6740: eafffeb2 b 6210 <rtems_fdisk_initialize+0x1c> <== NOT EXECUTED
00004d90 <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)
{
4d90: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
4d94: e24dd068 sub sp, sp, #104 ; 0x68
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
4d98: e5907004 ldr r7, [r0, #4]
4d9c: e1a06001 mov r6, r1
4da0: e1a05002 mov r5, r2
4da4: e1a08000 mov r8, 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;
4da8: eb0069f9 bl 1f594 <__errno>
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
4dac: e59f3fb4 ldr r3, [pc, #4020] ; 5d68 <bsp_section_rodata_size+0xe64>
4db0: e0671187 rsb r1, r7, r7, lsl #3
4db4: e5932000 ldr r2, [r3]
4db8: e0871101 add r1, r7, r1, lsl #2
4dbc: e1a01101 lsl r1, r1, #2
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;
4dc0: e3a03000 mov r3, #0
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
4dc4: e0822001 add r2, r2, r1
4dc8: e58d1038 str r1, [sp, #56] ; 0x38
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;
4dcc: e5803000 str r3, [r0]
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
4dd0: e1a01003 mov r1, r3
4dd4: e5920064 ldr r0, [r2, #100] ; 0x64
4dd8: e1a02003 mov r2, r3
4ddc: eb001b84 bl bbf4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
4de0: e2504000 subs r4, r0, #0
4de4: 1a000030 bne 4eac <rtems_fdisk_ioctl+0x11c>
errno = EIO;
else
{
errno = 0;
4de8: eb0069e9 bl 1f594 <__errno>
switch (req)
4dec: e59f3f78 ldr r3, [pc, #3960] ; 5d6c <bsp_section_rodata_size+0xe68>
4df0: e1560003 cmp r6, r3
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
errno = EIO;
else
{
errno = 0;
4df4: e5804000 str r4, [r0]
switch (req)
4df8: 0a000052 beq 4f48 <bsp_section_rodata_size+0x44>
4dfc: 8a000033 bhi 4ed0 <rtems_fdisk_ioctl+0x140>
4e00: e2433002 sub r3, r3, #2
4e04: e1560003 cmp r6, r3
4e08: 0a000116 beq 5268 <bsp_section_rodata_size+0x364>
4e0c: 9a0000d6 bls 516c <bsp_section_rodata_size+0x268>
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]);
4e10: eb0069df bl 1f594 <__errno> <== NOT EXECUTED
4e14: e1a06000 mov r6, r0 <== NOT EXECUTED
4e18: e59f0f48 ldr r0, [pc, #3912] ; 5d68 <bsp_section_rodata_size+0xe64><== NOT EXECUTED
4e1c: e59dc038 ldr ip, [sp, #56] ; 0x38 <== NOT EXECUTED
4e20: e5905000 ldr r5, [r0] <== NOT EXECUTED
4e24: e085500c add r5, r5, ip <== NOT EXECUTED
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
4e28: e595304c ldr r3, [r5, #76] ; 0x4c <== NOT EXECUTED
4e2c: e2531000 subs r1, r3, #0 <== NOT EXECUTED
if (!queue->head)
queue->tail = 0;
queue->count--;
sc->next = 0;
4e30: e1a07004 mov r7, r4 <== NOT EXECUTED
{
/*
* The segment will either end up on the available queue or
* the failed queue.
*/
int ret = rtems_fdisk_erase_segment (fd, sc);
4e34: e1a00005 mov r0, r5 <== NOT EXECUTED
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
4e38: 0a000012 beq 4e88 <rtems_fdisk_ioctl+0xf8> <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
4e3c: e5932000 ldr r2, [r3] <== NOT EXECUTED
if (!queue->head)
4e40: e3520000 cmp r2, #0 <== NOT EXECUTED
queue->tail = 0;
4e44: 05852050 streq r2, [r5, #80] ; 0x50 <== NOT EXECUTED
{
if (queue->head)
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
4e48: e585204c str r2, [r5, #76] ; 0x4c <== NOT EXECUTED
if (!queue->head)
queue->tail = 0;
queue->count--;
4e4c: e5952054 ldr r2, [r5, #84] ; 0x54 <== NOT EXECUTED
4e50: e2422001 sub r2, r2, #1 <== NOT EXECUTED
4e54: e5852054 str r2, [r5, #84] ; 0x54 <== NOT EXECUTED
sc->next = 0;
4e58: e5837000 str r7, [r3] <== NOT EXECUTED
{
/*
* The segment will either end up on the available queue or
* the failed queue.
*/
int ret = rtems_fdisk_erase_segment (fd, sc);
4e5c: ebfffc13 bl 3eb0 <rtems_fdisk_erase_segment> <== NOT EXECUTED
if (ret && !latched_ret)
4e60: e2903000 adds r3, r0, #0 <== NOT EXECUTED
4e64: 13a03001 movne r3, #1 <== NOT EXECUTED
4e68: e3540000 cmp r4, #0 <== NOT EXECUTED
4e6c: 13a03000 movne r3, #0 <== NOT EXECUTED
4e70: e3530000 cmp r3, #0 <== NOT EXECUTED
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
4e74: e595304c ldr r3, [r5, #76] ; 0x4c <== NOT EXECUTED
/*
* The segment will either end up on the available queue or
* the failed queue.
*/
int ret = rtems_fdisk_erase_segment (fd, sc);
if (ret && !latched_ret)
4e78: 11a04000 movne r4, r0 <== NOT EXECUTED
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
4e7c: e2531000 subs r1, r3, #0 <== NOT EXECUTED
{
/*
* The segment will either end up on the available queue or
* the failed queue.
*/
int ret = rtems_fdisk_erase_segment (fd, sc);
4e80: e1a00005 mov r0, r5 <== NOT EXECUTED
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
4e84: 1affffec bne 4e3c <rtems_fdisk_ioctl+0xac> <== 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]);
4e88: e59f0ed8 ldr r0, [pc, #3800] ; 5d68 <bsp_section_rodata_size+0xe64><== NOT EXECUTED
4e8c: e5864000 str r4, [r6] <== NOT EXECUTED
4e90: e5901000 ldr r1, [r0] <== NOT EXECUTED
4e94: e59d6038 ldr r6, [sp, #56] ; 0x38 <== NOT EXECUTED
4e98: e0811006 add r1, r1, r6 <== NOT EXECUTED
default:
rtems_blkdev_ioctl (dd, req, argp);
break;
}
sc = rtems_semaphore_release (rtems_flashdisks[minor].lock);
4e9c: e5910064 ldr r0, [r1, #100] ; 0x64 <== NOT EXECUTED
4ea0: eb001b9c bl bd18 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
4ea4: e3500000 cmp r0, #0 <== NOT EXECUTED
4ea8: 0a000002 beq 4eb8 <rtems_fdisk_ioctl+0x128> <== NOT EXECUTED
errno = EIO;
4eac: eb0069b8 bl 1f594 <__errno> <== NOT EXECUTED
4eb0: e3a03005 mov r3, #5 <== NOT EXECUTED
4eb4: e5803000 str r3, [r0] <== NOT EXECUTED
}
return errno == 0 ? 0 : -1;
4eb8: eb0069b5 bl 1f594 <__errno>
4ebc: e5900000 ldr r0, [r0]
4ec0: e3500000 cmp r0, #0
}
4ec4: 13e00000 mvnne r0, #0
4ec8: e28dd068 add sp, sp, #104 ; 0x68
4ecc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if (sc != RTEMS_SUCCESSFUL)
errno = EIO;
else
{
errno = 0;
switch (req)
4ed0: e59f3e98 ldr r3, [pc, #3736] ; 5d70 <bsp_section_rodata_size+0xe6c>
4ed4: e1560003 cmp r6, r3
4ed8: 0a0000ee beq 5298 <bsp_section_rodata_size+0x394>
4edc: 3a0000ae bcc 519c <bsp_section_rodata_size+0x298>
4ee0: e59f3e8c ldr r3, [pc, #3724] ; 5d74 <bsp_section_rodata_size+0xe70>
4ee4: e1560003 cmp r6, r3
4ee8: 1a0000a2 bne 5178 <bsp_section_rodata_size+0x274>
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
4eec: e59f6e74 ldr r6, [pc, #3700] ; 5d68 <bsp_section_rodata_size+0xe64>
4ef0: e5963004 ldr r3, [r6, #4]
4ef4: e1530007 cmp r3, r7
4ef8: 9a00020c bls 5730 <bsp_section_rodata_size+0x82c>
(rtems_flashdisks[minor].device_count == 0))
4efc: e5963000 ldr r3, [r6]
4f00: e59dc038 ldr ip, [sp, #56] ; 0x38
4f04: e083300c add r3, r3, ip
{
errno = 0;
switch (req)
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
4f08: e5933030 ldr r3, [r3, #48] ; 0x30
4f0c: e3530000 cmp r3, #0
4f10: 0a000206 beq 5730 <bsp_section_rodata_size+0x82c>
{
errno = ENODEV;
}
else
{
switch (r->req)
4f14: e5957000 ldr r7, [r5]
4f18: e3570000 cmp r7, #0
4f1c: 0a00020b beq 5750 <bsp_section_rodata_size+0x84c>
4f20: e3570001 cmp r7, #1
4f24: 0a0002e1 beq 5ab0 <bsp_section_rodata_size+0xbac>
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
break;
default:
errno = EINVAL;
4f28: eb006999 bl 1f594 <__errno> <== NOT EXECUTED
4f2c: e59f2e34 ldr r2, [pc, #3636] ; 5d68 <bsp_section_rodata_size+0xe64><== NOT EXECUTED
4f30: e59d6038 ldr r6, [sp, #56] ; 0x38 <== NOT EXECUTED
4f34: e5921000 ldr r1, [r2] <== NOT EXECUTED
4f38: e3a03016 mov r3, #22 <== NOT EXECUTED
4f3c: e5803000 str r3, [r0] <== NOT EXECUTED
4f40: e0811006 add r1, r1, r6 <== NOT EXECUTED
break;
4f44: ea000083 b 5158 <bsp_section_rodata_size+0x254> <== 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],
4f48: eb006991 bl 1f594 <__errno> <== NOT EXECUTED
4f4c: e59fce14 ldr ip, [pc, #3604] ; 5d68 <bsp_section_rodata_size+0xe64><== NOT EXECUTED
4f50: e59d6038 ldr r6, [sp, #56] ; 0x38 <== NOT EXECUTED
4f54: e59c1000 ldr r1, [ip] <== NOT EXECUTED
4f58: e0811006 add r1, r1, r6 <== NOT EXECUTED
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
data->block_count = fd->block_count;
4f5c: e591301c ldr r3, [r1, #28] <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks; data->device_count = fd->device_count;
4f60: e591c030 ldr ip, [r1, #48] ; 0x30 <== NOT EXECUTED
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
data->block_count = fd->block_count;
data->unavail_blocks = fd->unavail_blocks;
4f64: e5912020 ldr r2, [r1, #32] <== 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],
4f68: e58d0044 str r0, [sp, #68] ; 0x44 <== NOT EXECUTED
rtems_fdisk_monitor_data* data)
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
4f6c: e5910014 ldr r0, [r1, #20] <== 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++)
4f70: e3530000 cmp r3, #0 <== NOT EXECUTED
uint32_t j;
data->block_size = fd->block_size;
data->block_count = fd->block_count;
data->unavail_blocks = fd->unavail_blocks;
data->device_count = fd->device_count;
4f74: e58dc03c str ip, [sp, #60] ; 0x3c <== NOT EXECUTED
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
data->block_count = fd->block_count;
4f78: e8850009 stm r5, {r0, r3} <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks;
4f7c: e5852008 str r2, [r5, #8] <== NOT EXECUTED
data->device_count = fd->device_count;
4f80: e585c00c str ip, [r5, #12] <== NOT EXECUTED
data->blocks_used = 0;
4f84: e5854018 str r4, [r5, #24] <== NOT EXECUTED
for (i = 0; i < fd->block_count; i++)
4f88: 0a000008 beq 4fb0 <bsp_section_rodata_size+0xac> <== NOT EXECUTED
4f8c: e5912018 ldr r2, [r1, #24] <== NOT EXECUTED
if (fd->blocks[i].segment)
4f90: e7920184 ldr r0, [r2, r4, lsl #3] <== NOT EXECUTED
4f94: e3500000 cmp r0, #0 <== NOT EXECUTED
data->blocks_used++;
4f98: 15950018 ldrne r0, [r5, #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++)
4f9c: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (fd->blocks[i].segment)
data->blocks_used++;
4fa0: 12800001 addne r0, r0, #1 <== NOT EXECUTED
4fa4: 15850018 strne r0, [r5, #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++)
4fa8: e1540003 cmp r4, r3 <== NOT EXECUTED
4fac: 1afffff7 bne 4f90 <bsp_section_rodata_size+0x8c> <== 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;
4fb0: e5913034 ldr r3, [r1, #52] ; 0x34 <== NOT EXECUTED
uint32_t count = 0;
while (sc)
4fb4: e3530000 cmp r3, #0 <== NOT EXECUTED
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
4fb8: 01a02003 moveq r2, r3 <== NOT EXECUTED
while (sc)
4fbc: 0a000004 beq 4fd4 <bsp_section_rodata_size+0xd0> <== NOT EXECUTED
4fc0: e3a02000 mov r2, #0 <== NOT EXECUTED
{
count++;
sc = sc->next;
4fc4: e5933000 ldr r3, [r3] <== 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)
4fc8: e3530000 cmp r3, #0 <== NOT EXECUTED
{
count++;
4fcc: 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)
4fd0: 1afffffb bne 4fc4 <bsp_section_rodata_size+0xc0> <== 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;
4fd4: e5913040 ldr r3, [r1, #64] ; 0x40 <== NOT EXECUTED
uint32_t count = 0;
while (sc)
4fd8: e3530000 cmp r3, #0 <== 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);
4fdc: e585201c str r2, [r5, #28] <== NOT EXECUTED
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
4fe0: 01a02003 moveq r2, r3 <== NOT EXECUTED
while (sc)
4fe4: 0a000004 beq 4ffc <bsp_section_rodata_size+0xf8> <== NOT EXECUTED
4fe8: e3a02000 mov r2, #0 <== NOT EXECUTED
{
count++;
sc = sc->next;
4fec: e5933000 ldr r3, [r3] <== 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)
4ff0: e3530000 cmp r3, #0 <== NOT EXECUTED
{
count++;
4ff4: 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)
4ff8: 1afffffb bne 4fec <bsp_section_rodata_size+0xe8> <== 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;
4ffc: e5913058 ldr r3, [r1, #88] ; 0x58 <== NOT EXECUTED
uint32_t count = 0;
while (sc)
5000: e3530000 cmp r3, #0 <== 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);
5004: e5852020 str r2, [r5, #32] <== NOT EXECUTED
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
5008: 01a02003 moveq r2, r3 <== NOT EXECUTED
while (sc)
500c: 0a000004 beq 5024 <bsp_section_rodata_size+0x120> <== NOT EXECUTED
5010: e3a02000 mov r2, #0 <== NOT EXECUTED
{
count++;
sc = sc->next;
5014: e5933000 ldr r3, [r3] <== 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)
5018: e3530000 cmp r3, #0 <== NOT EXECUTED
{
count++;
501c: 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)
5020: 1afffffb bne 5014 <bsp_section_rodata_size+0x110> <== 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++)
5024: e59d003c ldr r0, [sp, #60] ; 0x3c <== NOT EXECUTED
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);
data->segment_count = 0;
5028: e3a03000 mov r3, #0 <== 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++)
502c: e1500003 cmp r0, r3 <== 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);
5030: e5852024 str r2, [r5, #36] ; 0x24 <== NOT EXECUTED
data->segment_count = 0;
5034: e5853010 str r3, [r5, #16] <== NOT EXECUTED
data->page_count = 0;
5038: e5853014 str r3, [r5, #20] <== NOT EXECUTED
data->pages_desc = 0;
503c: e585302c str r3, [r5, #44] ; 0x2c <== NOT EXECUTED
data->pages_active = 0;
5040: e5853030 str r3, [r5, #48] ; 0x30 <== NOT EXECUTED
data->pages_used = 0;
5044: e5853034 str r3, [r5, #52] ; 0x34 <== NOT EXECUTED
data->pages_bad = 0;
5048: e5853038 str r3, [r5, #56] ; 0x38 <== NOT EXECUTED
data->seg_erases = 0;
504c: e5853028 str r3, [r5, #40] ; 0x28 <== NOT EXECUTED
for (i = 0; i < fd->device_count; i++)
5050: 0a00003b beq 5144 <bsp_section_rodata_size+0x240> <== NOT EXECUTED
5054: e591202c ldr r2, [r1, #44] ; 0x2c <== NOT EXECUTED
5058: e58d3038 str r3, [sp, #56] ; 0x38 <== NOT EXECUTED
505c: e58d2034 str r2, [sp, #52] ; 0x34 <== NOT EXECUTED
5060: e58d3040 str r3, [sp, #64] ; 0x40 <== NOT EXECUTED
5064: e58d1048 str r1, [sp, #72] ; 0x48 <== NOT EXECUTED
5068: e58d5030 str r5, [sp, #48] ; 0x30 <== NOT EXECUTED
{
data->segment_count += fd->devices[i].segment_count;
506c: e59d3034 ldr r3, [sp, #52] ; 0x34 <== NOT EXECUTED
5070: e59d6038 ldr r6, [sp, #56] ; 0x38 <== NOT EXECUTED
5074: e593b004 ldr fp, [r3, #4] <== NOT EXECUTED
5078: e086600b add r6, r6, fp <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
507c: e35b0000 cmp fp, #0 <== NOT EXECUTED
data->pages_bad = 0;
data->seg_erases = 0;
for (i = 0; i < fd->device_count; i++)
{
data->segment_count += fd->devices[i].segment_count;
5080: e58d6038 str r6, [sp, #56] ; 0x38 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
5084: 0a000021 beq 5110 <bsp_section_rodata_size+0x20c> <== NOT EXECUTED
5088: e59d1030 ldr r1, [sp, #48] ; 0x30 <== NOT EXECUTED
508c: e59dc030 ldr ip, [sp, #48] ; 0x30 <== NOT EXECUTED
5090: e59d2030 ldr r2, [sp, #48] ; 0x30 <== NOT EXECUTED
5094: e2810034 add r0, r1, #52 ; 0x34 <== NOT EXECUTED
5098: e59c4014 ldr r4, [ip, #20] <== NOT EXECUTED
509c: e59ce02c ldr lr, [ip, #44] ; 0x2c <== NOT EXECUTED
50a0: e8900003 ldm r0, {r0, r1} <== NOT EXECUTED
50a4: e59cc030 ldr ip, [ip, #48] ; 0x30 <== NOT EXECUTED
50a8: e5933000 ldr r3, [r3] <== NOT EXECUTED
50ac: e5925028 ldr r5, [r2, #40] ; 0x28 <== NOT EXECUTED
50b0: e3a02000 mov r2, #0 <== 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;
50b4: e5936024 ldr r6, [r3, #36] ; 0x24 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
data->pages_desc += sc->pages_desc;
50b8: e2839014 add r9, r3, #20 <== NOT EXECUTED
50bc: e8990600 ldm r9, {r9, sl} <== NOT EXECUTED
data->pages_active += sc->pages_active;
50c0: e593801c ldr r8, [r3, #28] <== NOT EXECUTED
data->pages_used += sc->pages_used;
50c4: e5937020 ldr r7, [r3, #32] <== 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++)
50c8: e2822001 add r2, r2, #1 <== 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;
50cc: e0811006 add r1, r1, r6 <== NOT EXECUTED
data->seg_erases += sc->erased;
50d0: e593602c ldr r6, [r3, #44] ; 0x2c <== 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++)
50d4: e152000b cmp r2, fp <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
50d8: e0844009 add r4, r4, r9 <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
50dc: e08ee00a add lr, lr, sl <== NOT EXECUTED
data->pages_active += sc->pages_active;
50e0: e08cc008 add ip, ip, r8 <== NOT EXECUTED
data->pages_used += sc->pages_used;
50e4: e0800007 add r0, r0, r7 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
data->seg_erases += sc->erased;
50e8: e0855006 add r5, r5, r6 <== 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++)
50ec: e2833030 add r3, r3, #48 ; 0x30 <== NOT EXECUTED
50f0: 1affffef bne 50b4 <bsp_section_rodata_size+0x1b0> <== NOT EXECUTED
50f4: e59d2030 ldr r2, [sp, #48] ; 0x30 <== NOT EXECUTED
50f8: e5824014 str r4, [r2, #20] <== NOT EXECUTED
50fc: e582e02c str lr, [r2, #44] ; 0x2c <== NOT EXECUTED
5100: e582c030 str ip, [r2, #48] ; 0x30 <== NOT EXECUTED
5104: e5820034 str r0, [r2, #52] ; 0x34 <== NOT EXECUTED
5108: e5821038 str r1, [r2, #56] ; 0x38 <== NOT EXECUTED
510c: e5825028 str r5, [r2, #40] ; 0x28 <== 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++)
5110: e59d3040 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED
5114: e59dc034 ldr ip, [sp, #52] ; 0x34 <== NOT EXECUTED
5118: e59d603c ldr r6, [sp, #60] ; 0x3c <== NOT EXECUTED
511c: e2833001 add r3, r3, #1 <== NOT EXECUTED
5120: e28cc00c add ip, ip, #12 <== NOT EXECUTED
5124: e1530006 cmp r3, r6 <== NOT EXECUTED
5128: e58d3040 str r3, [sp, #64] ; 0x40 <== NOT EXECUTED
512c: e58dc034 str ip, [sp, #52] ; 0x34 <== NOT EXECUTED
5130: 1affffcd bne 506c <bsp_section_rodata_size+0x168> <== NOT EXECUTED
5134: e59d5030 ldr r5, [sp, #48] ; 0x30 <== NOT EXECUTED
5138: e59d0038 ldr r0, [sp, #56] ; 0x38 <== NOT EXECUTED
513c: e59d1048 ldr r1, [sp, #72] ; 0x48 <== NOT EXECUTED
5140: e5850010 str r0, [r5, #16] <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
data->seg_erases += sc->erased;
}
}
data->info_level = fd->info_level;
5144: e591306c ldr r3, [r1, #108] ; 0x6c <== 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],
5148: e59d2044 ldr r2, [sp, #68] ; 0x44 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
data->seg_erases += sc->erased;
}
}
data->info_level = fd->info_level;
514c: e585303c str r3, [r5, #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],
5150: e3a03000 mov r3, #0 <== NOT EXECUTED
5154: e5823000 str r3, [r2] <== NOT EXECUTED
default:
rtems_blkdev_ioctl (dd, req, argp);
break;
}
sc = rtems_semaphore_release (rtems_flashdisks[minor].lock);
5158: e5910064 ldr r0, [r1, #100] ; 0x64
515c: eb001aed bl bd18 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
5160: e3500000 cmp r0, #0
5164: 0affff53 beq 4eb8 <rtems_fdisk_ioctl+0x128>
5168: eaffff4f b 4eac <rtems_fdisk_ioctl+0x11c> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
errno = EIO;
else
{
errno = 0;
switch (req)
516c: e2433001 sub r3, r3, #1
5170: e1560003 cmp r6, r3
5174: 0a00000e beq 51b4 <bsp_section_rodata_size+0x2b0>
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
break;
default:
rtems_blkdev_ioctl (dd, req, argp);
5178: e1a01006 mov r1, r6
517c: e1a00008 mov r0, r8
5180: e1a02005 mov r2, r5
5184: eb00404b bl 152b8 <rtems_blkdev_ioctl>
5188: e59f0bd8 ldr r0, [pc, #3032] ; 5d68 <bsp_section_rodata_size+0xe64>
518c: e59d6038 ldr r6, [sp, #56] ; 0x38
5190: e5901000 ldr r1, [r0]
5194: e0811006 add r1, r1, r6
break;
5198: eaffffee b 5158 <bsp_section_rodata_size+0x254>
errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
(rtems_fdisk_monitor_data*) argp);
break;
case RTEMS_FDISK_IOCTL_INFO_LEVEL:
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
519c: e59f3bc4 ldr r3, [pc, #3012] ; 5d68 <bsp_section_rodata_size+0xe64><== NOT EXECUTED
51a0: e59d6038 ldr r6, [sp, #56] ; 0x38 <== NOT EXECUTED
51a4: e5931000 ldr r1, [r3] <== NOT EXECUTED
51a8: e0811006 add r1, r1, r6 <== NOT EXECUTED
51ac: e581506c str r5, [r1, #108] ; 0x6c <== NOT EXECUTED
break;
51b0: eaffffe8 b 5158 <bsp_section_rodata_size+0x254> <== NOT EXECUTED
}
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
51b4: eb0068f6 bl 1f594 <__errno> <== NOT EXECUTED
51b8: e59fcba8 ldr ip, [pc, #2984] ; 5d68 <bsp_section_rodata_size+0xe64><== NOT EXECUTED
51bc: e59d6038 ldr r6, [sp, #56] ; 0x38 <== NOT EXECUTED
51c0: e59c5000 ldr r5, [ip] <== NOT EXECUTED
51c4: e0855006 add r5, r5, r6 <== NOT EXECUTED
51c8: e1a08000 mov r8, r0 <== NOT EXECUTED
{
uint32_t device;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "erase-disk");
51cc: e59f1ba4 ldr r1, [pc, #2980] ; 5d78 <bsp_section_rodata_size+0xe74><== NOT EXECUTED
51d0: e1a00005 mov r0, r5 <== NOT EXECUTED
51d4: ebfffa14 bl 3a2c <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++)
51d8: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED
51dc: e3500000 cmp r0, #0 <== NOT EXECUTED
51e0: 0a00001a beq 5250 <bsp_section_rodata_size+0x34c> <== NOT EXECUTED
51e4: e1a06004 mov r6, r4 <== NOT EXECUTED
51e8: ea000003 b 51fc <bsp_section_rodata_size+0x2f8> <== NOT EXECUTED
51ec: e5953030 ldr r3, [r5, #48] ; 0x30 <== NOT EXECUTED
51f0: e1560003 cmp r6, r3 <== NOT EXECUTED
51f4: e284400c add r4, r4, #12 <== NOT EXECUTED
51f8: 2a000215 bcs 5a54 <bsp_section_rodata_size+0xb50> <== NOT EXECUTED
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " erase-flash:%02d", device);
51fc: e1a02006 mov r2, r6 <== NOT EXECUTED
5200: e59f1b74 ldr r1, [pc, #2932] ; 5d7c <bsp_section_rodata_size+0xe78><== NOT EXECUTED
5204: e1a00005 mov r0, r5 <== NOT EXECUTED
5208: ebfffa07 bl 3a2c <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;
520c: e595302c ldr r3, [r5, #44] ; 0x2c <== NOT EXECUTED
5210: e0833004 add r3, r3, r4 <== NOT EXECUTED
5214: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
#if RTEMS_FDISK_TRACE rtems_fdisk_printf (fd, " device-erase: %02d", device);
5218: e1a02006 mov r2, r6 <== NOT EXECUTED
521c: e59f1b5c ldr r1, [pc, #2908] ; 5d80 <bsp_section_rodata_size+0xe7c><== NOT EXECUTED
5220: e1a00005 mov r0, r5 <== 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;
5224: e5937008 ldr r7, [r3, #8] <== NOT EXECUTED
#if RTEMS_FDISK_TRACE rtems_fdisk_printf (fd, " device-erase: %02d", device);
5228: ebfffa23 bl 3abc <rtems_fdisk_printf> <== NOT EXECUTED
#endif return ops->erase_device (fd->devices[device].descriptor, device);
522c: e595302c ldr r3, [r5, #44] ; 0x2c <== NOT EXECUTED
5230: e0833004 add r3, r3, r4 <== NOT EXECUTED
5234: e1a01006 mov r1, r6 <== NOT EXECUTED
5238: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
523c: e1a0e00f mov lr, pc <== NOT EXECUTED
5240: e597f014 ldr pc, [r7, #20] <== NOT EXECUTED
rtems_fdisk_info (fd, " erase-flash:%02d", device);
#endif
ret = rtems_fdisk_device_erase (fd, device);
if (ret != 0)
5244: e3500000 cmp r0, #0 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
5248: e2866001 add r6, r6, #1 <== NOT EXECUTED
rtems_fdisk_info (fd, " erase-flash:%02d", device);
#endif
ret = rtems_fdisk_device_erase (fd, device);
if (ret != 0)
524c: 0affffe6 beq 51ec <bsp_section_rodata_size+0x2e8> <== NOT EXECUTED
}
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
5250: e59fcb10 ldr ip, [pc, #2832] ; 5d68 <bsp_section_rodata_size+0xe64><== NOT EXECUTED
5254: e59d6038 ldr r6, [sp, #56] ; 0x38 <== NOT EXECUTED
5258: e59c1000 ldr r1, [ip] <== NOT EXECUTED
525c: e5880000 str r0, [r8] <== NOT EXECUTED
5260: e0811006 add r1, r1, r6 <== NOT EXECUTED
break;
5264: eaffffbb b 5158 <bsp_section_rodata_size+0x254> <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_COMPACT:
errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);
5268: eb0068c9 bl 1f594 <__errno> <== NOT EXECUTED
526c: e59fcaf4 ldr ip, [pc, #2804] ; 5d68 <bsp_section_rodata_size+0xe64><== NOT EXECUTED
5270: e59d6038 ldr r6, [sp, #56] ; 0x38 <== NOT EXECUTED
5274: e1a04000 mov r4, r0 <== NOT EXECUTED
5278: e59c0000 ldr r0, [ip] <== NOT EXECUTED
527c: e0800006 add r0, r0, r6 <== NOT EXECUTED
5280: ebfffd31 bl 474c <rtems_fdisk_compact> <== NOT EXECUTED
5284: e59fcadc ldr ip, [pc, #2780] ; 5d68 <bsp_section_rodata_size+0xe64><== NOT EXECUTED
5288: e59c1000 ldr r1, [ip] <== NOT EXECUTED
528c: e5840000 str r0, [r4] <== NOT EXECUTED
5290: e0811006 add r1, r1, r6 <== NOT EXECUTED
break;
5294: eaffffaf b 5158 <bsp_section_rodata_size+0x254> <== NOT EXECUTED
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]);
5298: eb0068bd bl 1f594 <__errno>
529c: e59fcac4 ldr ip, [pc, #2756] ; 5d68 <bsp_section_rodata_size+0xe64>
52a0: e59c2000 ldr r2, [ip]
52a4: e59dc038 ldr ip, [sp, #56] ; 0x38
52a8: e082600c add r6, r2, ip
*/
static int
rtems_fdisk_print_status (rtems_flashdisk* fd)
{
#if RTEMS_FDISK_TRACE
uint32_t current_info_level = fd->info_level;
52ac: e596c06c ldr ip, [r6, #108] ; 0x6c
52b0: e58dc044 str ip, [sp, #68] ; 0x44
uint32_t count;
uint32_t device;
fd->info_level = 3;
rtems_fdisk_printf (fd,
52b4: e59dc038 ldr ip, [sp, #56] ; 0x38
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]);
52b8: e58d0040 str r0, [sp, #64] ; 0x40
uint32_t current_info_level = fd->info_level;
uint32_t total;
uint32_t count;
uint32_t device;
fd->info_level = 3;
52bc: e3a00003 mov r0, #3
rtems_fdisk_printf (fd,
52c0: e5963004 ldr r3, [r6, #4]
52c4: e792200c ldr r2, [r2, ip]
52c8: e59f1ab4 ldr r1, [pc, #2740] ; 5d84 <bsp_section_rodata_size+0xe80>
uint32_t current_info_level = fd->info_level;
uint32_t total;
uint32_t count;
uint32_t device;
fd->info_level = 3;
52cc: e586006c str r0, [r6, #108] ; 0x6c
rtems_fdisk_printf (fd,
52d0: e1a00006 mov r0, r6
52d4: ebfff9f8 bl 3abc <rtems_fdisk_printf>
"Flash Disk Driver Status : %d.%d", fd->major, fd->minor);
rtems_fdisk_printf (fd, "Block count\t%d", fd->block_count);
52d8: e59f1aa8 ldr r1, [pc, #2728] ; 5d88 <bsp_section_rodata_size+0xe84>
52dc: e596201c ldr r2, [r6, #28]
52e0: e1a00006 mov r0, r6
52e4: ebfff9f4 bl 3abc <rtems_fdisk_printf>
rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);
52e8: e59f1a9c ldr r1, [pc, #2716] ; 5d8c <bsp_section_rodata_size+0xe88>
52ec: e5962020 ldr r2, [r6, #32]
52f0: e1a00006 mov r0, r6
52f4: ebfff9f0 bl 3abc <rtems_fdisk_printf>
rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
52f8: e59f1a90 ldr r1, [pc, #2704] ; 5d90 <bsp_section_rodata_size+0xe8c>
52fc: e5962024 ldr r2, [r6, #36] ; 0x24
5300: e1a00006 mov r0, r6
5304: ebfff9ec bl 3abc <rtems_fdisk_printf>
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
5308: e1a00006 mov r0, r6
530c: e59f1a80 ldr r1, [pc, #2688] ; 5d94 <bsp_section_rodata_size+0xe90>
5310: e5962070 ldr r2, [r6, #112] ; 0x70
5314: ebfff9e8 bl 3abc <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;
5318: e5963034 ldr r3, [r6, #52] ; 0x34
uint32_t count = 0;
while (sc)
531c: e3530000 cmp r3, #0
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
5320: 01a04003 moveq r4, r3
while (sc)
5324: 0a000003 beq 5338 <bsp_section_rodata_size+0x434>
{
count++;
sc = sc->next;
5328: e5933000 ldr r3, [r3]
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
532c: e3530000 cmp r3, #0
{
count++;
5330: e2844001 add r4, r4, #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)
5334: 1afffffb bne 5328 <bsp_section_rodata_size+0x424>
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)",
5338: e596303c ldr r3, [r6, #60] ; 0x3c
533c: e1a00006 mov r0, r6
5340: e59f1a50 ldr r1, [pc, #2640] ; 5d98 <bsp_section_rodata_size+0xe94>
5344: e1a02004 mov r2, r4
5348: ebfff9db bl 3abc <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;
534c: e5963040 ldr r3, [r6, #64] ; 0x40
uint32_t count = 0;
while (sc)
5350: e3530000 cmp r3, #0
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
5354: 01a0c003 moveq ip, r3
while (sc)
5358: 0a000004 beq 5370 <bsp_section_rodata_size+0x46c>
535c: e3a0c000 mov ip, #0
{
count++;
sc = sc->next;
5360: e5933000 ldr r3, [r3]
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
5364: e3530000 cmp r3, #0
{
count++;
5368: e28cc001 add ip, ip, #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)
536c: 1afffffb bne 5360 <bsp_section_rodata_size+0x45c>
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)",
5370: e1a0200c mov r2, ip
5374: e5963048 ldr r3, [r6, #72] ; 0x48
5378: e1a00006 mov r0, r6
537c: e59f1a18 ldr r1, [pc, #2584] ; 5d9c <bsp_section_rodata_size+0xe98>
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;
5380: e08c4004 add r4, ip, r4
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
5384: ebfff9cc bl 3abc <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;
5388: e596304c ldr r3, [r6, #76] ; 0x4c
uint32_t count = 0;
while (sc)
538c: e3530000 cmp r3, #0
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
5390: 01a0c003 moveq ip, r3
while (sc)
5394: 0a000004 beq 53ac <bsp_section_rodata_size+0x4a8>
5398: e3a0c000 mov ip, #0 <== NOT EXECUTED
{
count++;
sc = sc->next;
539c: e5933000 ldr r3, [r3] <== 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)
53a0: e3530000 cmp r3, #0 <== NOT EXECUTED
{
count++;
53a4: e28cc001 add ip, ip, #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)
53a8: 1afffffb bne 539c <bsp_section_rodata_size+0x498> <== NOT EXECUTED
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)",
53ac: e1a0200c mov r2, ip
53b0: e5963054 ldr r3, [r6, #84] ; 0x54
53b4: e1a00006 mov r0, r6
53b8: e59f19e0 ldr r1, [pc, #2528] ; 5da0 <bsp_section_rodata_size+0xe9c>
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;
53bc: e084400c add r4, r4, ip
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
53c0: ebfff9bd bl 3abc <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;
53c4: e5963058 ldr r3, [r6, #88] ; 0x58
uint32_t count = 0;
while (sc)
53c8: e3530000 cmp r3, #0
*/
static uint32_t
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
53cc: 01a0c003 moveq ip, r3
while (sc)
53d0: 0a000004 beq 53e8 <bsp_section_rodata_size+0x4e4>
53d4: e3a0c000 mov ip, #0 <== NOT EXECUTED
{
count++;
sc = sc->next;
53d8: e5933000 ldr r3, [r3] <== 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)
53dc: e3530000 cmp r3, #0 <== NOT EXECUTED
{
count++;
53e0: e28cc001 add ip, ip, #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)
53e4: 1afffffb bne 53d8 <bsp_section_rodata_size+0x4d4> <== NOT EXECUTED
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)",
53e8: e1a0200c mov r2, ip
53ec: e5963060 ldr r3, [r6, #96] ; 0x60
53f0: e1a00006 mov r0, r6
53f4: e59f19a8 ldr r1, [pc, #2472] ; 5da4 <bsp_section_rodata_size+0xea0>
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;
53f8: e084400c add r4, r4, ip
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
53fc: ebfff9ae bl 3abc <rtems_fdisk_printf>
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
for (device = 0; device < fd->device_count; device++)
5400: e5962030 ldr r2, [r6, #48] ; 0x30
5404: e3520000 cmp r2, #0
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;
5408: 01a03002 moveq r3, r2
for (device = 0; device < fd->device_count; device++)
540c: 0a000008 beq 5434 <bsp_section_rodata_size+0x530>
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;
5410: e3a03000 mov r3, #0
for (device = 0; device < fd->device_count; device++)
5414: e596002c ldr r0, [r6, #44] ; 0x2c
5418: e1a01003 mov r1, r3
count += fd->devices[device].segment_count;
541c: e590c004 ldr ip, [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++)
5420: e2811001 add r1, r1, #1
5424: e1510002 cmp r1, r2
count += fd->devices[device].segment_count;
5428: e083300c add r3, r3, ip
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++)
542c: e280000c add r0, r0, #12
5430: 1afffff9 bne 541c <bsp_section_rodata_size+0x518>
count += fd->devices[device].segment_count;
rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
5434: e59f296c ldr r2, [pc, #2412] ; 5da8 <bsp_section_rodata_size+0xea4>
5438: e1540003 cmp r4, r3
543c: e59fc968 ldr ip, [pc, #2408] ; 5dac <bsp_section_rodata_size+0xea8>
5440: e59f1968 ldr r1, [pc, #2408] ; 5db0 <bsp_section_rodata_size+0xeac>
5444: 01a0c002 moveq ip, r2
5448: e1a00006 mov r0, r6
544c: e1a02004 mov r2, r4
5450: e58dc000 str ip, [sp]
5454: ebfff998 bl 3abc <rtems_fdisk_printf>
total == count ? "ok" : "MISSING");
rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);
5458: e1a00006 mov r0, r6
545c: e59f1950 ldr r1, [pc, #2384] ; 5db4 <bsp_section_rodata_size+0xeb0>
5460: e5962030 ldr r2, [r6, #48] ; 0x30
5464: ebfff994 bl 3abc <rtems_fdisk_printf>
for (device = 0; device < fd->device_count; device++)
5468: e5963030 ldr r3, [r6, #48] ; 0x30
546c: e3530000 cmp r3, #0
5470: 0a000084 beq 5688 <bsp_section_rodata_size+0x784>
5474: e3a0c000 mov ip, #0
5478: e58dc034 str ip, [sp, #52] ; 0x34
547c: e58dc03c str ip, [sp, #60] ; 0x3c
{
uint32_t block;
uint32_t seg;
rtems_fdisk_printf (fd, " Device\t\t%ld", device);
5480: e59f1930 ldr r1, [pc, #2352] ; 5db8 <bsp_section_rodata_size+0xeb4>
5484: e59d203c ldr r2, [sp, #60] ; 0x3c
5488: e1a00006 mov r0, r6
548c: ebfff98a bl 3abc <rtems_fdisk_printf>
rtems_fdisk_printf (fd, " Segment count\t%ld",
5490: e59dc034 ldr ip, [sp, #52] ; 0x34
5494: e596302c ldr r3, [r6, #44] ; 0x2c
5498: e083300c add r3, r3, ip
549c: e5932004 ldr r2, [r3, #4]
54a0: e1a00006 mov r0, r6
54a4: e59f1910 ldr r1, [pc, #2320] ; 5dbc <bsp_section_rodata_size+0xeb8>
54a8: ebfff983 bl 3abc <rtems_fdisk_printf>
fd->devices[device].segment_count);
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
54ac: e596302c ldr r3, [r6, #44] ; 0x2c
54b0: e59dc034 ldr ip, [sp, #52] ; 0x34
54b4: e083300c add r3, r3, ip
54b8: e5932004 ldr r2, [r3, #4]
54bc: e3520000 cmp r2, #0
54c0: 0a000067 beq 5664 <bsp_section_rodata_size+0x760>
54c4: e3a0c000 mov ip, #0
54c8: e58dc030 str ip, [sp, #48] ; 0x30
54cc: e1a0b00c mov fp, ip
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
54d0: e5935000 ldr r5, [r3]
54d4: e59dc030 ldr ip, [sp, #48] ; 0x30
54d8: e085500c add r5, r5, ip
uint32_t active = 0;
uint32_t used = 0;
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
54dc: e1a00006 mov r0, r6
54e0: e1a01005 mov r1, r5
54e4: e28d2060 add r2, sp, #96 ; 0x60
54e8: ebfff8fc bl 38e0 <rtems_fdisk_queue_status>
for (page = 0; page < sc->pages; page++)
54ec: e5950014 ldr r0, [r5, #20]
54f0: e3500000 cmp r0, #0
54f4: 0a000088 beq 571c <bsp_section_rodata_size+0x818>
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;
bool is_active = false;
54f8: e3a08000 mov r8, #0
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
54fc: e596301c ldr r3, [r6, #28]
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;
5500: e58d802c str r8, [sp, #44] ; 0x2c
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
5504: e1a02003 mov r2, r3
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;
uint32_t active = 0;
5508: e1a0a008 mov sl, r8
uint32_t used = 0;
550c: e1a09008 mov r9, r8
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
5510: e1a07008 mov r7, r8
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
5514: e5951010 ldr r1, [r5, #16]
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
5518: e791c187 ldr ip, [r1, r7, lsl #3]
551c: e37c0001 cmn ip, #1
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
5520: e0811187 add r1, r1, r7, lsl #3
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
5524: 0a000075 beq 5700 <bsp_section_rodata_size+0x7fc>
* 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;
5528: e1d110b2 ldrh r1, [r1, #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],
552c: e3110001 tst r1, #1
5530: 1a000003 bne 5544 <bsp_section_rodata_size+0x640>
RTEMS_FDISK_PAGE_ACTIVE))
{
if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
5534: e3110002 tst r1, #2
RTEMS_FDISK_PAGE_USED))
used++;
5538: 02899001 addeq r9, r9, #1
else
{
active++;
553c: 128aa001 addne sl, sl, #1
is_active = true;
5540: 13a08001 movne r8, #1
}
}
for (block = 0; block < fd->block_count; block++)
5544: e3530000 cmp r3, #0
5548: 0a00001a beq 55b8 <bsp_section_rodata_size+0x6b4>
554c: e3a04000 mov r4, #0
5550: ea000003 b 5564 <bsp_section_rodata_size+0x660>
5554: e2844001 add r4, r4, #1
5558: e1540003 cmp r4, r3
555c: e1a02003 mov r2, r3
5560: 2a000013 bcs 55b4 <bsp_section_rodata_size+0x6b0>
{
if ((fd->blocks[block].segment == sc) &&
5564: e5962018 ldr r2, [r6, #24]
5568: e7921184 ldr r1, [r2, r4, lsl #3]
556c: e1550001 cmp r5, r1
5570: e0822184 add r2, r2, r4, lsl #3
5574: 1afffff6 bne 5554 <bsp_section_rodata_size+0x650>
5578: e5922004 ldr r2, [r2, #4]
557c: e1570002 cmp r7, r2
5580: 1afffff3 bne 5554 <bsp_section_rodata_size+0x650>
(fd->blocks[block].page == page) && !is_active)
5584: e3580000 cmp r8, #0
5588: 1afffff1 bne 5554 <bsp_section_rodata_size+0x650>
rtems_fdisk_printf (fd,
558c: e1a03004 mov r3, r4 <== NOT EXECUTED
5590: e1a02007 mov r2, r7 <== NOT EXECUTED
5594: e1a00006 mov r0, r6 <== NOT EXECUTED
5598: e59f1820 ldr r1, [pc, #2080] ; 5dc0 <bsp_section_rodata_size+0xebc><== NOT EXECUTED
559c: ebfff946 bl 3abc <rtems_fdisk_printf> <== NOT EXECUTED
55a0: e596301c ldr r3, [r6, #28] <== NOT EXECUTED
active++;
is_active = true;
}
}
for (block = 0; block < fd->block_count; block++)
55a4: e2844001 add r4, r4, #1 <== NOT EXECUTED
55a8: e1540003 cmp r4, r3 <== NOT EXECUTED
55ac: e1a02003 mov r2, r3 <== NOT EXECUTED
55b0: 3affffeb bcc 5564 <bsp_section_rodata_size+0x660> <== NOT EXECUTED
55b4: e5950014 ldr r0, [r5, #20]
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
55b8: e2877001 add r7, r7, #1
55bc: e1570000 cmp r7, r0
55c0: 3affffd3 bcc 5514 <bsp_section_rodata_size+0x610>
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
55c4: e3520000 cmp r2, #0
55c8: 01a0c002 moveq ip, r2
55cc: 0a000008 beq 55f4 <bsp_section_rodata_size+0x6f0>
55d0: e3a0c000 mov ip, #0
55d4: e596e018 ldr lr, [r6, #24]
55d8: e1a0300c mov r3, ip
{
if (fd->blocks[block].segment == sc)
55dc: e79e1183 ldr r1, [lr, r3, lsl #3]
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
55e0: e2833001 add r3, r3, #1
{
if (fd->blocks[block].segment == sc)
55e4: e1550001 cmp r5, r1
count++;
55e8: 028cc001 addeq ip, ip, #1
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
55ec: e1530002 cmp r3, r2
55f0: 1afffff9 bne 55dc <bsp_section_rodata_size+0x6d8>
" 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 +
sc->pages_used + sc->pages_bad),
55f4: e285201c add r2, r5, #28
55f8: e892000c ldm r2, {r2, r3}
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
55fc: e59d102c ldr r1, [sp, #44] ; 0x2c
5600: e88d0405 stm sp, {r0, r2, sl}
5604: e58d300c str r3, [sp, #12]
5608: e58d9010 str r9, [sp, #16]
560c: e58d1014 str r1, [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)
5610: e5951024 ldr r1, [r5, #36] ; 0x24
5614: e0822001 add r2, r2, r1
5618: e0823003 add r3, r2, r3
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
561c: e063e000 rsb lr, r3, r0
5620: e1a0200b mov r2, fp
5624: e28d3060 add r3, sp, #96 ; 0x60
5628: e1a00006 mov r0, r6
562c: e59f1790 ldr r1, [pc, #1936] ; 5dc4 <bsp_section_rodata_size+0xec0>
5630: e58dc01c str ip, [sp, #28]
5634: e58de018 str lr, [sp, #24]
5638: ebfff91f bl 3abc <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++)
563c: e59dc034 ldr ip, [sp, #52] ; 0x34
5640: e596302c ldr r3, [r6, #44] ; 0x2c
5644: e083300c add r3, r3, ip
5648: e5932004 ldr r2, [r3, #4]
564c: e59dc030 ldr ip, [sp, #48] ; 0x30
5650: e28bb001 add fp, fp, #1
5654: e28cc030 add ip, ip, #48 ; 0x30
5658: e15b0002 cmp fp, r2
565c: e58dc030 str ip, [sp, #48] ; 0x30
5660: 3affff9a bcc 54d0 <bsp_section_rodata_size+0x5cc>
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++)
5664: e59dc03c ldr ip, [sp, #60] ; 0x3c
5668: e5963030 ldr r3, [r6, #48] ; 0x30
566c: e28cc001 add ip, ip, #1
5670: e58dc03c str ip, [sp, #60] ; 0x3c
5674: e15c0003 cmp ip, r3
5678: e59dc034 ldr ip, [sp, #52] ; 0x34
567c: e28cc00c add ip, ip, #12
5680: e58dc034 str ip, [sp, #52] ; 0x34
5684: 3affff7d bcc 5480 <bsp_section_rodata_size+0x57c>
count);
}
}
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
5688: e5964040 ldr r4, [r6, #64] ; 0x40
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
568c: e1a00006 mov r0, r6
5690: e59f1730 ldr r1, [pc, #1840] ; 5dc8 <bsp_section_rodata_size+0xec4>
5694: ebfff908 bl 3abc <rtems_fdisk_printf>
while (sc)
5698: e3540000 cmp r4, #0
569c: 0a00000d beq 56d8 <bsp_section_rodata_size+0x7d4>
56a0: e3a05000 mov r5, #0
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
56a4: e594200c ldr r2, [r4, #12]
56a8: e5943008 ldr r3, [r4, #8]
56ac: e58d2000 str r2, [sp]
56b0: e594c020 ldr ip, [r4, #32]
56b4: e1a02005 mov r2, r5
56b8: e1a00006 mov r0, r6
56bc: e59f1708 ldr r1, [pc, #1800] ; 5dcc <bsp_section_rodata_size+0xec8>
56c0: e58dc004 str ip, [sp, #4]
56c4: ebfff8fc bl 3abc <rtems_fdisk_printf>
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
56c8: e5944000 ldr r4, [r4]
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
while (sc)
56cc: e3540000 cmp r4, #0
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
count++;
56d0: e2855001 add r5, r5, #1
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
while (sc)
56d4: 1afffff2 bne 56a4 <bsp_section_rodata_size+0x7a0>
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
count++;
}
}
fd->info_level = current_info_level;
56d8: e59dc044 ldr ip, [sp, #68] ; 0x44
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]);
56dc: e59f0684 ldr r0, [pc, #1668] ; 5d68 <bsp_section_rodata_size+0xe64>
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
count++;
}
}
fd->info_level = current_info_level;
56e0: e586c06c str ip, [r6, #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]);
56e4: e5901000 ldr r1, [r0]
56e8: e59d6038 ldr r6, [sp, #56] ; 0x38
56ec: e59dc040 ldr ip, [sp, #64] ; 0x40
56f0: e3a03000 mov r3, #0
56f4: e0811006 add r1, r1, r6
56f8: e58c3000 str r3, [ip]
break;
56fc: eafffe95 b 5158 <bsp_section_rodata_size+0x254>
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
5700: e591c004 ldr ip, [r1, #4]
5704: e37c0001 cmn ip, #1
5708: 1affff86 bne 5528 <bsp_section_rodata_size+0x624>
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
erased++;
570c: e59dc02c ldr ip, [sp, #44] ; 0x2c
5710: e28cc001 add ip, ip, #1
5714: e58dc02c str ip, [sp, #44] ; 0x2c
5718: eaffff89 b 5544 <bsp_section_rodata_size+0x640>
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
571c: e596201c ldr r2, [r6, #28] <== NOT EXECUTED
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;
uint32_t active = 0;
5720: e1a0a000 mov sl, r0 <== NOT EXECUTED
uint32_t used = 0;
5724: e1a09000 mov r9, r0 <== NOT EXECUTED
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;
5728: e58d002c str r0, [sp, #44] ; 0x2c <== NOT EXECUTED
572c: eaffffa4 b 55c4 <bsp_section_rodata_size+0x6c0> <== NOT EXECUTED
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
(rtems_flashdisks[minor].device_count == 0))
{
errno = ENODEV;
5730: eb006797 bl 1f594 <__errno> <== NOT EXECUTED
5734: e59f262c ldr r2, [pc, #1580] ; 5d68 <bsp_section_rodata_size+0xe64><== NOT EXECUTED
5738: e59d6038 ldr r6, [sp, #56] ; 0x38 <== NOT EXECUTED
573c: e5921000 ldr r1, [r2] <== NOT EXECUTED
5740: e3a03013 mov r3, #19 <== NOT EXECUTED
5744: e5803000 str r3, [r0] <== NOT EXECUTED
5748: e0811006 add r1, r1, r6 <== NOT EXECUTED
574c: eafffe81 b 5158 <bsp_section_rodata_size+0x254> <== NOT EXECUTED
else
{
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
5750: eb00678f bl 1f594 <__errno>
5754: e59fc60c ldr ip, [pc, #1548] ; 5d68 <bsp_section_rodata_size+0xe64>
5758: e59c6000 ldr r6, [ip]
575c: e59dc038 ldr ip, [sp, #56] ; 0x38
5760: e58d003c str r0, [sp, #60] ; 0x3c
* @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;
5764: e5954010 ldr r4, [r5, #16]
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
5768: e58d7030 str r7, [sp, #48] ; 0x30
576c: e58d502c str r5, [sp, #44] ; 0x2c
* @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;
5770: e2859018 add r9, r5, #24
else
{
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
5774: e086600c add r6, r6, ip
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
5778: e59dc030 ldr ip, [sp, #48] ; 0x30
577c: e15c0004 cmp ip, r4
5780: 2a0000b0 bcs 5a48 <bsp_section_rodata_size+0xb44>
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
5784: e5990004 ldr r0, [r9, #4]
5788: e5961014 ldr r1, [r6, #20]
578c: ebfff0c5 bl 1aa8 <__aeabi_uidiv>
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
5790: e3500000 cmp r0, #0
5794: e58d0040 str r0, [sp, #64] ; 0x40
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
5798: e5995008 ldr r5, [r9, #8]
for (b = 0; b < fb; b++, data += fd->block_size)
579c: 0a000095 beq 59f8 <bsp_section_rodata_size+0xaf4>
57a0: e3a0b000 mov fp, #0
{
ret = rtems_fdisk_read_block (fd, sg->block + b, data);
57a4: e5997000 ldr r7, [r9]
57a8: e08b7007 add r7, fp, r7
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);
57ac: e1a00006 mov r0, r6
57b0: e59f1618 ldr r1, [pc, #1560] ; 5dd0 <bsp_section_rodata_size+0xecc>
57b4: e1a02007 mov r2, r7
57b8: ebfff89b bl 3a2c <rtems_fdisk_info>
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
57bc: e286001c add r0, r6, #28
57c0: e8900009 ldm r0, {r0, r3}
57c4: e0403003 sub r3, r0, r3
57c8: e1570003 cmp r7, r3
57cc: 2a000074 bcs 59a4 <bsp_section_rodata_size+0xaa0>
{
rtems_fdisk_error ("read-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
57d0: e5968018 ldr r8, [r6, #24]
if (!bc->segment)
57d4: e7984187 ldr r4, [r8, r7, lsl #3]
57d8: e3540000 cmp r4, #0
{
rtems_fdisk_error ("read-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
57dc: e0888187 add r8, r8, r7, lsl #3
if (!bc->segment)
57e0: 0a000074 beq 59b8 <bsp_section_rodata_size+0xab4>
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
57e4: e5943024 ldr r3, [r4, #36] ; 0x24
57e8: e594101c ldr r1, [r4, #28]
57ec: e58d3048 str r3, [sp, #72] ; 0x48
57f0: e5943000 ldr r3, [r4]
57f4: e58d104c str r1, [sp, #76] ; 0x4c
57f8: e59f1600 ldr r1, [pc, #1536] ; 5e00 <bsp_section_rodata_size+0xefc>
57fc: e3530000 cmp r3, #0
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
5800: e5982004 ldr r2, [r8, #4]
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
5804: e594e014 ldr lr, [r4, #20]
5808: e59f05f4 ldr r0, [pc, #1524] ; 5e04 <bsp_section_rodata_size+0xf00>
580c: 11a00001 movne r0, r1
5810: e594100c ldr r1, [r4, #12]
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
5814: e594c010 ldr ip, [r4, #16]
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
5818: e594a020 ldr sl, [r4, #32]
581c: e5943008 ldr r3, [r4, #8]
5820: e58d0044 str r0, [sp, #68] ; 0x44
5824: e88d4006 stm sp, {r1, r2, lr}
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
5828: e1a00182 lsl r0, r2, #3
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
582c: e59d204c ldr r2, [sp, #76] ; 0x4c
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
5830: e58d0034 str r0, [sp, #52] ; 0x34
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
5834: e59d1044 ldr r1, [sp, #68] ; 0x44
5838: e59d0048 ldr r0, [sp, #72] ; 0x48
583c: e58d200c str r2, [sp, #12]
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
5840: e59d2034 ldr r2, [sp, #52] ; 0x34
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
5844: e58da010 str sl, [sp, #16]
5848: e58d0014 str r0, [sp, #20]
584c: e58d1018 str r1, [sp, #24]
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
5850: e08ca002 add sl, ip, r2
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
5854: e1da20b2 ldrh r2, [sl, #2]
5858: e59d0034 ldr r0, [sp, #52] ; 0x34
585c: e58d201c str r2, [sp, #28]
5860: e19c20b0 ldrh r2, [ip, r0]
5864: e58d2020 str r2, [sp, #32]
5868: e59ae004 ldr lr, [sl, #4]
586c: e1a00006 mov r0, r6
5870: e59f155c ldr r1, [pc, #1372] ; 5dd4 <bsp_section_rodata_size+0xed0>
5874: e1a02007 mov r2, r7
5878: e58de024 str lr, [sp, #36] ; 0x24
587c: e58dc028 str ip, [sp, #40] ; 0x28
5880: ebfff869 bl 3a2c <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;
5884: e1da30b2 ldrh r3, [sl, #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))
5888: e3130001 tst r3, #1
588c: 1a000015 bne 58e8 <bsp_section_rodata_size+0x9e4>
{
if (rtems_fdisk_page_desc_flags_clear (pd, RTEMS_FDISK_PAGE_USED))
5890: e3130002 tst r3, #2
5894: 1a00001c bne 590c <bsp_section_rodata_size+0xa08>
rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
block, cs, pd->crc);
}
else
{
rtems_fdisk_error ("read-block: block points to used page: %d: %d-%d-%d",
5898: e2842008 add r2, r4, #8 <== NOT EXECUTED
589c: e598c004 ldr ip, [r8, #4] <== NOT EXECUTED
58a0: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
58a4: e1a01007 mov r1, r7 <== NOT EXECUTED
58a8: e59f0528 ldr r0, [pc, #1320] ; 5dd8 <bsp_section_rodata_size+0xed4><== NOT EXECUTED
58ac: e59d502c ldr r5, [sp, #44] ; 0x2c <== NOT EXECUTED
58b0: e58dc000 str ip, [sp] <== NOT EXECUTED
58b4: ebfff95d bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
58b8: 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);
58bc: e1a00005 mov r0, r5
58c0: e1a0e00f mov lr, pc
58c4: e595f004 ldr pc, [r5, #4]
else
{
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
58c8: e59f0498 ldr r0, [pc, #1176] ; 5d68 <bsp_section_rodata_size+0xe64>
58cc: e59d603c ldr r6, [sp, #60] ; 0x3c
58d0: e5901000 ldr r1, [r0]
58d4: e59dc038 ldr ip, [sp, #56] ; 0x38
58d8: e3a03000 mov r3, #0
58dc: e5863000 str r3, [r6]
58e0: e081100c add r1, r1, ip
break;
58e4: eafffe1b b 5158 <bsp_section_rodata_size+0x254>
block, sc->device, sc->segment, bc->page);
}
}
else
{
rtems_fdisk_error ("read-block: block page not active: %d: %d-%d-%d",
58e8: e2842008 add r2, r4, #8 <== NOT EXECUTED
58ec: e598c004 ldr ip, [r8, #4] <== NOT EXECUTED
58f0: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
58f4: e1a01007 mov r1, r7 <== NOT EXECUTED
58f8: e59f04dc ldr r0, [pc, #1244] ; 5ddc <bsp_section_rodata_size+0xed8><== NOT EXECUTED
58fc: e59d502c ldr r5, [sp, #44] ; 0x2c <== NOT EXECUTED
5900: e58dc000 str ip, [sp] <== NOT EXECUTED
5904: ebfff949 bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
5908: eaffffea b 58b8 <bsp_section_rodata_size+0x9b4> <== NOT EXECUTED
/*
* 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,
590c: e5983004 ldr r3, [r8, #4]
5910: e5942018 ldr r2, [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);
5914: e596e014 ldr lr, [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,
5918: e0822003 add r2, r2, r3
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,
591c: e1a00006 mov r0, r6
5920: e1a03005 mov r3, r5
5924: e1a01004 mov r1, r4
5928: e002029e mul r2, lr, r2
592c: e58de000 str lr, [sp]
5930: ebfff885 bl 3b4c <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)
5934: e2503000 subs r3, r0, #0
5938: e59dc028 ldr ip, [sp, #40] ; 0x28
593c: 1a000032 bne 5a0c <bsp_section_rodata_size+0xb08>
strerror (ret), ret);
#endif
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
5940: e5961014 ldr r1, [r6, #20]
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++)
5944: e3510000 cmp r1, #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;
5948: 059f24ac ldreq r2, [pc, #1196] ; 5dfc <bsp_section_rodata_size+0xef8>
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
594c: 0a00000b beq 5980 <bsp_section_rodata_size+0xa7c>
5950: e59f2410 ldr r2, [pc, #1040] ; 5d68 <bsp_section_rodata_size+0xe64>
5954: e592e008 ldr lr, [r2, #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;
5958: e59f249c ldr r2, [pc, #1180] ; 5dfc <bsp_section_rodata_size+0xef8>
* @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)
595c: e0850001 add r0, r5, r1
5960: e1a03005 mov r3, r5
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
5964: e4d34001 ldrb r4, [r3], #1
5968: e0242002 eor r2, r4, r2
596c: e20220ff and r2, r2, #255 ; 0xff
5970: e1a02082 lsl r2, r2, #1
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++)
5974: e1530000 cmp r3, r0
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
5978: e19e20b2 ldrh r2, [lr, 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++)
597c: 1afffff8 bne 5964 <bsp_section_rodata_size+0xa60>
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
if (cs == pd->crc)
5980: e59d0034 ldr r0, [sp, #52] ; 0x34
5984: e19c30b0 ldrh r3, [ip, r0]
5988: e1520003 cmp r2, r3
598c: 0a000012 beq 59dc <bsp_section_rodata_size+0xad8>
return 0;
rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
5990: e1a01007 mov r1, r7 <== NOT EXECUTED
5994: e59f0444 ldr r0, [pc, #1092] ; 5de0 <bsp_section_rodata_size+0xedc><== NOT EXECUTED
5998: e59d502c ldr r5, [sp, #44] ; 0x2c <== NOT EXECUTED
599c: ebfff923 bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
59a0: eaffffc4 b 58b8 <bsp_section_rodata_size+0x9b4> <== NOT EXECUTED
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
{
rtems_fdisk_error ("read-block: block out of range: %d", block);
59a4: e1a01007 mov r1, r7 <== NOT EXECUTED
59a8: e59f0434 ldr r0, [pc, #1076] ; 5de4 <bsp_section_rodata_size+0xee0><== NOT EXECUTED
59ac: e59d502c ldr r5, [sp, #44] ; 0x2c <== NOT EXECUTED
59b0: ebfff91e bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
59b4: eaffffbf b 58b8 <bsp_section_rodata_size+0x9b4> <== NOT EXECUTED
bc = &fd->blocks[block];
if (!bc->segment)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block: no segment mapping: %d", block);
59b8: e59f1428 ldr r1, [pc, #1064] ; 5de8 <bsp_section_rodata_size+0xee4>
59bc: e1a02007 mov r2, r7
59c0: e1a00006 mov r0, r6
59c4: ebfff818 bl 3a2c <rtems_fdisk_info>
#endif
memset (buffer, 0xff, fd->block_size);
59c8: e3a010ff mov r1, #255 ; 0xff
59cc: e1a00005 mov r0, r5
59d0: e5962014 ldr r2, [r6, #20]
59d4: eb006a41 bl 202e0 <memset>
59d8: e5961014 ldr r1, [r6, #20]
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)
59dc: e59dc040 ldr ip, [sp, #64] ; 0x40
59e0: e28bb001 add fp, fp, #1
59e4: e15b000c cmp fp, ip
59e8: e0855001 add r5, r5, r1
59ec: 1affff6c bne 57a4 <bsp_section_rodata_size+0x8a0>
59f0: e59dc02c ldr ip, [sp, #44] ; 0x2c
59f4: e59c4010 ldr r4, [ip, #16]
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
59f8: e59dc030 ldr ip, [sp, #48] ; 0x30
59fc: e28cc001 add ip, ip, #1
5a00: e58dc030 str ip, [sp, #48] ; 0x30
5a04: e2899010 add r9, r9, #16
5a08: eaffff5a b 5778 <bsp_section_rodata_size+0x874>
5a0c: e1a0b003 mov fp, r3 <== NOT EXECUTED
bc->page + sc->pages_desc, buffer);
if (ret)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
5a10: e5947008 ldr r7, [r4, #8] <== NOT EXECUTED
5a14: e5988004 ldr r8, [r8, #4] <== NOT EXECUTED
5a18: e594400c ldr r4, [r4, #12] <== NOT EXECUTED
5a1c: e59d502c ldr r5, [sp, #44] ; 0x2c <== NOT EXECUTED
5a20: eb006f4d bl 2175c <strerror> <== NOT EXECUTED
5a24: e59f13c0 ldr r1, [pc, #960] ; 5dec <bsp_section_rodata_size+0xee8><== NOT EXECUTED
5a28: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
5a2c: e1a02007 mov r2, r7 <== NOT EXECUTED
5a30: e1a00006 mov r0, r6 <== NOT EXECUTED
5a34: e1a03004 mov r3, r4 <== NOT EXECUTED
5a38: e58d8000 str r8, [sp] <== NOT EXECUTED
5a3c: e58db008 str fp, [sp, #8] <== NOT EXECUTED
5a40: ebfff7f9 bl 3a2c <rtems_fdisk_info> <== NOT EXECUTED
5a44: eaffff9b b 58b8 <bsp_section_rodata_size+0x9b4> <== NOT EXECUTED
5a48: e59d502c ldr r5, [sp, #44] ; 0x2c
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
5a4c: e3a01000 mov r1, #0
5a50: eaffff99 b 58bc <bsp_section_rodata_size+0x9b8>
ret = rtems_fdisk_erase_flash (fd);
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
5a54: e3530000 cmp r3, #0 <== NOT EXECUTED
5a58: 0afffdfc beq 5250 <bsp_section_rodata_size+0x34c> <== NOT EXECUTED
{
if (!fd->devices[device].segments)
5a5c: e595302c ldr r3, [r5, #44] ; 0x2c <== NOT EXECUTED
5a60: e5933000 ldr r3, [r3] <== NOT EXECUTED
5a64: e3530000 cmp r3, #0 <== NOT EXECUTED
5a68: 13a0600c movne r6, #12 <== NOT EXECUTED
5a6c: 11a04000 movne r4, r0 <== NOT EXECUTED
5a70: 1a000008 bne 5a98 <bsp_section_rodata_size+0xb94> <== NOT EXECUTED
5a74: ea0001ce b 61b4 <bsp_section_rodata_size+0x12b0> <== NOT EXECUTED
ret = rtems_fdisk_erase_flash (fd);
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
5a78: e5953030 ldr r3, [r5, #48] ; 0x30 <== NOT EXECUTED
5a7c: e1540003 cmp r4, r3 <== NOT EXECUTED
5a80: 2afffdf2 bcs 5250 <bsp_section_rodata_size+0x34c> <== NOT EXECUTED
{
if (!fd->devices[device].segments)
5a84: e595302c ldr r3, [r5, #44] ; 0x2c <== NOT EXECUTED
5a88: e7933006 ldr r3, [r3, r6] <== NOT EXECUTED
5a8c: e3530000 cmp r3, #0 <== NOT EXECUTED
5a90: e286600c add r6, r6, #12 <== NOT EXECUTED
5a94: 0a0001c6 beq 61b4 <bsp_section_rodata_size+0x12b0> <== NOT EXECUTED
return ENOMEM;
ret = rtems_fdisk_recover_block_mappings (fd);
5a98: e1a00005 mov r0, r5 <== NOT EXECUTED
5a9c: ebfffbd2 bl 49ec <rtems_fdisk_recover_block_mappings> <== NOT EXECUTED
if (ret)
5aa0: e3500000 cmp r0, #0 <== NOT EXECUTED
ret = rtems_fdisk_erase_flash (fd);
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
5aa4: e2844001 add r4, r4, #1 <== NOT EXECUTED
{
if (!fd->devices[device].segments)
return ENOMEM;
ret = rtems_fdisk_recover_block_mappings (fd);
if (ret)
5aa8: 0afffff2 beq 5a78 <bsp_section_rodata_size+0xb74> <== NOT EXECUTED
5aac: eafffde7 b 5250 <bsp_section_rodata_size+0x34c> <== NOT EXECUTED
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);
5ab0: eb0066b7 bl 1f594 <__errno>
5ab4: e58d0058 str r0, [sp, #88] ; 0x58
5ab8: e59f02a8 ldr r0, [pc, #680] ; 5d68 <bsp_section_rodata_size+0xe64>
5abc: e59dc038 ldr ip, [sp, #56] ; 0x38
5ac0: e5904000 ldr r4, [r0]
5ac4: e084400c add r4, r4, ip
* @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)
5ac8: e285c028 add ip, r5, #40 ; 0x28
5acc: e58dc030 str ip, [sp, #48] ; 0x30
5ad0: e3a0c001 mov ip, #1
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);
5ad4: e5956010 ldr r6, [r5, #16]
* @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)
5ad8: e58dc040 str ip, [sp, #64] ; 0x40
5adc: e58d502c str r5, [sp, #44] ; 0x2c
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
5ae0: e59dc040 ldr ip, [sp, #64] ; 0x40
5ae4: e24c3001 sub r3, ip, #1
5ae8: e1530006 cmp r3, r6
5aec: 2a0001ad bcs 61a8 <bsp_section_rodata_size+0x12a4>
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
5af0: e59dc030 ldr ip, [sp, #48] ; 0x30
5af4: e5941014 ldr r1, [r4, #20]
5af8: e51c000c ldr r0, [ip, #-12]
5afc: ebffefe9 bl 1aa8 <__aeabi_uidiv>
data = sg->buffer;
5b00: e59dc030 ldr ip, [sp, #48] ; 0x30
for (b = 0; b < fb; b++, data += fd->block_size)
5b04: e3500000 cmp r0, #0
5b08: e58d005c str r0, [sp, #92] ; 0x5c
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
5b0c: e51cb008 ldr fp, [ip, #-8]
for (b = 0; b < fb; b++, data += fd->block_size)
5b10: 0a000139 beq 5ffc <bsp_section_rodata_size+0x10f8>
5b14: e3a06000 mov r6, #0
5b18: e58d6034 str r6, [sp, #52] ; 0x34
{
ret = rtems_fdisk_write_block (fd, sg->block + b, data);
5b1c: e59dc030 ldr ip, [sp, #48] ; 0x30
5b20: e59d6034 ldr r6, [sp, #52] ; 0x34
5b24: e51ca010 ldr sl, [ip, #-16]
5b28: e086a00a add sl, r6, sl
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d", block);
5b2c: e1a00004 mov r0, r4
5b30: e59f12b8 ldr r1, [pc, #696] ; 5df0 <bsp_section_rodata_size+0xeec>
5b34: e1a0200a mov r2, sl
5b38: ebfff7bb bl 3a2c <rtems_fdisk_info>
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
5b3c: e284c01c add ip, r4, #28
5b40: e89c1008 ldm ip, {r3, ip}
5b44: e043300c sub r3, r3, ip
5b48: e15a0003 cmp sl, r3
5b4c: 2a000131 bcs 6018 <bsp_section_rodata_size+0x1114>
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
5b50: e5946018 ldr r6, [r4, #24]
/*
* Does the page exist in flash ?
*/
if (bc->segment)
5b54: e796518a ldr r5, [r6, sl, lsl #3]
5b58: e3550000 cmp r5, #0
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
5b5c: e58d6044 str r6, [sp, #68] ; 0x44
5b60: e086818a add r8, r6, sl, lsl #3
/*
* Does the page exist in flash ?
*/
if (bc->segment)
5b64: 0a000061 beq 5cf0 <bsp_section_rodata_size+0xdec>
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
5b68: e598c004 ldr ip, [r8, #4]
5b6c: e5956010 ldr r6, [r5, #16]
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
5b70: e2852008 add r2, r5, #8
5b74: e892000c ldm r2, {r2, r3}
5b78: e59f1274 ldr r1, [pc, #628] ; 5df4 <bsp_section_rodata_size+0xef0>
5b7c: e1a00004 mov r0, r4
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
5b80: e58dc048 str ip, [sp, #72] ; 0x48
5b84: e58d6050 str r6, [sp, #80] ; 0x50
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
5b88: e58dc000 str ip, [sp]
5b8c: ebfff7a6 bl 3a2c <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,
5b90: e5952018 ldr r2, [r5, #24]
5b94: e5983004 ldr r3, [r8, #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);
5b98: e594c014 ldr ip, [r4, #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,
5b9c: 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,
5ba0: e006039c mul r6, ip, r3
#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,
5ba4: e5957008 ldr r7, [r5, #8]
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;
5ba8: e594302c ldr r3, [r4, #44] ; 0x2c
5bac: e0872087 add r2, r7, r7, lsl #1
#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,
5bb0: e595900c ldr r9, [r5, #12]
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;
5bb4: e7931102 ldr r1, [r3, r2, lsl #2]
5bb8: e0833102 add r3, r3, r2, lsl #2
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);
5bbc: e58dc03c str ip, [sp, #60] ; 0x3c
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;
5bc0: e593c008 ldr ip, [r3, #8]
uint32_t device,
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
5bc4: e58d604c str r6, [sp, #76] ; 0x4c
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;
5bc8: e0890089 add r0, r9, r9, lsl #1
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;
5bcc: e59c6008 ldr r6, [ip, #8]
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;
5bd0: e0811200 add r1, r1, r0, lsl #4
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",
5bd4: e59dc04c ldr ip, [sp, #76] ; 0x4c
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;
5bd8: e5911004 ldr r1, [r1, #4]
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",
5bdc: e58dc000 str ip, [sp]
5be0: e59dc03c ldr ip, [sp, #60] ; 0x3c
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;
5be4: e58d1054 str r1, [sp, #84] ; 0x54
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",
5be8: e1a02007 mov r2, r7
5bec: e59f1204 ldr r1, [pc, #516] ; 5df8 <bsp_section_rodata_size+0xef4>
5bf0: e1a03009 mov r3, r9
5bf4: e1a00004 mov r0, r4
5bf8: e58dc004 str ip, [sp, #4]
5bfc: ebfff7ae bl 3abc <rtems_fdisk_printf>
device, segment, offset, size);
#endif
return ops->verify (sd, device, segment, offset, buffer, size);
5c00: e59dc03c ldr ip, [sp, #60] ; 0x3c
5c04: e58db000 str fp, [sp]
5c08: e58dc004 str ip, [sp, #4]
5c0c: e59d0054 ldr r0, [sp, #84] ; 0x54
5c10: e1a01007 mov r1, r7
5c14: e1a02009 mov r2, r9
5c18: e59d304c ldr r3, [sp, #76] ; 0x4c
5c1c: e1a0e00f mov lr, pc
5c20: e596f00c ldr pc, [r6, #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,
5c24: e3500000 cmp r0, #0
5c28: 0a000115 beq 6084 <bsp_section_rodata_size+0x1180>
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
5c2c: e59d6050 ldr r6, [sp, #80] ; 0x50
5c30: e59dc048 ldr ip, [sp, #72] ; 0x48
* 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);
5c34: e5989004 ldr r9, [r8, #4]
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
5c38: e086718c add r7, r6, ip, 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;
5c3c: e1d720b2 ldrh r2, [r7, #2]
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))
5c40: e5941008 ldr r1, [r4, #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)) +
5c44: e1a03189 lsl r3, r9, #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;
5c48: e3c22002 bic r2, r2, #2
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));
5c4c: e2833002 add r3, r3, #2
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
5c50: e3110008 tst r1, #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;
5c54: e1c720b2 strh r2, [r7, #2]
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));
5c58: e58d303c str r3, [sp, #60] ; 0x3c
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
5c5c: 0a00000d beq 5c98 <bsp_section_rodata_size+0xd94>
{
uint16_t flash_flags;
int ret;
ret = rtems_fdisk_seg_read (fd, sc, offset,
5c60: e1a02003 mov r2, r3
5c64: e3a0c002 mov ip, #2
5c68: e1a00004 mov r0, r4
5c6c: e1a01005 mov r1, r5
5c70: e28d3066 add r3, sp, #102 ; 0x66
5c74: e58dc000 str ip, [sp]
5c78: ebfff7b3 bl 3b4c <rtems_fdisk_seg_read>
&flash_flags, sizeof (flash_flags));
if (ret)
5c7c: e2506000 subs r6, r0, #0
5c80: 1a00012e bne 6140 <bsp_section_rodata_size+0x123c>
return ret;
if ((flash_flags & page_desc->flags) != page_desc->flags)
5c84: e1d7c0b2 ldrh ip, [r7, #2]
5c88: e1dde6b6 ldrh lr, [sp, #102] ; 0x66
5c8c: e00e300c and r3, lr, ip
5c90: e15c0003 cmp ip, r3
5c94: 1a000148 bne 61bc <bsp_section_rodata_size+0x12b8>
sc->device, sc->segment, page,
flash_flags, page_desc->flags);
return ret;
}
}
return rtems_fdisk_seg_write (fd, sc, offset,
5c98: e3a0c002 mov ip, #2
5c9c: e1a00004 mov r0, r4
5ca0: e1a01005 mov r1, r5
5ca4: e59d203c ldr r2, [sp, #60] ; 0x3c
5ca8: e2873002 add r3, r7, #2
5cac: e58dc000 str ip, [sp]
5cb0: ebfff7e5 bl 3c4c <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)
5cb4: e2506000 subs r6, r0, #0
5cb8: 1a000120 bne 6140 <bsp_section_rodata_size+0x123c>
#endif
}
else
{
sc->pages_active--;
sc->pages_used++;
5cbc: e285201c add r2, r5, #28
5cc0: e892000c ldm r2, {r2, r3}
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
5cc4: e2422001 sub r2, r2, #1
sc->pages_used++;
5cc8: e2833001 add r3, r3, #1
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
5ccc: e585201c str r2, [r5, #28]
sc->pages_used++;
5cd0: e5853020 str r3, [r5, #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);
5cd4: e1a00004 mov r0, r4
5cd8: e1a01005 mov r1, r5
5cdc: ebfff8eb bl 4090 <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)
5ce0: e5943008 ldr r3, [r4, #8]
5ce4: e3130002 tst r3, #2
rtems_fdisk_compact (fd);
5ce8: 01a00004 moveq r0, r4
5cec: 0bfffa96 bleq 474c <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;
5cf0: e5946034 ldr r6, [r4, #52] ; 0x34
uint32_t count = 0;
while (sc)
5cf4: e3560000 cmp r6, #0
5cf8: 0a000104 beq 6110 <bsp_section_rodata_size+0x120c>
5cfc: e1a03006 mov r3, r6
5d00: e3a02000 mov r2, #0
{
count++;
sc = sc->next;
5d04: e5933000 ldr r3, [r3]
rtems_fdisk_segment_count_queue (rtems_fdisk_segment_ctl_queue* queue)
{
rtems_fdisk_segment_ctl* sc = queue->head;
uint32_t count = 0;
while (sc)
5d08: e3530000 cmp r3, #0
{
count++;
5d0c: 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)
5d10: 1afffffb bne 5d04 <bsp_section_rodata_size+0xe00>
/*
* Is it time to compact the disk ?
*
* We override the background compaction configruation.
*/
if (rtems_fdisk_segment_count_queue (&fd->available) <=
5d14: e5943010 ldr r3, [r4, #16]
5d18: e1530002 cmp r3, r2
5d1c: 2a0000fb bcs 6110 <bsp_section_rodata_size+0x120c>
{
if (queue->head)
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
5d20: e5963000 ldr r3, [r6]
if (!queue->head)
5d24: e3530000 cmp r3, #0
queue->tail = 0;
5d28: 05843038 streq r3, [r4, #56] ; 0x38
{
if (queue->head)
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
5d2c: e5843034 str r3, [r4, #52] ; 0x34
if (!queue->head)
queue->tail = 0;
queue->count--;
5d30: e594303c ldr r3, [r4, #60] ; 0x3c
5d34: e2433001 sub r3, r3, #1
5d38: e584303c str r3, [r4, #60] ; 0x3c
sc->next = 0;
5d3c: e3a03000 mov r3, #0
5d40: e5863000 str r3, [r6]
return ENOSPC;
}
}
#if RTEMS_FDISK_TRACE
if (fd->info_level >= 3)
5d44: e594306c ldr r3, [r4, #108] ; 0x6c
5d48: e3530002 cmp r3, #2
5d4c: 8a0000e1 bhi 60d8 <bsp_section_rodata_size+0x11d4>
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
for (page = 0; page < sc->pages; page++, pd++)
5d50: e596e014 ldr lr, [r6, #20]
5d54: e35e0000 cmp lr, #0
/*
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
5d58: e5965010 ldr r5, [r6, #16]
for (page = 0; page < sc->pages; page++, pd++)
5d5c: 0a0000bd beq 6058 <bsp_section_rodata_size+0x1154>
5d60: e3a07000 mov r7, #0
5d64: ea000036 b 5e44 <bsp_section_rodata_size+0xf40>
5d68: 00044ccc .word 0x00044ccc
5d6c: 20004283 .word 0x20004283 <== NOT EXECUTED
5d70: 20004285 .word 0x20004285 <== NOT EXECUTED
5d74: c0184201 .word 0xc0184201 <== NOT EXECUTED
5d78: 000304e8 .word 0x000304e8 <== NOT EXECUTED
5d7c: 000304f4 .word 0x000304f4 <== NOT EXECUTED
5d80: 00030508 .word 0x00030508 <== NOT EXECUTED
5d84: 0003051c .word 0x0003051c <== NOT EXECUTED
5d88: 00030540 .word 0x00030540 <== NOT EXECUTED
5d8c: 00030550 .word 0x00030550 <== NOT EXECUTED
5d90: 00030564 .word 0x00030564 <== NOT EXECUTED
5d94: 0003057c .word 0x0003057c <== NOT EXECUTED
5d98: 0003058c .word 0x0003058c <== NOT EXECUTED
5d9c: 000305a8 .word 0x000305a8 <== NOT EXECUTED
5da0: 000305c0 .word 0x000305c0 <== NOT EXECUTED
5da4: 000305d8 .word 0x000305d8 <== NOT EXECUTED
5da8: 000300f4 .word 0x000300f4 <== NOT EXECUTED
5dac: 000300f8 .word 0x000300f8 <== NOT EXECUTED
5db0: 000305f0 .word 0x000305f0 <== NOT EXECUTED
5db4: 0003060c .word 0x0003060c <== NOT EXECUTED
5db8: 0003061c .word 0x0003061c <== NOT EXECUTED
5dbc: 0003062c .word 0x0003062c <== NOT EXECUTED
5dc0: 00030640 .word 0x00030640 <== NOT EXECUTED
5dc4: 00030670 .word 0x00030670 <== NOT EXECUTED
5dc8: 000306ac .word 0x000306ac <== NOT EXECUTED
5dcc: 000306b8 .word 0x000306b8 <== NOT EXECUTED
5dd0: 00030100 .word 0x00030100 <== NOT EXECUTED
5dd4: 00030158 .word 0x00030158 <== NOT EXECUTED
5dd8: 0003020c .word 0x0003020c <== NOT EXECUTED
5ddc: 00030240 .word 0x00030240 <== NOT EXECUTED
5de0: 000301d8 .word 0x000301d8 <== NOT EXECUTED
5de4: 00030110 .word 0x00030110 <== NOT EXECUTED
5de8: 00030134 .word 0x00030134 <== NOT EXECUTED
5dec: 000301a0 .word 0x000301a0 <== NOT EXECUTED
5df0: 00030270 .word 0x00030270 <== NOT EXECUTED
5df4: 000302a4 .word 0x000302a4 <== NOT EXECUTED
5df8: 000302c8 .word 0x000302c8 <== NOT EXECUTED
5dfc: 0000ffff .word 0x0000ffff <== NOT EXECUTED
5e00: 0002fd30 .word 0x0002fd30 <== NOT EXECUTED
5e04: 0002fd34 .word 0x0002fd34 <== NOT EXECUTED
5e08: 000303f0 .word 0x000303f0 <== NOT EXECUTED
5e0c: 00030440 .word 0x00030440 <== NOT EXECUTED
5e10: 00030280 .word 0x00030280 <== NOT EXECUTED
5e14: 00044ccc .word 0x00044ccc <== NOT EXECUTED
5e18: 000304b4 .word 0x000304b4 <== NOT EXECUTED
5e1c: 000302f0 .word 0x000302f0 <== NOT EXECUTED
5e20: 000303c8 .word 0x000303c8 <== NOT EXECUTED
5e24: 000303a8 .word 0x000303a8 <== NOT EXECUTED
5e28: 0003036c .word 0x0003036c <== NOT EXECUTED
5e2c: 00030478 .word 0x00030478 <== NOT EXECUTED
5e30: 00030320 .word 0x00030320 <== NOT EXECUTED
5e34: e2877001 add r7, r7, #1
5e38: e157000e cmp r7, lr
5e3c: e2855008 add r5, r5, #8
5e40: 0a000084 beq 6058 <bsp_section_rodata_size+0x1154>
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
5e44: e5953000 ldr r3, [r5]
5e48: e3730001 cmn r3, #1
5e4c: 1afffff8 bne 5e34 <bsp_section_rodata_size+0xf30>
5e50: e5953004 ldr r3, [r5, #4]
5e54: e3730001 cmn r3, #1
5e58: 1afffff5 bne 5e34 <bsp_section_rodata_size+0xf30>
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);
5e5c: e5940014 ldr r0, [r4, #20]
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++)
5e60: e3500000 cmp r0, #0
5e64: 051f9070 ldreq r9, [pc, #-112] ; 5dfc <bsp_section_rodata_size+0xef8>
* 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;
5e68: 01a03009 moveq r3, r9
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
5e6c: 0a00000c beq 5ea4 <bsp_section_rodata_size+0xfa0>
5e70: e51f1064 ldr r1, [pc, #-100] ; 5e14 <bsp_section_rodata_size+0xf10>
5e74: e591c008 ldr ip, [r1, #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;
5e78: e2833801 add r3, r3, #65536 ; 0x10000
* @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)
5e7c: e08b0000 add r0, fp, r0
5e80: e1a0200b mov r2, fp
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
5e84: e4d21001 ldrb r1, [r2], #1
5e88: e0213003 eor r3, r1, r3
5e8c: e20330ff and r3, r3, #255 ; 0xff
5e90: e1a03083 lsl r3, r3, #1
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++)
5e94: e1520000 cmp r2, r0
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
5e98: e19c30b3 ldrh r3, [ip, r3]
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++)
5e9c: 1afffff8 bne 5e84 <bsp_section_rodata_size+0xf80>
5ea0: e1a09003 mov r9, r3
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: " \
5ea4: e596c000 ldr ip, [r6]
5ea8: e596101c ldr r1, [r6, #28]
* 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;
5eac: e1d520b2 ldrh r2, [r5, #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: " \
5eb0: e35c0000 cmp ip, #0
5eb4: e58d104c str r1, [sp, #76] ; 0x4c
if (rtems_fdisk_page_desc_erased (pd))
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
pd->block = block;
bc->segment = sc;
5eb8: e59dc044 ldr ip, [sp, #68] ; 0x44
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: " \
5ebc: e5961020 ldr r1, [r6, #32]
* 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;
5ec0: e3c22001 bic r2, r2, #1
5ec4: e58d203c str r2, [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: " \
5ec8: e5960008 ldr r0, [r6, #8]
5ecc: e58d1050 str r1, [sp, #80] ; 0x50
5ed0: e5961024 ldr r1, [r6, #36] ; 0x24
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);
5ed4: e1c530b0 strh r3, [r5]
pd->block = block;
5ed8: e585a004 str sl, [r5, #4]
bc->segment = sc;
5edc: e78c618a str r6, [ip, sl, 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;
5ee0: e59dc03c ldr ip, [sp, #60] ; 0x3c
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
pd->block = block;
bc->segment = sc;
bc->page = page;
5ee4: e5887004 str r7, [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;
5ee8: e1c5c0b2 strh ip, [r5, #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: " \
5eec: e596c00c ldr ip, [r6, #12]
5ef0: e58dc000 str ip, [sp]
5ef4: e59dc04c ldr ip, [sp, #76] ; 0x4c
5ef8: e51f3100 ldr r3, [pc, #-256] ; 5e00 <bsp_section_rodata_size+0xefc>
5efc: e58dc00c str ip, [sp, #12]
5f00: e59dc050 ldr ip, [sp, #80] ; 0x50
5f04: e58d1054 str r1, [sp, #84] ; 0x54
5f08: e51f210c ldr r2, [pc, #-268] ; 5e04 <bsp_section_rodata_size+0xf00>
5f0c: e58dc010 str ip, [sp, #16]
5f10: 11a02003 movne r2, r3
5f14: e59dc054 ldr ip, [sp, #84] ; 0x54
5f18: e58d2048 str r2, [sp, #72] ; 0x48
5f1c: e58dc014 str ip, [sp, #20]
5f20: e59dc048 ldr ip, [sp, #72] ; 0x48
5f24: e58dc018 str ip, [sp, #24]
5f28: e59dc03c ldr ip, [sp, #60] ; 0x3c
5f2c: e1a0200a mov r2, sl
5f30: e1a03000 mov r3, r0
5f34: e51f1134 ldr r1, [pc, #-308] ; 5e08 <bsp_section_rodata_size+0xf04>
5f38: e1a00004 mov r0, r4
5f3c: e98d4080 stmib sp, {r7, lr}
5f40: e58dc01c str ip, [sp, #28]
5f44: e58d9020 str r9, [sp, #32]
5f48: e58da024 str sl, [sp, #36] ; 0x24
5f4c: ebfff6b6 bl 3a2c <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);
5f50: e5962018 ldr r2, [r6, #24]
5f54: e1a00004 mov r0, r4
5f58: e1a01006 mov r1, r6
5f5c: e0872002 add r2, r7, r2
5f60: e1a0300b mov r3, fp
5f64: ebfff774 bl 3d3c <rtems_fdisk_seg_write_page>
if (ret)
5f68: e250a000 subs sl, r0, #0
5f6c: 0a00004e beq 60ac <bsp_section_rodata_size+0x11a8>
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: write page failed: " \
5f70: e5968008 ldr r8, [r6, #8] <== NOT EXECUTED
5f74: e596500c ldr r5, [r6, #12] <== NOT EXECUTED
5f78: eb006df7 bl 2175c <strerror> <== NOT EXECUTED
5f7c: e51f1178 ldr r1, [pc, #-376] ; 5e0c <bsp_section_rodata_size+0xf08><== NOT EXECUTED
5f80: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
5f84: e1a02008 mov r2, r8 <== NOT EXECUTED
{
ret = rtems_fdisk_seg_write_page_desc (fd, sc, page, pd);
if (ret)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: " \
5f88: e1a00004 mov r0, r4 <== NOT EXECUTED
5f8c: e1a03005 mov r3, r5 <== NOT EXECUTED
5f90: e58d7000 str r7, [sp] <== NOT EXECUTED
5f94: e58da008 str sl, [sp, #8] <== NOT EXECUTED
5f98: ebfff6a3 bl 3a2c <rtems_fdisk_info> <== NOT EXECUTED
{
sc->pages_active++;
}
}
rtems_fdisk_queue_segment (fd, sc);
5f9c: e1a00004 mov r0, r4
5fa0: e1a01006 mov r1, r6
5fa4: ebfff839 bl 4090 <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)
5fa8: e5942028 ldr r2, [r4, #40] ; 0x28
5fac: e5943024 ldr r3, [r4, #36] ; 0x24
5fb0: e1520003 cmp r2, r3
5fb4: 2a000004 bcs 5fcc <bsp_section_rodata_size+0x10c8>
fd->starvations++;
5fb8: e5943070 ldr r3, [r4, #112] ; 0x70
5fbc: e2833001 add r3, r3, #1
5fc0: e5843070 str r3, [r4, #112] ; 0x70
}
rtems_fdisk_queue_segment (fd, sc);
if (rtems_fdisk_is_erased_blocks_starvation (fd))
rtems_fdisk_compact (fd);
5fc4: e1a00004 mov r0, r4
5fc8: ebfff9df bl 474c <rtems_fdisk_compact>
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)
5fcc: e35a0000 cmp sl, #0
5fd0: 1a000072 bne 61a0 <bsp_section_rodata_size+0x129c>
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)
5fd4: e59d6034 ldr r6, [sp, #52] ; 0x34
5fd8: e59dc05c ldr ip, [sp, #92] ; 0x5c
5fdc: e2866001 add r6, r6, #1
5fe0: e5943014 ldr r3, [r4, #20]
5fe4: e156000c cmp r6, ip
5fe8: e58d6034 str r6, [sp, #52] ; 0x34
5fec: e08bb003 add fp, fp, r3
5ff0: 1afffec9 bne 5b1c <bsp_section_rodata_size+0xc18>
5ff4: e59dc02c ldr ip, [sp, #44] ; 0x2c
5ff8: e59c6010 ldr r6, [ip, #16]
5ffc: e59dc030 ldr ip, [sp, #48] ; 0x30
6000: e28cc010 add ip, ip, #16
6004: e58dc030 str ip, [sp, #48] ; 0x30
6008: e59dc040 ldr ip, [sp, #64] ; 0x40
600c: e28cc001 add ip, ip, #1
6010: e58dc040 str ip, [sp, #64] ; 0x40
6014: eafffeb1 b 5ae0 <bsp_section_rodata_size+0xbdc>
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
6018: e1a0100a mov r1, sl <== NOT EXECUTED
601c: e51f0214 ldr r0, [pc, #-532] ; 5e10 <bsp_section_rodata_size+0xf0c><== NOT EXECUTED
6020: e59d502c ldr r5, [sp, #44] ; 0x2c <== NOT EXECUTED
6024: ebfff781 bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
6028: e3a0101b mov r1, #27 <== NOT EXECUTED
602c: e1a00005 mov r0, r5
6030: e1a0e00f mov lr, pc
6034: e595f004 ldr pc, [r5, #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);
6038: e51f022c ldr r0, [pc, #-556] ; 5e14 <bsp_section_rodata_size+0xf10>
603c: e59d6058 ldr r6, [sp, #88] ; 0x58
6040: e5901000 ldr r1, [r0]
6044: e59dc038 ldr ip, [sp, #56] ; 0x38
6048: e3a03000 mov r3, #0
604c: e5863000 str r3, [r6]
6050: e081100c add r1, r1, ip
break;
6054: eafffc3f b 5158 <bsp_section_rodata_size+0x254>
return ret;
}
}
rtems_fdisk_error ("write-block: no erased page descs in segment: %d-%d",
6058: e2861008 add r1, r6, #8 <== NOT EXECUTED
605c: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
6060: e51f0250 ldr r0, [pc, #-592] ; 5e18 <bsp_section_rodata_size+0xf14><== NOT EXECUTED
6064: e59d502c ldr r5, [sp, #44] ; 0x2c <== NOT EXECUTED
6068: ebfff770 bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
sc->device, sc->segment);
sc->failed = true;
606c: e3a03001 mov r3, #1 <== NOT EXECUTED
6070: e5863028 str r3, [r6, #40] ; 0x28 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, sc);
6074: e1a00004 mov r0, r4 <== NOT EXECUTED
6078: e1a01006 mov r1, r6 <== NOT EXECUTED
607c: ebfff803 bl 4090 <rtems_fdisk_queue_segment> <== NOT EXECUTED
6080: eaffffe8 b 6028 <bsp_section_rodata_size+0x1124> <== NOT EXECUTED
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
bc->page + sc->pages_desc, buffer) == 0)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d=>%02d-%03d-%03d: page verified",
6084: e595200c ldr r2, [r5, #12]
6088: e5953008 ldr r3, [r5, #8]
608c: e58d2000 str r2, [sp]
6090: e598c004 ldr ip, [r8, #4]
6094: e1a00004 mov r0, r4
6098: e51f1284 ldr r1, [pc, #-644] ; 5e1c <bsp_section_rodata_size+0xf18>
609c: e1a0200a mov r2, sl
60a0: e58dc004 str ip, [sp, #4]
60a4: ebfff660 bl 3a2c <rtems_fdisk_info>
60a8: eaffffc9 b 5fd4 <bsp_section_rodata_size+0x10d0>
strerror (ret), ret);
#endif
}
else
{
ret = rtems_fdisk_seg_write_page_desc (fd, sc, page, pd);
60ac: e1a00004 mov r0, r4
60b0: e1a01006 mov r1, r6
60b4: e1a02007 mov r2, r7
60b8: e1a03005 mov r3, r5
60bc: ebfff707 bl 3ce0 <rtems_fdisk_seg_write_page_desc>
if (ret)
60c0: e250a000 subs sl, r0, #0
60c4: 1a00002d bne 6180 <bsp_section_rodata_size+0x127c>
strerror (ret), ret);
#endif
}
else
{
sc->pages_active++;
60c8: e596301c ldr r3, [r6, #28]
60cc: e2833001 add r3, r3, #1
60d0: e586301c str r3, [r6, #28]
60d4: eaffffb0 b 5f9c <bsp_section_rodata_size+0x1098>
#if RTEMS_FDISK_TRACE
if (fd->info_level >= 3)
{
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
60d8: e28d5060 add r5, sp, #96 ; 0x60 <== NOT EXECUTED
60dc: e1a00004 mov r0, r4 <== NOT EXECUTED
60e0: e1a01006 mov r1, r6 <== NOT EXECUTED
60e4: e1a02005 mov r2, r5 <== NOT EXECUTED
60e8: ebfff5fc bl 38e0 <rtems_fdisk_queue_status> <== NOT EXECUTED
rtems_fdisk_info (fd, " write:%d=>%02d-%03d: queue check: %s",
60ec: e2863008 add r3, r6, #8 <== NOT EXECUTED
60f0: e8931008 ldm r3, {r3, ip} <== NOT EXECUTED
60f4: e1a00004 mov r0, r4 <== NOT EXECUTED
60f8: e51f12e0 ldr r1, [pc, #-736] ; 5e20 <bsp_section_rodata_size+0xf1c><== NOT EXECUTED
60fc: e1a0200a mov r2, sl <== NOT EXECUTED
6100: e58dc000 str ip, [sp] <== NOT EXECUTED
6104: e58d5004 str r5, [sp, #4] <== NOT EXECUTED
6108: ebfff647 bl 3a2c <rtems_fdisk_info> <== NOT EXECUTED
610c: eaffff0f b 5d50 <bsp_section_rodata_size+0xe4c> <== NOT EXECUTED
*
* We override the background compaction configruation.
*/
if (rtems_fdisk_segment_count_queue (&fd->available) <=
fd->avail_compact_segs)
rtems_fdisk_compact (fd);
6110: e1a00004 mov r0, r4
6114: ebfff98c bl 474c <rtems_fdisk_compact>
6118: e5946034 ldr r6, [r4, #52] ; 0x34
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
611c: e3560000 cmp r6, #0
6120: 1afffefe bne 5d20 <bsp_section_rodata_size+0xe1c>
{
/*
* 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))
6124: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
6128: e3130002 tst r3, #2 <== NOT EXECUTED
612c: 1a00002a bne 61dc <bsp_section_rodata_size+0x12d8> <== NOT EXECUTED
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
if (!sc)
{
rtems_fdisk_error ("write-block: no available pages");
6130: e51f0314 ldr r0, [pc, #-788] ; 5e24 <bsp_section_rodata_size+0xf20><== NOT EXECUTED
6134: e59d502c ldr r5, [sp, #44] ; 0x2c <== NOT EXECUTED
6138: ebfff73c bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
613c: eaffffb9 b 6028 <bsp_section_rodata_size+0x1124> <== NOT EXECUTED
ret = rtems_fdisk_seg_write_page_desc_flags (fd, sc, bc->page, pd);
if (ret)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: " \
6140: e598c004 ldr ip, [r8, #4] <== NOT EXECUTED
6144: e1a00006 mov r0, r6 <== NOT EXECUTED
6148: e5959008 ldr r9, [r5, #8] <== NOT EXECUTED
614c: e595700c ldr r7, [r5, #12] <== NOT EXECUTED
6150: e58dc028 str ip, [sp, #40] ; 0x28 <== NOT EXECUTED
6154: eb006d80 bl 2175c <strerror> <== NOT EXECUTED
6158: e59dc028 ldr ip, [sp, #40] ; 0x28 <== NOT EXECUTED
615c: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
6160: e51f1340 ldr r1, [pc, #-832] ; 5e28 <bsp_section_rodata_size+0xf24><== NOT EXECUTED
6164: e1a02009 mov r2, r9 <== NOT EXECUTED
6168: e1a00004 mov r0, r4 <== NOT EXECUTED
616c: e1a03007 mov r3, r7 <== NOT EXECUTED
6170: e58dc000 str ip, [sp] <== NOT EXECUTED
6174: e58d6008 str r6, [sp, #8] <== NOT EXECUTED
6178: ebfff62b bl 3a2c <rtems_fdisk_info> <== NOT EXECUTED
617c: eafffed4 b 5cd4 <bsp_section_rodata_size+0xdd0> <== NOT EXECUTED
{
ret = rtems_fdisk_seg_write_page_desc (fd, sc, page, pd);
if (ret)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: " \
6180: e5969008 ldr r9, [r6, #8] <== NOT EXECUTED
6184: e596500c ldr r5, [r6, #12] <== NOT EXECUTED
6188: e5987004 ldr r7, [r8, #4] <== NOT EXECUTED
618c: eb006d72 bl 2175c <strerror> <== NOT EXECUTED
6190: e51f136c ldr r1, [pc, #-876] ; 5e2c <bsp_section_rodata_size+0xf28><== NOT EXECUTED
6194: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
6198: e1a02009 mov r2, r9 <== NOT EXECUTED
619c: eaffff79 b 5f88 <bsp_section_rodata_size+0x1084> <== NOT EXECUTED
61a0: e59d502c ldr r5, [sp, #44] ; 0x2c <== NOT EXECUTED
61a4: eaffff9f b 6028 <bsp_section_rodata_size+0x1124> <== NOT EXECUTED
61a8: e59d502c ldr r5, [sp, #44] ; 0x2c
if (ret)
break;
}
}
rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
61ac: e3a01000 mov r1, #0
61b0: eaffff9d b 602c <bsp_section_rodata_size+0x1128>
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
{
if (!fd->devices[device].segments)
return ENOMEM;
61b4: e3a0000c mov r0, #12 <== NOT EXECUTED
61b8: eafffc24 b 5250 <bsp_section_rodata_size+0x34c> <== NOT EXECUTED
&flash_flags, sizeof (flash_flags));
if (ret)
return ret;
if ((flash_flags & page_desc->flags) != page_desc->flags)
{
rtems_fdisk_error (" seg-write-page-flags: %02d-%03d-%03d: "
61bc: e2851008 add r1, r5, #8 <== NOT EXECUTED
61c0: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
61c4: e1a03009 mov r3, r9 <== NOT EXECUTED
61c8: e51f03a0 ldr r0, [pc, #-928] ; 5e30 <bsp_section_rodata_size+0xf2c><== NOT EXECUTED
61cc: e58de000 str lr, [sp] <== NOT EXECUTED
61d0: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
61d4: ebfff715 bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
61d8: eafffeb7 b 5cbc <bsp_section_rodata_size+0xdb8> <== NOT EXECUTED
/*
* 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))
rtems_fdisk_compact (fd);
61dc: e1a00004 mov r0, r4 <== NOT EXECUTED
61e0: ebfff959 bl 474c <rtems_fdisk_compact> <== NOT EXECUTED
61e4: e5946034 ldr r6, [r4, #52] ; 0x34 <== NOT EXECUTED
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
if (queue->head)
61e8: e3560000 cmp r6, #0 <== NOT EXECUTED
61ec: 1afffecb bne 5d20 <bsp_section_rodata_size+0xe1c> <== NOT EXECUTED
61f0: eaffffce b 6130 <bsp_section_rodata_size+0x122c> <== NOT EXECUTED
00004090 <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)
{
4090: e92d45f0 push {r4, r5, r6, r7, r8, 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",
4094: e5915028 ldr r5, [r1, #40] ; 0x28
4098: e5918000 ldr r8, [r1]
409c: e591a014 ldr sl, [r1, #20]
40a0: e591701c ldr r7, [r1, #28]
* @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)
{
40a4: 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",
40a8: e2812008 add r2, r1, #8
40ac: e2816020 add r6, r1, #32
40b0: e59f126c ldr r1, [pc, #620] ; 4324 <rtems_fdisk_queue_segment+0x294>
40b4: e3550000 cmp r5, #0
40b8: e59fc268 ldr ip, [pc, #616] ; 4328 <rtems_fdisk_queue_segment+0x298>
40bc: e59f5268 ldr r5, [pc, #616] ; 432c <rtems_fdisk_queue_segment+0x29c>
40c0: 11a0c001 movne ip, r1
40c4: e59f1264 ldr r1, [pc, #612] ; 4330 <rtems_fdisk_queue_segment+0x2a0>
40c8: e8964040 ldm r6, {r6, lr}
40cc: e3580000 cmp r8, #0
40d0: e892000c ldm r2, {r2, r3}
* @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)
{
40d4: 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",
40d8: 01a08005 moveq r8, r5
40dc: 11a08001 movne r8, r1
40e0: e59f124c ldr r1, [pc, #588] ; 4334 <rtems_fdisk_queue_segment+0x2a4>
* @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)
{
40e4: 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",
40e8: e58da000 str sl, [sp]
40ec: e58d7004 str r7, [sp, #4]
40f0: e58d6008 str r6, [sp, #8]
40f4: e58de00c str lr, [sp, #12]
40f8: e58dc010 str ip, [sp, #16]
40fc: e58d8014 str r8, [sp, #20]
4100: ebfffe49 bl 3a2c <rtems_fdisk_info>
/*
* If the segment has failed then check the failed queue and append
* if not failed.
*/
if (sc->failed)
4104: e5943028 ldr r3, [r4, #40] ; 0x28
4108: e3530000 cmp r3, #0
410c: 0a000012 beq 415c <rtems_fdisk_queue_segment+0xcc>
*/
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;
4110: e5953058 ldr r3, [r5, #88] ; 0x58 <== NOT EXECUTED
while (it)
4114: e3530000 cmp r3, #0 <== NOT EXECUTED
4118: 1a000003 bne 412c <rtems_fdisk_queue_segment+0x9c> <== NOT EXECUTED
411c: ea00006a b 42cc <rtems_fdisk_queue_segment+0x23c> <== NOT EXECUTED
{
if (it == sc)
return true;
it = it->next;
4120: 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)
4124: e3530000 cmp r3, #0 <== NOT EXECUTED
4128: 0a000003 beq 413c <rtems_fdisk_queue_segment+0xac> <== NOT EXECUTED
{
if (it == sc)
412c: e1540003 cmp r4, r3 <== NOT EXECUTED
4130: 1afffffa bne 4120 <rtems_fdisk_queue_segment+0x90> <== NOT EXECUTED
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
else
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
4134: e28dd018 add sp, sp, #24
4138: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
{
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
413c: e595205c ldr r2, [r5, #92] ; 0x5c <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
4140: e5843000 str r3, [r4] <== NOT EXECUTED
if (queue->head)
{
queue->tail->next = sc;
4144: e5824000 str r4, [r2] <== NOT EXECUTED
queue->tail = sc;
4148: e585405c str r4, [r5, #92] ; 0x5c <== NOT EXECUTED
else
{
queue->head = queue->tail = sc;
}
queue->count++;
414c: e5953060 ldr r3, [r5, #96] ; 0x60 <== NOT EXECUTED
4150: e2833001 add r3, r3, #1 <== NOT EXECUTED
4154: e5853060 str r3, [r5, #96] ; 0x60 <== NOT EXECUTED
4158: eafffff5 b 4134 <rtems_fdisk_queue_segment+0xa4> <== NOT EXECUTED
}
/*
* Remove the queue from the available or used queue.
*/
rtems_fdisk_segment_queue_remove (&fd->available, sc);
415c: e2856034 add r6, r5, #52 ; 0x34
4160: e1a00006 mov r0, r6
4164: e1a01004 mov r1, r4
rtems_fdisk_segment_queue_remove (&fd->used, sc);
4168: e2857040 add r7, r5, #64 ; 0x40
}
/*
* Remove the queue from the available or used queue.
*/
rtems_fdisk_segment_queue_remove (&fd->available, sc);
416c: ebfffdb8 bl 3854 <rtems_fdisk_segment_queue_remove>
rtems_fdisk_segment_queue_remove (&fd->used, sc);
4170: e1a00007 mov r0, r7
4174: e1a01004 mov r1, r4
4178: ebfffdb5 bl 3854 <rtems_fdisk_segment_queue_remove>
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
417c: e284101c add r1, r4, #28
4180: e891000a ldm r1, {r1, r3}
4184: e5942024 ldr r2, [r4, #36] ; 0x24
4188: e594c014 ldr ip, [r4, #20]
418c: e0830001 add r0, r3, r1
4190: e0802002 add r2, r0, r2
* 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)
4194: e15c0002 cmp ip, r2
4198: 0a000025 beq 4234 <rtems_fdisk_queue_segment+0x1a4>
* 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;
419c: e5951034 ldr r1, [r5, #52] ; 0x34
while (seg)
41a0: e3510000 cmp r1, #0
41a4: 0a000051 beq 42f0 <rtems_fdisk_queue_segment+0x260>
*
* @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)
41a8: e591001c ldr r0, [r1, #28]
41ac: e5913024 ldr r3, [r1, #36] ; 0x24
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
41b0: e5917014 ldr r7, [r1, #20]
* * @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)
41b4: e0803003 add r3, r0, r3
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
41b8: e5910020 ldr r0, [r1, #32]
41bc: e0633007 rsb r3, r3, r7
41c0: e062c00c rsb ip, r2, ip
41c4: e0603003 rsb r3, r0, r3
*/
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
{
if (rtems_fdisk_seg_pages_available (sc) <
41c8: e15c0003 cmp ip, r3
41cc: 2a00000d bcs 4208 <rtems_fdisk_queue_segment+0x178>
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
41d0: e1a00006 mov r0, r6
41d4: e1a02004 mov r2, r4
else
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
41d8: e28dd018 add sp, sp, #24
41dc: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr}
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
41e0: eaffff86 b 4000 <rtems_fdisk_segment_queue_insert_before>
* * @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)
41e4: e281201c add r2, r1, #28
41e8: e892000c ldm r2, {r2, r3}
41ec: e0823003 add r3, r2, r3
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
41f0: e5910014 ldr r0, [r1, #20]
41f4: e5912024 ldr r2, [r1, #36] ; 0x24
41f8: e0633000 rsb r3, r3, r0
41fc: e0623003 rsb r3, r2, r3
*/
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
{
if (rtems_fdisk_seg_pages_available (sc) <
4200: e15c0003 cmp ip, r3
4204: 3afffff1 bcc 41d0 <rtems_fdisk_queue_segment+0x140>
rtems_fdisk_seg_pages_available (seg))
break;
seg = seg->next;
4208: e5911000 ldr r1, [r1]
* 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)
420c: e3510000 cmp r1, #0
4210: 1afffff3 bne 41e4 <rtems_fdisk_queue_segment+0x154>
{
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
4214: e5953038 ldr r3, [r5, #56] ; 0x38
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
4218: e5841000 str r1, [r4]
if (queue->head)
{
queue->tail->next = sc;
421c: e5834000 str r4, [r3]
queue->tail = sc;
4220: e5854038 str r4, [r5, #56] ; 0x38
else
{
queue->head = queue->tail = sc;
}
queue->count++;
4224: e595303c ldr r3, [r5, #60] ; 0x3c
4228: e2833001 add r3, r3, #1
422c: e585303c str r3, [r5, #60] ; 0x3c
4230: eaffffbf b 4134 <rtems_fdisk_queue_segment+0xa4>
* to background erase perform the erase now.
*
*/
if (rtems_fdisk_seg_pages_available (sc) == 0)
{
if (sc->pages_active)
4234: e3510000 cmp r1, #0
4238: 0a000014 beq 4290 <rtems_fdisk_queue_segment+0x200>
/*
* 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;
423c: e5951040 ldr r1, [r5, #64] ; 0x40
while (seg)
4240: e3510000 cmp r1, #0
4244: 0a000032 beq 4314 <rtems_fdisk_queue_segment+0x284>
{
if (sc->pages_used > seg->pages_used)
4248: e5912020 ldr r2, [r1, #32]
424c: e1530002 cmp r3, r2
4250: 9a000003 bls 4264 <rtems_fdisk_queue_segment+0x1d4>
4254: ea000020 b 42dc <rtems_fdisk_queue_segment+0x24c>
4258: e5912020 ldr r2, [r1, #32]
425c: e1520003 cmp r2, r3
4260: 3a00001d bcc 42dc <rtems_fdisk_queue_segment+0x24c>
break;
seg = seg->next;
4264: 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)
4268: e3510000 cmp r1, #0
426c: 1afffff9 bne 4258 <rtems_fdisk_queue_segment+0x1c8>
{
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
4270: e5953044 ldr r3, [r5, #68] ; 0x44
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
4274: e5841000 str r1, [r4]
if (queue->head)
{
queue->tail->next = sc;
4278: e5834000 str r4, [r3]
queue->tail = sc;
427c: e5854044 str r4, [r5, #68] ; 0x44
else
{
queue->head = queue->tail = sc;
}
queue->count++;
4280: e5953048 ldr r3, [r5, #72] ; 0x48
4284: e2833001 add r3, r3, #1
4288: e5853048 str r3, [r5, #72] ; 0x48
428c: eaffffa8 b 4134 <rtems_fdisk_queue_segment+0xa4>
else
rtems_fdisk_segment_queue_push_tail (&fd->used, sc);
}
else
{
if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))
4290: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
4294: e3130001 tst r3, #1 <== NOT EXECUTED
4298: 0a000018 beq 4300 <rtems_fdisk_queue_segment+0x270> <== NOT EXECUTED
{
if (sc)
{
sc->next = 0;
if (queue->head)
429c: e595304c ldr r3, [r5, #76] ; 0x4c <== NOT EXECUTED
42a0: e3530000 cmp r3, #0 <== NOT EXECUTED
{
queue->tail->next = sc;
42a4: 15953050 ldrne r3, [r5, #80] ; 0x50 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
42a8: e5841000 str r1, [r4] <== NOT EXECUTED
if (queue->head)
{
queue->tail->next = sc;
42ac: 15834000 strne r4, [r3] <== NOT EXECUTED
else
{
queue->head = queue->tail = sc;
}
queue->count++;
42b0: e5953054 ldr r3, [r5, #84] ; 0x54 <== NOT EXECUTED
42b4: e2833001 add r3, r3, #1 <== NOT EXECUTED
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
queue->tail = sc;
42b8: 15854050 strne r4, [r5, #80] ; 0x50 <== NOT EXECUTED
}
else
{
queue->head = queue->tail = sc;
42bc: 05854050 streq r4, [r5, #80] ; 0x50 <== NOT EXECUTED
42c0: 0585404c streq r4, [r5, #76] ; 0x4c <== NOT EXECUTED
}
queue->count++;
42c4: e5853054 str r3, [r5, #84] ; 0x54 <== NOT EXECUTED
42c8: eaffff99 b 4134 <rtems_fdisk_queue_segment+0xa4> <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
42cc: e5843000 str r3, [r4] <== NOT EXECUTED
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
42d0: e585405c str r4, [r5, #92] ; 0x5c <== NOT EXECUTED
42d4: e5854058 str r4, [r5, #88] ; 0x58 <== NOT EXECUTED
42d8: eaffff9b b 414c <rtems_fdisk_queue_segment+0xbc> <== NOT EXECUTED
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->used, seg, sc);
42dc: e1a00007 mov r0, r7
42e0: e1a02004 mov r2, r4
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
else
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
42e4: e28dd018 add sp, sp, #24
42e8: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr}
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->used, seg, sc);
42ec: eaffff43 b 4000 <rtems_fdisk_segment_queue_insert_before>
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
42f0: e5841000 str r1, [r4]
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
42f4: e5854038 str r4, [r5, #56] ; 0x38
42f8: e5854034 str r4, [r5, #52] ; 0x34
42fc: eaffffc8 b 4224 <rtems_fdisk_queue_segment+0x194>
else
{
if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))
rtems_fdisk_segment_queue_push_tail (&fd->erase, sc);
else
rtems_fdisk_erase_segment (fd, sc);
4300: e1a00005 mov r0, r5 <== NOT EXECUTED
4304: 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);
}
}
4308: e28dd018 add sp, sp, #24 <== NOT EXECUTED
430c: e8bd45f0 pop {r4, r5, r6, r7, r8, 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);
4310: eafffee6 b 3eb0 <rtems_fdisk_erase_segment> <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
4314: e5841000 str r1, [r4]
queue->tail->next = sc;
queue->tail = sc;
}
else
{
queue->head = queue->tail = sc;
4318: e5854044 str r4, [r5, #68] ; 0x44
431c: e5854040 str r4, [r5, #64] ; 0x40
4320: eaffffd6 b 4280 <rtems_fdisk_queue_segment+0x1f0>
000038e0 <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;
38e0: e5903034 ldr r3, [r0, #52] ; 0x34
while (it)
38e4: e3530000 cmp r3, #0
38e8: 1a000003 bne 38fc <rtems_fdisk_queue_status+0x1c>
38ec: ea000006 b 390c <rtems_fdisk_queue_status+0x2c> <== NOT EXECUTED
{
if (it == sc)
return true;
it = it->next;
38f0: 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)
38f4: e3530000 cmp r3, #0
38f8: 0a000003 beq 390c <rtems_fdisk_queue_status+0x2c>
{
if (it == sc)
38fc: e1510003 cmp r1, r3
3900: 1afffffa bne 38f0 <rtems_fdisk_queue_status+0x10>
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' : '-';
3904: e3a03041 mov r3, #65 ; 0x41
3908: ea000000 b 3910 <rtems_fdisk_queue_status+0x30>
390c: e3a0302d mov r3, #45 ; 0x2d
3910: 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;
3914: e5903040 ldr r3, [r0, #64] ; 0x40
while (it)
3918: e3530000 cmp r3, #0
391c: 1a000003 bne 3930 <rtems_fdisk_queue_status+0x50>
3920: ea000006 b 3940 <rtems_fdisk_queue_status+0x60> <== NOT EXECUTED
{
if (it == sc)
return true;
it = it->next;
3924: 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)
3928: e3530000 cmp r3, #0
392c: 0a000003 beq 3940 <rtems_fdisk_queue_status+0x60>
{
if (it == sc)
3930: e1510003 cmp r1, r3
3934: 1afffffa bne 3924 <rtems_fdisk_queue_status+0x44>
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' : '-';
3938: e3a03055 mov r3, #85 ; 0x55
393c: ea000000 b 3944 <rtems_fdisk_queue_status+0x64>
3940: e3a0302d mov r3, #45 ; 0x2d
3944: 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;
3948: e590304c ldr r3, [r0, #76] ; 0x4c
while (it)
394c: e3530000 cmp r3, #0
3950: 1a000003 bne 3964 <rtems_fdisk_queue_status+0x84>
3954: ea000006 b 3974 <rtems_fdisk_queue_status+0x94>
{
if (it == sc)
return true;
it = it->next;
3958: 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)
395c: e3530000 cmp r3, #0 <== NOT EXECUTED
3960: 0a000003 beq 3974 <rtems_fdisk_queue_status+0x94> <== NOT EXECUTED
{
if (it == sc)
3964: e1510003 cmp r1, r3 <== NOT EXECUTED
3968: 1afffffa bne 3958 <rtems_fdisk_queue_status+0x78> <== NOT EXECUTED
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' : '-';
396c: e3a03045 mov r3, #69 ; 0x45 <== NOT EXECUTED
3970: ea000000 b 3978 <rtems_fdisk_queue_status+0x98> <== NOT EXECUTED
3974: e3a0302d mov r3, #45 ; 0x2d
3978: 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;
397c: e5903058 ldr r3, [r0, #88] ; 0x58
while (it)
3980: e3530000 cmp r3, #0
3984: 1a000003 bne 3998 <rtems_fdisk_queue_status+0xb8>
3988: ea000009 b 39b4 <rtems_fdisk_queue_status+0xd4>
{
if (it == sc)
return true;
it = it->next;
398c: 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)
3990: e3530000 cmp r3, #0 <== NOT EXECUTED
3994: 0a000006 beq 39b4 <rtems_fdisk_queue_status+0xd4> <== NOT EXECUTED
{
if (it == sc)
3998: e1510003 cmp r1, r3 <== NOT EXECUTED
399c: 1afffffa bne 398c <rtems_fdisk_queue_status+0xac> <== NOT EXECUTED
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' : '-';
39a0: e3a03046 mov r3, #70 ; 0x46 <== NOT EXECUTED
39a4: e5c23003 strb r3, [r2, #3] <== NOT EXECUTED
queues[4] = '\0';
39a8: e3a03000 mov r3, #0 <== NOT EXECUTED
39ac: e5c23004 strb r3, [r2, #4] <== NOT EXECUTED
}
39b0: e12fff1e bx lr <== NOT EXECUTED
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' : '-';
39b4: e3a0302d mov r3, #45 ; 0x2d
39b8: e5c23003 strb r3, [r2, #3]
queues[4] = '\0';
39bc: e3a03000 mov r3, #0
39c0: e5c23004 strb r3, [r2, #4]
}
39c4: e12fff1e bx lr
000049ec <rtems_fdisk_recover_block_mappings>:
/**
* Recover the block mappings from the devices.
*/
static int
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)
{
49ec: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_fdisk_segment_queue_init (&fd->failed);
/*
* Clear the lock mappings.
*/
memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
49f0: e590201c ldr r2, [r0, #28]
* Initialise the segment control queue.
*/
static void
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue)
{
queue->head = queue->tail = 0;
49f4: e3a04000 mov r4, #0
/**
* Recover the block mappings from the devices.
*/
static int
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)
{
49f8: e1a07000 mov r7, r0
* Initialise the segment control queue.
*/
static void
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue)
{
queue->head = queue->tail = 0;
49fc: e5804038 str r4, [r0, #56] ; 0x38
4a00: e5804034 str r4, [r0, #52] ; 0x34
queue->count = 0;
4a04: e580403c str r4, [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;
4a08: e5804044 str r4, [r0, #68] ; 0x44
4a0c: e5804040 str r4, [r0, #64] ; 0x40
queue->count = 0;
4a10: e5804048 str r4, [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;
4a14: e5804050 str r4, [r0, #80] ; 0x50
4a18: e580404c str r4, [r0, #76] ; 0x4c
queue->count = 0;
4a1c: e5804054 str r4, [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;
4a20: e580405c str r4, [r0, #92] ; 0x5c
4a24: e5804058 str r4, [r0, #88] ; 0x58
queue->count = 0;
4a28: e5804060 str r4, [r0, #96] ; 0x60
/**
* Recover the block mappings from the devices.
*/
static int
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)
{
4a2c: e24dd010 sub sp, sp, #16
rtems_fdisk_segment_queue_init (&fd->failed);
/*
* Clear the lock mappings.
*/
memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
4a30: e5900018 ldr r0, [r0, #24]
4a34: e1a01004 mov r1, r4
4a38: e1a02182 lsl r2, r2, #3
4a3c: eb006e27 bl 202e0 <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++)
4a40: e5975030 ldr r5, [r7, #48] ; 0x30
4a44: e1550004 cmp r5, r4
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;
4a48: e5874028 str r4, [r7, #40] ; 0x28
fd->starvation_threshold = 0;
4a4c: e5874024 str r4, [r7, #36] ; 0x24
for (device = 0; device < fd->device_count; device++)
4a50: 0a000071 beq 4c1c <rtems_fdisk_recover_block_mappings+0x230>
4a54: e58d400c str r4, [sp, #12]
4a58: e597202c ldr r2, [r7, #44] ; 0x2c
4a5c: e1a09004 mov r9, r4
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
4a60: e1a0a004 mov sl, r4
4a64: e59d100c ldr r1, [sp, #12]
4a68: e0823001 add r3, r2, r1
4a6c: e5931004 ldr r1, [r3, #4]
4a70: e3510000 cmp r1, #0
4a74: 13a0b000 movne fp, #0
4a78: 11a0800b movne r8, fp
4a7c: 0a00005f beq 4c00 <rtems_fdisk_recover_block_mappings+0x214>
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[segment];
4a80: e5936000 ldr r6, [r3]
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);
4a84: e1a02009 mov r2, r9
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];
4a88: e086600b add r6, r6, 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);
4a8c: e1a03008 mov r3, r8
4a90: e59f12dc ldr r1, [pc, #732] ; 4d74 <rtems_fdisk_recover_block_mappings+0x388>
4a94: e1a00007 mov r0, r7
{
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;
4a98: e5964004 ldr r4, [r6, #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);
4a9c: ebfffbe2 bl 3a2c <rtems_fdisk_info>
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
4aa0: e5975014 ldr r5, [r7, #20]
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
4aa4: e5940008 ldr r0, [r4, #8]
4aa8: e1a01005 mov r1, r5
4aac: ebfff3fd bl 1aa8 <__aeabi_uidiv>
4ab0: e1a04000 mov r4, 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);
4ab4: e1a00180 lsl r0, r0, #3
return ((bytes - 1) / page_size) + 1;
4ab8: e1a01005 mov r1, r5
4abc: e2400001 sub r0, r0, #1
4ac0: ebfff3f8 bl 1aa8 <__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)
4ac4: e5973024 ldr r3, [r7, #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;
4ac8: e2800001 add r0, 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;
4acc: e0604004 rsb r4, r0, r4
if (sc->pages > fd->starvation_threshold)
4ad0: e1540003 cmp r4, r3
#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);
sc->pages =
4ad4: e5864014 str r4, [r6, #20]
#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);
4ad8: e5860018 str r0, [r6, #24]
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
if (sc->pages > fd->starvation_threshold)
fd->starvation_threshold = sc->pages;
4adc: 85874024 strhi r4, [r7, #36] ; 0x24
sc->pages_used = 0;
sc->pages_bad = 0;
sc->failed = false;
if (!sc->page_descriptors)
4ae0: e5964010 ldr r4, [r6, #16]
4ae4: e3540000 cmp r4, #0
sc->page_descriptors = malloc (sc->pages_desc * fd->block_size);
4ae8: e0050590 mul r5, r0, r5
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
if (sc->pages > fd->starvation_threshold)
fd->starvation_threshold = sc->pages;
sc->pages_active = 0;
4aec: e586a01c str sl, [r6, #28]
sc->pages_used = 0;
4af0: e586a020 str sl, [r6, #32]
sc->pages_bad = 0;
4af4: e586a024 str sl, [r6, #36] ; 0x24
sc->failed = false;
4af8: e586a028 str sl, [r6, #40] ; 0x28
if (!sc->page_descriptors)
4afc: 0a00008c beq 4d34 <rtems_fdisk_recover_block_mappings+0x348>
* 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,
4b00: e1a00007 mov r0, r7
4b04: e1a01006 mov r1, r6
4b08: e3a02000 mov r2, #0
4b0c: e1a03004 mov r3, r4
4b10: e58d5000 str r5, [sp]
4b14: ebfffc0c bl 3b4c <rtems_fdisk_seg_read>
sc->pages_desc * fd->block_size);
if (ret)
4b18: e2505000 subs r5, r0, #0
4b1c: 1a00008c bne 4d54 <rtems_fdisk_recover_block_mappings+0x368>
* 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++)
4b20: e5962014 ldr r2, [r6, #20]
4b24: e3520000 cmp r2, #0
4b28: 1a000007 bne 4b4c <rtems_fdisk_recover_block_mappings+0x160>
4b2c: ea000027 b 4bd0 <rtems_fdisk_recover_block_mappings+0x1e4> <== NOT EXECUTED
}
else
{
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_USED))
{
sc->pages_used++;
4b30: e5963020 ldr r3, [r6, #32] <== NOT EXECUTED
4b34: e2833001 add r3, r3, #1 <== NOT EXECUTED
4b38: e5863020 str r3, [r6, #32] <== 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++)
4b3c: e2855001 add r5, r5, #1
4b40: e1520005 cmp r2, r5
4b44: e2844008 add r4, r4, #8
4b48: 9a000020 bls 4bd0 <rtems_fdisk_recover_block_mappings+0x1e4>
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
4b4c: e5943000 ldr r3, [r4]
4b50: e3730001 cmn r3, #1
4b54: 0a000033 beq 4c28 <rtems_fdisk_recover_block_mappings+0x23c>
* 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;
4b58: e1d430b2 ldrh r3, [r4, #2] <== NOT EXECUTED
sc->pages_used++;
}
}
else
{
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_USED))
4b5c: e3130002 tst r3, #2 <== NOT EXECUTED
4b60: 0afffff2 beq 4b30 <rtems_fdisk_recover_block_mappings+0x144><== NOT EXECUTED
{
sc->pages_used++;
}
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
4b64: e3130001 tst r3, #1 <== NOT EXECUTED
4b68: 1a00003f bne 4c6c <rtems_fdisk_recover_block_mappings+0x280><== NOT EXECUTED
{
if (pd->block >= fd->block_count)
4b6c: e594c004 ldr ip, [r4, #4] <== NOT EXECUTED
4b70: e597301c ldr r3, [r7, #28] <== NOT EXECUTED
4b74: e15c0003 cmp ip, r3 <== NOT EXECUTED
4b78: 2a000056 bcs 4cd8 <rtems_fdisk_recover_block_mappings+0x2ec><== 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)
4b7c: e5971018 ldr r1, [r7, #24] <== NOT EXECUTED
4b80: e791018c ldr r0, [r1, ip, lsl #3] <== NOT EXECUTED
4b84: e3500000 cmp r0, #0 <== NOT EXECUTED
4b88: e081318c add r3, r1, ip, lsl #3 <== NOT EXECUTED
4b8c: 0a00005c beq 4d04 <rtems_fdisk_recover_block_mappings+0x318><== 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: " \
4b90: e2801008 add r1, r0, #8 <== NOT EXECUTED
4b94: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
4b98: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
4b9c: e59f01d4 ldr r0, [pc, #468] ; 4d78 <rtems_fdisk_recover_block_mappings+0x38c><== NOT EXECUTED
4ba0: e58d5008 str r5, [sp, #8] <== NOT EXECUTED
4ba4: e58d9000 str r9, [sp] <== NOT EXECUTED
4ba8: e58d8004 str r8, [sp, #4] <== NOT EXECUTED
4bac: ebfffc9f bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
"duplicate: %d-%d-%d",
bsc->device, bsc->segment,
fd->blocks[pd->block].page,
device, segment, page);
sc->pages_bad++;
4bb0: e5963024 ldr r3, [r6, #36] ; 0x24 <== NOT EXECUTED
4bb4: e5962014 ldr r2, [r6, #20] <== 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++)
4bb8: e2855001 add r5, r5, #1 <== NOT EXECUTED
rtems_fdisk_error ("duplicate block: %d-%d-%d: " \
"duplicate: %d-%d-%d",
bsc->device, bsc->segment,
fd->blocks[pd->block].page,
device, segment, page);
sc->pages_bad++;
4bbc: e2833001 add r3, r3, #1 <== 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++)
4bc0: e1520005 cmp r2, r5 <== NOT EXECUTED
rtems_fdisk_error ("duplicate block: %d-%d-%d: " \
"duplicate: %d-%d-%d",
bsc->device, bsc->segment,
fd->blocks[pd->block].page,
device, segment, page);
sc->pages_bad++;
4bc4: e5863024 str r3, [r6, #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++)
4bc8: e2844008 add r4, r4, #8 <== NOT EXECUTED
4bcc: 8affffde bhi 4b4c <rtems_fdisk_recover_block_mappings+0x160><== NOT EXECUTED
}
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, sc);
4bd0: e1a01006 mov r1, r6
4bd4: e1a00007 mov r0, r7
4bd8: ebfffd2c bl 4090 <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++)
4bdc: e59d100c ldr r1, [sp, #12]
4be0: e597202c ldr r2, [r7, #44] ; 0x2c
4be4: e0823001 add r3, r2, r1
4be8: e5931004 ldr r1, [r3, #4]
4bec: e2888001 add r8, r8, #1
4bf0: e1510008 cmp r1, r8
4bf4: e28bb030 add fp, fp, #48 ; 0x30
4bf8: 8affffa0 bhi 4a80 <rtems_fdisk_recover_block_mappings+0x94>
4bfc: e5975030 ldr r5, [r7, #48] ; 0x30
/* * 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++)
4c00: e59d300c ldr r3, [sp, #12]
4c04: e2899001 add r9, r9, #1
4c08: e283300c add r3, r3, #12
4c0c: e1550009 cmp r5, r9
4c10: e58d300c str r3, [sp, #12]
4c14: 8affff92 bhi 4a64 <rtems_fdisk_recover_block_mappings+0x78>
*/
rtems_fdisk_queue_segment (fd, sc);
}
}
return 0;
4c18: e3a05000 mov r5, #0
}
4c1c: e1a00005 mov r0, r5
4c20: e28dd010 add sp, sp, #16
4c24: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
4c28: e5943004 ldr r3, [r4, #4]
4c2c: e3730001 cmn r3, #1
4c30: 1affffc8 bne 4b58 <rtems_fdisk_recover_block_mappings+0x16c>
if (rtems_fdisk_page_desc_erased (pd))
{
/*
* Is the page erased ?
*/
ret = rtems_fdisk_seg_blank_check_page (fd, sc,
4c34: e5962018 ldr r2, [r6, #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);
4c38: e5973014 ldr r3, [r7, #20]
if (rtems_fdisk_page_desc_erased (pd))
{
/*
* Is the page erased ?
*/
ret = rtems_fdisk_seg_blank_check_page (fd, sc,
4c3c: e0852002 add r2, r5, 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,
4c40: e1a00007 mov r0, r7
4c44: e1a01006 mov r1, r6
4c48: e0020293 mul r2, r3, r2
4c4c: ebfffbde bl 3bcc <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)
4c50: e3500000 cmp r0, #0
4c54: 1a000008 bne 4c7c <rtems_fdisk_recover_block_mappings+0x290>
{
++fd->erased_blocks;
4c58: e5973028 ldr r3, [r7, #40] ; 0x28
4c5c: e2833001 add r3, r3, #1
4c60: e5873028 str r3, [r7, #40] ; 0x28
4c64: e5962014 ldr r2, [r6, #20]
4c68: eaffffb3 b 4b3c <rtems_fdisk_recover_block_mappings+0x150>
*/
sc->pages_active++;
}
}
else
sc->pages_bad++;
4c6c: e5963024 ldr r3, [r6, #36] ; 0x24 <== NOT EXECUTED
4c70: e2833001 add r3, r3, #1 <== NOT EXECUTED
4c74: e5863024 str r3, [r6, #36] ; 0x24 <== NOT EXECUTED
4c78: eaffffaf b 4b3c <rtems_fdisk_recover_block_mappings+0x150> <== NOT EXECUTED
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
4c7c: e58d5000 str r5, [sp] <== NOT EXECUTED
4c80: e594c004 ldr ip, [r4, #4] <== NOT EXECUTED
4c84: e59f10f0 ldr r1, [pc, #240] ; 4d7c <rtems_fdisk_recover_block_mappings+0x390><== NOT EXECUTED
4c88: e1a02009 mov r2, r9 <== NOT EXECUTED
4c8c: e1a03008 mov r3, r8 <== NOT EXECUTED
4c90: e1a00007 mov r0, r7 <== NOT EXECUTED
4c94: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
4c98: ebfffc41 bl 3da4 <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;
4c9c: e1d430b2 ldrh r3, [r4, #2] <== NOT EXECUTED
4ca0: e3c33002 bic r3, r3, #2 <== NOT EXECUTED
4ca4: e1c430b2 strh r3, [r4, #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,
4ca8: e1a00007 mov r0, r7 <== NOT EXECUTED
4cac: e1a01006 mov r1, r6 <== NOT EXECUTED
4cb0: e1a02005 mov r2, r5 <== NOT EXECUTED
4cb4: e1a03004 mov r3, r4 <== NOT EXECUTED
4cb8: ebfffc08 bl 3ce0 <rtems_fdisk_seg_write_page_desc> <== NOT EXECUTED
page, pd);
if (ret)
4cbc: e3500000 cmp r0, #0 <== NOT EXECUTED
4cc0: 1a000015 bne 4d1c <rtems_fdisk_recover_block_mappings+0x330><== NOT EXECUTED
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
device, segment, page);
}
sc->pages_used++;
4cc4: e5963020 ldr r3, [r6, #32] <== NOT EXECUTED
4cc8: e2833001 add r3, r3, #1 <== NOT EXECUTED
4ccc: e5863020 str r3, [r6, #32] <== NOT EXECUTED
4cd0: e5962014 ldr r2, [r6, #20] <== NOT EXECUTED
4cd4: eaffff98 b 4b3c <rtems_fdisk_recover_block_mappings+0x150> <== NOT EXECUTED
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
{
if (pd->block >= fd->block_count)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd,
4cd8: e1a02009 mov r2, r9 <== NOT EXECUTED
4cdc: e1a03008 mov r3, r8 <== NOT EXECUTED
4ce0: e1a00007 mov r0, r7 <== NOT EXECUTED
4ce4: e59f1094 ldr r1, [pc, #148] ; 4d80 <rtems_fdisk_recover_block_mappings+0x394><== NOT EXECUTED
4ce8: e88d1020 stm sp, {r5, ip} <== NOT EXECUTED
4cec: ebfffc2c bl 3da4 <rtems_fdisk_warning> <== NOT EXECUTED
"invalid block number: %d-%d-%d: block: %d",
device, segment, page, pd->block);
#endif
sc->pages_bad++;
4cf0: e5963024 ldr r3, [r6, #36] ; 0x24 <== NOT EXECUTED
4cf4: e2833001 add r3, r3, #1 <== NOT EXECUTED
4cf8: e5863024 str r3, [r6, #36] ; 0x24 <== NOT EXECUTED
4cfc: e5962014 ldr r2, [r6, #20] <== NOT EXECUTED
4d00: eaffff8d b 4b3c <rtems_fdisk_recover_block_mappings+0x150> <== NOT EXECUTED
fd->blocks[pd->block].page = page;
/*
* The page is active.
*/
sc->pages_active++;
4d04: e596001c ldr r0, [r6, #28] <== NOT EXECUTED
4d08: e2800001 add r0, r0, #1 <== NOT EXECUTED
{
/**
* @todo
* Add start up crc checks here.
*/
fd->blocks[pd->block].segment = sc;
4d0c: e781618c str r6, [r1, ip, lsl #3] <== NOT EXECUTED
fd->blocks[pd->block].page = page;
4d10: e5835004 str r5, [r3, #4] <== NOT EXECUTED
/*
* The page is active.
*/
sc->pages_active++;
4d14: e586001c str r0, [r6, #28] <== NOT EXECUTED
4d18: eaffff87 b 4b3c <rtems_fdisk_recover_block_mappings+0x150> <== NOT EXECUTED
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
page, pd);
if (ret)
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
4d1c: e1a01009 mov r1, r9 <== NOT EXECUTED
4d20: e1a02008 mov r2, r8 <== NOT EXECUTED
4d24: e1a03005 mov r3, r5 <== NOT EXECUTED
4d28: e59f0054 ldr r0, [pc, #84] ; 4d84 <rtems_fdisk_recover_block_mappings+0x398><== NOT EXECUTED
4d2c: ebfffc3f bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
4d30: eaffffe3 b 4cc4 <rtems_fdisk_recover_block_mappings+0x2d8> <== NOT EXECUTED
sc->pages_bad = 0;
sc->failed = false;
if (!sc->page_descriptors)
sc->page_descriptors = malloc (sc->pages_desc * fd->block_size);
4d34: e1a00005 mov r0, r5
4d38: eb000abd bl 7834 <malloc>
if (!sc->page_descriptors)
4d3c: e3500000 cmp r0, #0
sc->pages_bad = 0;
sc->failed = false;
if (!sc->page_descriptors)
sc->page_descriptors = malloc (sc->pages_desc * fd->block_size);
4d40: e1a04000 mov r4, r0
4d44: e5860010 str r0, [r6, #16]
if (!sc->page_descriptors)
4d48: 1affff6c bne 4b00 <rtems_fdisk_recover_block_mappings+0x114>
rtems_fdisk_abort ("no memory for page descriptors");
4d4c: e59f0034 ldr r0, [pc, #52] ; 4d88 <rtems_fdisk_recover_block_mappings+0x39c><== NOT EXECUTED
4d50: ebffee50 bl 698 <rtems_fdisk_abort> <== NOT EXECUTED
ret = rtems_fdisk_seg_read (fd, sc, 0, (void*) pd,
sc->pages_desc * fd->block_size);
if (ret)
{
rtems_fdisk_error ("recover-block-mappings:%02d-%03d: " \
4d54: eb007280 bl 2175c <strerror> <== NOT EXECUTED
4d58: e1a01009 mov r1, r9 <== NOT EXECUTED
4d5c: e1a03000 mov r3, r0 <== NOT EXECUTED
4d60: e1a02008 mov r2, r8 <== NOT EXECUTED
4d64: e59f0020 ldr r0, [pc, #32] ; 4d8c <rtems_fdisk_recover_block_mappings+0x3a0><== NOT EXECUTED
4d68: e58d5000 str r5, [sp] <== NOT EXECUTED
4d6c: ebfffc2f bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
"read page desc failed: %s (%d)",
device, segment, strerror (ret), ret);
return ret;
4d70: eaffffa9 b 4c1c <rtems_fdisk_recover_block_mappings+0x230> <== NOT EXECUTED
00004338 <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)
{
4338: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
433c: e1a06001 mov r6, r1
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
4340: e5911014 ldr r1, [r1, #20]
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* ssc,
rtems_fdisk_segment_ctl* dsc,
uint32_t *pages)
{
4344: e24dd030 sub sp, sp, #48 ; 0x30
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
4348: e3510000 cmp r1, #0
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* ssc,
rtems_fdisk_segment_ctl* dsc,
uint32_t *pages)
{
434c: e1a08000 mov r8, r0
4350: e1a05002 mov r5, r2
4354: e58d3028 str r3, [sp, #40] ; 0x28
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
4358: 0a0000f0 beq 4720 <rtems_fdisk_recycle_segment+0x3e8>
435c: e3a0c000 mov ip, #0
4360: e58dc020 str ip, [sp, #32]
4364: e1a0900c mov r9, ip
4368: e1a0700c mov r7, ip
/*
* 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);
436c: e280c034 add ip, r0, #52 ; 0x34
4370: e58dc02c str ip, [sp, #44] ; 0x2c
for (spage = 0; spage < ssc->pages; spage++)
{
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
if (!dsc && ssc->pages_active > 0)
4374: e3550000 cmp r5, #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];
4378: e5962010 ldr r2, [r6, #16]
if (!dsc && ssc->pages_active > 0)
437c: 0a000080 beq 4584 <rtems_fdisk_recycle_segment+0x24c>
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
{
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
4380: e1a00187 lsl r0, r7, #3
4384: e082a000 add sl, r2, r0
* 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;
4388: e1da30b2 ldrh r3, [sl, #2]
{
rtems_fdisk_error ("recycle: no available dst segment");
return EIO;
}
if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
438c: e2134001 ands r4, r3, #1
4390: 1a00005b bne 4504 <rtems_fdisk_recycle_segment+0x1cc>
4394: e3130002 tst r3, #2
4398: 0a000059 beq 4504 <rtems_fdisk_recycle_segment+0x1cc>
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++)
439c: e5953014 ldr r3, [r5, #20]
* 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];
43a0: e595c010 ldr ip, [r5, #16]
uint32_t page;
for (page = 0; page < sc->pages; page++, pd++)
43a4: e3530000 cmp r3, #0
* 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];
43a8: e58dc01c str ip, [sp, #28]
uint32_t page;
for (page = 0; page < sc->pages; page++, pd++)
43ac: 0a0000b5 beq 4688 <rtems_fdisk_recycle_segment+0x350>
43b0: e1a0200c mov r2, ip
43b4: ea000003 b 43c8 <rtems_fdisk_recycle_segment+0x90>
43b8: e2844001 add r4, r4, #1
43bc: e1540003 cmp r4, r3
43c0: e2822008 add r2, r2, #8
43c4: 0a0000af beq 4688 <rtems_fdisk_recycle_segment+0x350>
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
43c8: e5921000 ldr r1, [r2]
43cc: e3710001 cmn r1, #1
43d0: 1afffff8 bne 43b8 <rtems_fdisk_recycle_segment+0x80>
43d4: e5921004 ldr r1, [r2, #4]
43d8: e3710001 cmn r1, #1
43dc: 1afffff5 bne 43b8 <rtems_fdisk_recycle_segment+0x80>
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
active++;
if (dpage >= dsc->pages)
43e0: e1530004 cmp r3, r4
43e4: 9a0000a7 bls 4688 <rtems_fdisk_recycle_segment+0x350>
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",
43e8: e58d7000 str r7, [sp]
43ec: e5953008 ldr r3, [r5, #8]
43f0: e58d3004 str r3, [sp, #4]
43f4: e2862008 add r2, r6, #8
43f8: e595c00c ldr ip, [r5, #12]
43fc: e892000c ldm r2, {r2, r3}
4400: e59f1324 ldr r1, [pc, #804] ; 472c <rtems_fdisk_recycle_segment+0x3f4>
4404: e1a00008 mov r0, r8
4408: e58dc008 str ip, [sp, #8]
440c: e58d400c str r4, [sp, #12]
4410: ebfffd85 bl 3a2c <rtems_fdisk_info>
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage);
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
4414: e596b018 ldr fp, [r6, #24]
4418: e087b00b add fp, r7, fp
441c: e5951018 ldr r1, [r5, #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",
4420: e58db000 str fp, [sp]
4424: e5953008 ldr r3, [r5, #8]
4428: e58d3004 str r3, [sp, #4]
#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,
442c: e0841001 add r1, r4, r1
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",
4430: e595c00c ldr ip, [r5, #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,
4434: e58d1024 str r1, [sp, #36] ; 0x24
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",
4438: e2862008 add r2, r6, #8
443c: e892000c ldm r2, {r2, r3}
4440: e58dc008 str ip, [sp, #8]
4444: e59dc024 ldr ip, [sp, #36] ; 0x24
4448: e59f12e0 ldr r1, [pc, #736] ; 4730 <rtems_fdisk_recycle_segment+0x3f8>
444c: e1a00008 mov r0, r8
4450: e58dc00c str ip, [sp, #12]
4454: ebfffd98 bl 3abc <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);
4458: e598c014 ldr ip, [r8, #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,
445c: e5983068 ldr r3, [r8, #104] ; 0x68
4460: e0020b9c mul r2, ip, fp
4464: e1a00008 mov r0, r8
4468: e1a01006 mov r1, r6
446c: e58dc000 str ip, [sp]
4470: ebfffdb5 bl 3b4c <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)
4474: e250b000 subs fp, r0, #0
4478: 0a000048 beq 45a0 <rtems_fdisk_recycle_segment+0x268>
spage + ssc->pages_desc,
dsc,
dpage + dsc->pages_desc);
if (ret)
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
447c: e2859008 add r9, r5, #8 <== NOT EXECUTED
4480: e596200c ldr r2, [r6, #12] <== NOT EXECUTED
4484: e8991200 ldm r9, {r9, ip} <== NOT EXECUTED
4488: e1a0000b mov r0, fp <== NOT EXECUTED
448c: e596a008 ldr sl, [r6, #8] <== NOT EXECUTED
4490: e58d2018 str r2, [sp, #24] <== NOT EXECUTED
4494: e58dc014 str ip, [sp, #20] <== NOT EXECUTED
4498: eb0074af bl 2175c <strerror> <== NOT EXECUTED
449c: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED
44a0: e58d000c str r0, [sp, #12] <== NOT EXECUTED
44a4: e59f0288 ldr r0, [pc, #648] ; 4734 <rtems_fdisk_recycle_segment+0x3fc><== NOT EXECUTED
44a8: e1a03007 mov r3, r7 <== NOT EXECUTED
dsc,
dpage, dpd);
if (ret)
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
44ac: e59dc014 ldr ip, [sp, #20] <== NOT EXECUTED
44b0: e1a0100a mov r1, sl <== NOT EXECUTED
44b4: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
44b8: e58d9000 str r9, [sp] <== NOT EXECUTED
44bc: e58d4008 str r4, [sp, #8] <== NOT EXECUTED
44c0: e58db010 str fp, [sp, #16] <== NOT EXECUTED
44c4: ebfffe59 bl 3e30 <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);
44c8: e1a00008 mov r0, r8 <== NOT EXECUTED
44cc: e1a01005 mov r1, r5 <== NOT EXECUTED
44d0: ebfffeee bl 4090 <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;
44d4: e5983040 ldr r3, [r8, #64] ; 0x40 <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
44d8: e5982044 ldr r2, [r8, #68] ; 0x44 <== 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;
44dc: e5863000 str r3, [r6] <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
queue->tail = sc;
queue->count++;
44e0: e5983048 ldr r3, [r8, #72] ; 0x48 <== NOT EXECUTED
if (sc)
{
sc->next = queue->head;
queue->head = sc;
if (queue->tail == 0)
44e4: e3520000 cmp r2, #0 <== NOT EXECUTED
queue->tail = sc;
queue->count++;
44e8: e2833001 add r3, r3, #1 <== NOT EXECUTED
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = queue->head;
queue->head = sc;
44ec: e5886040 str r6, [r8, #64] ; 0x40 <== NOT EXECUTED
if (queue->tail == 0)
queue->tail = sc;
44f0: 05886044 streq r6, [r8, #68] ; 0x44 <== NOT EXECUTED
queue->count++;
44f4: e5883048 str r3, [r8, #72] ; 0x48 <== NOT EXECUTED
}
ret = rtems_fdisk_erase_segment (fd, ssc);
return ret;
}
44f8: e1a0000b mov r0, fp <== NOT EXECUTED
44fc: e28dd030 add sp, sp, #48 ; 0x30 <== NOT EXECUTED
4500: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
4504: e7923000 ldr r3, [r2, r0]
4508: e3730001 cmn r3, #1
450c: 0a000015 beq 4568 <rtems_fdisk_recycle_segment+0x230>
{
--fd->erased_blocks;
}
else
{
used++;
4510: e2899001 add r9, r9, #1
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
4514: e2877001 add r7, r7, #1
4518: e1510007 cmp r1, r7
451c: 8affff94 bhi 4374 <rtems_fdisk_recycle_segment+0x3c>
used++;
}
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, "ssc end: %d-%d: p=%ld, a=%ld, u=%ld",
4520: e59dc028 ldr ip, [sp, #40] ; 0x28
4524: e2862008 add r2, r6, #8
4528: e892000c ldm r2, {r2, r3}
452c: e58dc000 str ip, [sp]
4530: e59dc020 ldr ip, [sp, #32]
4534: e59f11fc ldr r1, [pc, #508] ; 4738 <rtems_fdisk_recycle_segment+0x400>
4538: e1a00008 mov r0, r8
453c: e58dc004 str ip, [sp, #4]
4540: e58d9008 str r9, [sp, #8]
4544: ebfffd5c bl 3abc <rtems_fdisk_printf>
ssc->device, ssc->segment,
pages, active, used);
#endif
if (ssc->pages_active != 0)
4548: e596101c ldr r1, [r6, #28]
454c: e3510000 cmp r1, #0
4550: 1a000049 bne 467c <rtems_fdisk_recycle_segment+0x344>
{
rtems_fdisk_error ("compacting: ssc pages not 0: %d",
ssc->pages_active);
}
ret = rtems_fdisk_erase_segment (fd, ssc);
4554: e1a00008 mov r0, r8
4558: e1a01006 mov r1, r6
return ret;
}
455c: e28dd030 add sp, sp, #48 ; 0x30
4560: 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);
4564: eafffe51 b 3eb0 <rtems_fdisk_erase_segment>
static bool
rtems_fdisk_page_desc_erased (const rtems_fdisk_page_desc* pd)
{
return ((pd->crc == 0xffff) &&
(pd->flags == 0xffff) &&
(pd->block == 0xffffffff)) ? true : false;
4568: e59a3004 ldr r3, [sl, #4] <== NOT EXECUTED
456c: e3730001 cmn r3, #1 <== NOT EXECUTED
4570: 1affffe6 bne 4510 <rtems_fdisk_recycle_segment+0x1d8> <== NOT EXECUTED
(*pages)--;
}
else if (rtems_fdisk_page_desc_erased (spd))
{
--fd->erased_blocks;
4574: e5983028 ldr r3, [r8, #40] ; 0x28 <== NOT EXECUTED
4578: e2433001 sub r3, r3, #1 <== NOT EXECUTED
457c: e5883028 str r3, [r8, #40] ; 0x28 <== NOT EXECUTED
4580: eaffffe3 b 4514 <rtems_fdisk_recycle_segment+0x1dc> <== NOT EXECUTED
for (spage = 0; spage < ssc->pages; spage++)
{
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
if (!dsc && ssc->pages_active > 0)
4584: e596301c ldr r3, [r6, #28]
4588: e3530000 cmp r3, #0
458c: 0affff7b beq 4380 <rtems_fdisk_recycle_segment+0x48>
{
rtems_fdisk_error ("recycle: no available dst segment");
4590: e59f01a4 ldr r0, [pc, #420] ; 473c <rtems_fdisk_recycle_segment+0x404><== NOT EXECUTED
4594: ebfffe25 bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
return EIO;
4598: e3a0b005 mov fp, #5 <== NOT EXECUTED
459c: eaffffd5 b 44f8 <rtems_fdisk_recycle_segment+0x1c0> <== 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,
45a0: e1a00008 mov r0, r8
45a4: e1a01005 mov r1, r5
45a8: e59d2024 ldr r2, [sp, #36] ; 0x24
45ac: e5983068 ldr r3, [r8, #104] ; 0x68
45b0: ebfffde1 bl 3d3c <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)
45b4: e250b000 subs fp, r0, #0
45b8: 1affffaf bne 447c <rtems_fdisk_recycle_segment+0x144>
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];
45bc: e59dc01c ldr ip, [sp, #28]
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
*dpd = *spd;
45c0: e89a0003 ldm sl, {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];
45c4: e08c3184 add r3, ip, r4, lsl #3
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
*dpd = *spd;
45c8: e8830003 stm r3, {r0, r1}
ret = rtems_fdisk_seg_write_page_desc (fd,
45cc: e1a02004 mov r2, r4
45d0: e1a00008 mov r0, r8
45d4: e1a01005 mov r1, r5
45d8: ebfffdc0 bl 3ce0 <rtems_fdisk_seg_write_page_desc>
dsc,
dpage, dpd);
if (ret)
45dc: e250b000 subs fp, r0, #0
45e0: 1a000042 bne 46f0 <rtems_fdisk_recycle_segment+0x3b8>
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
dsc->pages_active++;
45e4: e595301c ldr r3, [r5, #28]
45e8: e2833001 add r3, r3, #1
45ec: e585301c str r3, [r5, #28]
*/
ssc->pages_active--;
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
45f0: e59a2004 ldr r2, [sl, #4]
45f4: e5983018 ldr r3, [r8, #24]
* We do the stats to make sure everything is as it should
* be.
*/
ssc->pages_active--;
ssc->pages_used++;
45f8: e5960020 ldr r0, [r6, #32]
* 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--;
45fc: e596c01c ldr ip, [r6, #28]
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
4600: e0831182 add r1, r3, r2, lsl #3
* 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--;
4604: e24cc001 sub ip, ip, #1
ssc->pages_used++;
4608: e2800001 add r0, r0, #1
460c: e5860020 str r0, [r6, #32]
* 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--;
4610: e586c01c str ip, [r6, #28]
fd->blocks[spd->block].page = dpage;
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, dsc);
4614: e1a00008 mov r0, r8
*/
ssc->pages_active--;
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
4618: e7835182 str r5, [r3, r2, lsl #3]
fd->blocks[spd->block].page = dpage;
461c: e5814004 str r4, [r1, #4]
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, dsc);
4620: e1a01005 mov r1, r5
4624: ebfffe99 bl 4090 <rtems_fdisk_queue_segment>
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
4628: e2852020 add r2, r5, #32
462c: e8120006 ldmda r2, {r1, r2}
4630: e0821001 add r1, r2, r1
4634: e5953024 ldr r3, [r5, #36] ; 0x24
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
if (dst_pages == 0)
4638: e5952014 ldr r2, [r5, #20]
* active, used and bad pages.
*/
static uint32_t
rtems_fdisk_seg_pages_available (const rtems_fdisk_segment_ctl* sc)
{
return sc->pages - (sc->pages_active + sc->pages_used + sc->pages_bad);
463c: e0813003 add r3, r1, r3
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
if (dst_pages == 0)
4640: e1520003 cmp r2, r3
4644: 0a000008 beq 466c <rtems_fdisk_recycle_segment+0x334>
dsc = rtems_fdisk_seg_most_available (&fd->available);
(*pages)--;
4648: e59dc028 ldr ip, [sp, #40] ; 0x28
464c: e59c3000 ldr r3, [ip]
4650: e2433001 sub r3, r3, #1
4654: e58c3000 str r3, [ip]
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
active++;
4658: e59dc020 ldr ip, [sp, #32]
465c: e28cc001 add ip, ip, #1
4660: e58dc020 str ip, [sp, #32]
4664: e5961014 ldr r1, [r6, #20]
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))
{
4668: eaffffa9 b 4514 <rtems_fdisk_recycle_segment+0x1dc>
/*
* 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);
466c: e59d002c ldr r0, [sp, #44] ; 0x2c
4670: ebfffcd4 bl 39c8 <rtems_fdisk_seg_most_available>
4674: e1a05000 mov r5, r0
4678: eafffff2 b 4648 <rtems_fdisk_recycle_segment+0x310>
ssc->device, ssc->segment,
pages, active, used);
#endif
if (ssc->pages_active != 0)
{
rtems_fdisk_error ("compacting: ssc pages not 0: %d",
467c: e59f00bc ldr r0, [pc, #188] ; 4740 <rtems_fdisk_recycle_segment+0x408><== NOT EXECUTED
4680: ebfffdea bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
4684: eaffffb2 b 4554 <rtems_fdisk_recycle_segment+0x21c> <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
4688: e285101c add r1, r5, #28 <== NOT EXECUTED
468c: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
4690: e5950024 ldr r0, [r5, #36] ; 0x24 <== NOT EXECUTED
4694: e0800001 add r0, r0, r1 <== NOT EXECUTED
4698: e0800002 add r0, r0, r2 <== NOT EXECUTED
active++;
if (dpage >= dsc->pages)
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
469c: e2851008 add r1, r5, #8 <== NOT EXECUTED
46a0: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
46a4: e0603003 rsb r3, r0, r3 <== NOT EXECUTED
46a8: e59f0094 ldr r0, [pc, #148] ; 4744 <rtems_fdisk_recycle_segment+0x40c><== NOT EXECUTED
46ac: ebfffddf bl 3e30 <rtems_fdisk_error> <== NOT EXECUTED
"no page desc available: %d",
dsc->device, dsc->segment,
rtems_fdisk_seg_pages_available (dsc));
dsc->failed = true;
46b0: e3a03001 mov r3, #1 <== NOT EXECUTED
46b4: e5853028 str r3, [r5, #40] ; 0x28 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, dsc);
46b8: e1a00008 mov r0, r8 <== NOT EXECUTED
46bc: e1a01005 mov r1, r5 <== NOT EXECUTED
46c0: ebfffe72 bl 4090 <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;
46c4: e5983040 ldr r3, [r8, #64] ; 0x40 <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
46c8: e5982044 ldr r2, [r8, #68] ; 0x44 <== 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;
46cc: e5863000 str r3, [r6] <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
queue->tail = sc;
queue->count++;
46d0: e5983048 ldr r3, [r8, #72] ; 0x48 <== NOT EXECUTED
if (sc)
{
sc->next = queue->head;
queue->head = sc;
if (queue->tail == 0)
46d4: e3520000 cmp r2, #0 <== NOT EXECUTED
queue->tail = sc;
queue->count++;
46d8: e2833001 add r3, r3, #1 <== NOT EXECUTED
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = queue->head;
queue->head = sc;
46dc: e5886040 str r6, [r8, #64] ; 0x40 <== NOT EXECUTED
if (queue->tail == 0)
queue->tail = sc;
46e0: 05886044 streq r6, [r8, #68] ; 0x44 <== NOT EXECUTED
queue->count++;
46e4: e5883048 str r3, [r8, #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;
46e8: e3a0b005 mov fp, #5 <== NOT EXECUTED
46ec: eaffff81 b 44f8 <rtems_fdisk_recycle_segment+0x1c0> <== NOT EXECUTED
dsc,
dpage, dpd);
if (ret)
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
46f0: e2859008 add r9, r5, #8 <== NOT EXECUTED
46f4: e596200c ldr r2, [r6, #12] <== NOT EXECUTED
46f8: e8991200 ldm r9, {r9, ip} <== NOT EXECUTED
46fc: e596a008 ldr sl, [r6, #8] <== NOT EXECUTED
4700: e58d2018 str r2, [sp, #24] <== NOT EXECUTED
4704: e58dc014 str ip, [sp, #20] <== NOT EXECUTED
4708: eb007413 bl 2175c <strerror> <== NOT EXECUTED
470c: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED
4710: e58d000c str r0, [sp, #12] <== NOT EXECUTED
4714: e1a03007 mov r3, r7 <== NOT EXECUTED
4718: e59f0028 ldr r0, [pc, #40] ; 4748 <rtems_fdisk_recycle_segment+0x410><== NOT EXECUTED
471c: eaffff62 b 44ac <rtems_fdisk_recycle_segment+0x174> <== NOT EXECUTED
uint32_t *pages)
{
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
4720: e58d1020 str r1, [sp, #32] <== NOT EXECUTED
rtems_fdisk_segment_ctl* dsc,
uint32_t *pages)
{
int ret;
uint32_t spage;
uint32_t used = 0;
4724: e1a09001 mov r9, r1 <== NOT EXECUTED
4728: eaffff7c b 4520 <rtems_fdisk_recycle_segment+0x1e8> <== NOT EXECUTED
00004000 <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)
4000: e3510000 cmp r1, #0
4004: 0a00000c beq 403c <rtems_fdisk_segment_queue_insert_before+0x3c>
{
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
4008: e5903000 ldr r3, [r0]
while (it)
400c: e3530000 cmp r3, #0
4010: 0a000009 beq 403c <rtems_fdisk_segment_queue_insert_before+0x3c>
{
if (item == it)
4014: e1510003 cmp r1, r3
rtems_fdisk_segment_ctl* item,
rtems_fdisk_segment_ctl* sc)
{
if (item)
{
rtems_fdisk_segment_ctl** prev = &queue->head;
4018: 01a0c000 moveq ip, r0
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
{
if (item == it)
401c: 1a000002 bne 402c <rtems_fdisk_segment_queue_insert_before+0x2c>
4020: ea000014 b 4078 <rtems_fdisk_segment_queue_insert_before+0x78>
4024: e1510003 cmp r1, r3
4028: 0a000012 beq 4078 <rtems_fdisk_segment_queue_insert_before+0x78>
*prev = sc;
queue->count++;
return;
}
prev = &it->next;
402c: e1a0c003 mov ip, r3
it = it->next;
4030: e5933000 ldr r3, [r3]
if (item)
{
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
4034: e3530000 cmp r3, #0
4038: 1afffff9 bne 4024 <rtems_fdisk_segment_queue_insert_before+0x24>
*/
static void
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
403c: e3520000 cmp r2, #0 <== NOT EXECUTED
4040: 012fff1e bxeq lr <== NOT EXECUTED
{
sc->next = 0;
if (queue->head)
4044: e5903000 ldr r3, [r0] <== NOT EXECUTED
4048: e3530000 cmp r3, #0 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
{
sc->next = 0;
404c: e3a03000 mov r3, #0 <== NOT EXECUTED
4050: e5823000 str r3, [r2] <== NOT EXECUTED
if (queue->head)
{
queue->tail->next = sc;
4054: 15903004 ldrne r3, [r0, #4] <== NOT EXECUTED
4058: 15832000 strne r2, [r3] <== NOT EXECUTED
else
{
queue->head = queue->tail = sc;
}
queue->count++;
405c: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED
4060: e2833001 add r3, r3, #1 <== NOT EXECUTED
sc->next = 0;
if (queue->head)
{
queue->tail->next = sc;
queue->tail = sc;
4064: 15802004 strne r2, [r0, #4] <== NOT EXECUTED
}
else
{
queue->head = queue->tail = sc;
4068: 05802004 streq r2, [r0, #4] <== NOT EXECUTED
406c: 05802000 streq r2, [r0] <== NOT EXECUTED
}
queue->count++;
4070: e5803008 str r3, [r0, #8] <== NOT EXECUTED
4074: e12fff1e bx lr <== NOT EXECUTED
{
if (item == it)
{
sc->next = item;
*prev = sc;
queue->count++;
4078: e5903008 ldr r3, [r0, #8]
407c: e2833001 add r3, r3, #1
while (it)
{
if (item == it)
{
sc->next = item;
4080: e5821000 str r1, [r2]
*prev = sc;
4084: e58c2000 str r2, [ip]
queue->count++;
4088: e5803008 str r3, [r0, #8]
return;
408c: e12fff1e bx lr
00003da4 <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, ...)
{
3da4: e92d000e push {r1, r2, r3} <== NOT EXECUTED
3da8: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
int ret = 0; if (fd->info_level >= 1)
3dac: e590506c ldr r5, [r0, #108] ; 0x6c <== NOT EXECUTED
3db0: e3550000 cmp r5, #0 <== NOT EXECUTED
* @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, ...)
{
3db4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
int ret = 0; if (fd->info_level >= 1)
3db8: 0a000015 beq 3e14 <rtems_fdisk_warning+0x70> <== NOT EXECUTED
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:warning:");
3dbc: e59f4064 ldr r4, [pc, #100] ; 3e28 <rtems_fdisk_warning+0x84><== NOT EXECUTED
3dc0: e5943000 ldr r3, [r4] <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
3dc4: e28dc014 add ip, sp, #20 <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
3dc8: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
3dcc: e3a01001 mov r1, #1 <== NOT EXECUTED
3dd0: e3a0200e mov r2, #14 <== NOT EXECUTED
3dd4: e59f0050 ldr r0, [pc, #80] ; 3e2c <rtems_fdisk_warning+0x88><== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
3dd8: e58dc000 str ip, [sp] <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
3ddc: eb007072 bl 1ffac <fwrite> <== NOT EXECUTED
ret = vfprintf (stdout, format, args);
3de0: e5943000 ldr r3, [r4] <== NOT EXECUTED
3de4: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
3de8: e59d2000 ldr r2, [sp] <== NOT EXECUTED
3dec: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
3df0: eb009190 bl 28438 <vfprintf> <== NOT EXECUTED
fprintf (stdout, "\n");
3df4: 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);
3df8: e1a05000 mov r5, r0 <== NOT EXECUTED
fprintf (stdout, "\n");
3dfc: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED
3e00: e3a0000a mov r0, #10 <== NOT EXECUTED
3e04: eb006fec bl 1fdbc <fputc> <== NOT EXECUTED
fflush (stdout);
3e08: e5943000 ldr r3, [r4] <== NOT EXECUTED
3e0c: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
3e10: eb006edc bl 1f988 <fflush> <== NOT EXECUTED
va_end (args);
}
return ret;
}
3e14: e1a00005 mov r0, r5 <== NOT EXECUTED
3e18: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3e1c: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
3e20: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3e24: e12fff1e bx lr <== NOT EXECUTED
00003a78 <rtems_filesystem_do_unmount>:
}
void rtems_filesystem_do_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
3a78: e92d4030 push {r4, r5, lr}
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
3a7c: e59f506c ldr r5, [pc, #108] ; 3af0 <rtems_filesystem_do_unmount+0x78>
3a80: e3a01000 mov r1, #0
3a84: e1a04000 mov r4, r0
3a88: e1a02001 mov r2, r1
3a8c: e5950000 ldr r0, [r5]
3a90: eb000ad7 bl 65f4 <rtems_semaphore_obtain>
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3a94: e894000c ldm r4, {r2, r3}
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
3a98: e5950000 ldr r0, [r5]
next->previous = previous;
3a9c: e5823004 str r3, [r2, #4]
previous->next = next;
3aa0: e5832000 str r2, [r3]
3aa4: eb000b1b bl 6718 <rtems_semaphore_release>
rtems_filesystem_mt_lock(); rtems_chain_extract_unprotected(&mt_entry->mt_node); rtems_filesystem_mt_unlock(); rtems_filesystem_global_location_release(mt_entry->mt_point_node);
3aa8: e5940020 ldr r0, [r4, #32]
3aac: eb000069 bl 3c58 <rtems_filesystem_global_location_release>
(*mt_entry->ops->fsunmount_me_h)(mt_entry);
3ab0: e1a00004 mov r0, r4
3ab4: e594300c ldr r3, [r4, #12]
3ab8: e1a0e00f mov lr, pc
3abc: e593f03c ldr pc, [r3, #60] ; 0x3c
if (mt_entry->unmount_task != 0) {
3ac0: e594003c ldr r0, [r4, #60] ; 0x3c
3ac4: e3500000 cmp r0, #0
3ac8: 0a000003 beq 3adc <rtems_filesystem_do_unmount+0x64>
*/
RTEMS_INLINE_ROUTINE rtems_status_code rtems_event_transient_send(
rtems_id id
)
{
return rtems_event_system_send( id, RTEMS_EVENT_SYSTEM_TRANSIENT );
3acc: e3a01102 mov r1, #-2147483648 ; 0x80000000
3ad0: eb000b39 bl 67bc <rtems_event_system_send>
rtems_status_code sc =
rtems_event_transient_send(mt_entry->unmount_task);
if (sc != RTEMS_SUCCESSFUL) {
3ad4: e3500000 cmp r0, #0
3ad8: 1a000002 bne 3ae8 <rtems_filesystem_do_unmount+0x70>
rtems_fatal_error_occurred(0xdeadbeef);
}
}
free(mt_entry);
3adc: e1a00004 mov r0, r4
}
3ae0: e8bd4030 pop {r4, r5, lr}
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
}
}
free(mt_entry);
3ae4: eafffa8a b 2514 <free>
if (mt_entry->unmount_task != 0) {
rtems_status_code sc =
rtems_event_transient_send(mt_entry->unmount_task);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
3ae8: e59f0004 ldr r0, [pc, #4] ; 3af4 <rtems_filesystem_do_unmount+0x7c><== NOT EXECUTED
3aec: eb000c9a bl 6d5c <rtems_fatal_error_occurred> <== NOT EXECUTED
0000b3a8 <rtems_filesystem_eval_path_next_token>:
}
void rtems_filesystem_eval_path_next_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
b3a8: e92d4010 push {r4, lr}
b3ac: e1a04000 mov r4, r0
rtems_filesystem_eval_path_eat_delimiter(ctx);
b3b0: ebffffe8 bl b358 <rtems_filesystem_eval_path_eat_delimiter>
ctx->pathlen = (size_t) (end - current);
}
static void next_token(rtems_filesystem_eval_path_context_t *ctx)
{
const char *begin = ctx->path;
b3b4: e594c000 ldr ip, [r4]
const char *end = begin + ctx->pathlen;
b3b8: e5940004 ldr r0, [r4, #4]
b3bc: e08c0000 add r0, ip, r0
const char *current = begin;
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
b3c0: e15c0000 cmp ip, r0
b3c4: 01a0100c moveq r1, ip
b3c8: 01a0300c moveq r3, ip
b3cc: 03a02000 moveq r2, #0
b3d0: 0a000010 beq b418 <rtems_filesystem_eval_path_next_token+0x70>
b3d4: e5dc3000 ldrb r3, [ip]
b3d8: e353002f cmp r3, #47 ; 0x2f
b3dc: 1353005c cmpne r3, #92 ; 0x5c
b3e0: e1a0100c mov r1, ip
ctx->pathlen = (size_t) (end - current);
ctx->token = begin;
ctx->tokenlen = (size_t) (current - begin);
}
void rtems_filesystem_eval_path_next_token(
b3e4: e1a0300c mov r3, ip
{
const char *begin = ctx->path;
const char *end = begin + ctx->pathlen;
const char *current = begin;
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
b3e8: 03a02000 moveq r2, #0
b3ec: 1a000004 bne b404 <rtems_filesystem_eval_path_next_token+0x5c>
b3f0: ea000008 b b418 <rtems_filesystem_eval_path_next_token+0x70><== NOT EXECUTED
b3f4: e5f12001 ldrb r2, [r1, #1]!
b3f8: e352002f cmp r2, #47 ; 0x2f
b3fc: 1352005c cmpne r2, #92 ; 0x5c
b400: 0a000009 beq b42c <rtems_filesystem_eval_path_next_token+0x84>
++current;
b404: e2833001 add r3, r3, #1
{
const char *begin = ctx->path;
const char *end = begin + ctx->pathlen;
const char *current = begin;
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
b408: e1500003 cmp r0, r3
b40c: 1afffff8 bne b3f4 <rtems_filesystem_eval_path_next_token+0x4c>
b410: e1a01000 mov r1, r0
b414: e06c2000 rsb r2, ip, r0
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
b418: e0610000 rsb r0, r1, r0
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
++current;
}
ctx->path = current;
b41c: e5843000 str r3, [r4]
ctx->pathlen = (size_t) (end - current); ctx->token = begin;
b420: e9841001 stmib r4, {r0, ip}
ctx->tokenlen = (size_t) (current - begin);
b424: e584200c str r2, [r4, #12]
rtems_filesystem_eval_path_context_t *ctx
)
{
rtems_filesystem_eval_path_eat_delimiter(ctx);
next_token(ctx);
}
b428: e8bd8010 pop {r4, pc}
{
const char *begin = ctx->path;
const char *end = begin + ctx->pathlen;
const char *current = begin;
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
b42c: e1a01003 mov r1, r3
b430: e06c2003 rsb r2, ip, r3
++current;
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
b434: e0610000 rsb r0, r1, r0
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
++current;
}
ctx->path = current;
b438: e5843000 str r3, [r4]
ctx->pathlen = (size_t) (end - current); ctx->token = begin;
b43c: e9841001 stmib r4, {r0, ip}
ctx->tokenlen = (size_t) (current - begin);
b440: e584200c str r2, [r4, #12]
rtems_filesystem_eval_path_context_t *ctx
)
{
rtems_filesystem_eval_path_eat_delimiter(ctx);
next_token(ctx);
}
b444: e8bd8010 pop {r4, pc}
0000395c <rtems_filesystem_eval_path_recursive>:
void rtems_filesystem_eval_path_recursive(
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
395c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
if (pathlen > 0) {
3960: e2526000 subs r6, r2, #0
void rtems_filesystem_eval_path_recursive(
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
3964: e1a04000 mov r4, r0
3968: e1a05001 mov r5, r1
if (pathlen > 0) {
396c: 0a000019 beq 39d8 <rtems_filesystem_eval_path_recursive+0x7c>
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
3970: e5903014 ldr r3, [r0, #20]
3974: e353001f cmp r3, #31
3978: ca00001d bgt 39f4 <rtems_filesystem_eval_path_recursive+0x98>
const char *saved_path = ctx->path;
size_t saved_pathlen = ctx->pathlen;
if (rtems_filesystem_is_delimiter(path [0])) {
397c: e5d12000 ldrb r2, [r1]
3980: e352002f cmp r2, #47 ; 0x2f
3984: 1352005c cmpne r2, #92 ; 0x5c
size_t pathlen
)
{
if (pathlen > 0) {
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
const char *saved_path = ctx->path;
3988: e5908000 ldr r8, [r0]
size_t saved_pathlen = ctx->pathlen;
398c: e5907004 ldr r7, [r0, #4]
if (rtems_filesystem_is_delimiter(path [0])) {
3990: 0a000013 beq 39e4 <rtems_filesystem_eval_path_recursive+0x88>
}
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
3994: 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;
3998: e8840060 stm r4, {r5, r6}
++ctx->recursionlevel;
399c: e5843014 str r3, [r4, #20]
while (ctx->pathlen > 0) {
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
39a0: e594302c ldr r3, [r4, #44] ; 0x2c
39a4: e1a00004 mov r0, r4
39a8: e593300c ldr r3, [r3, #12]
39ac: e1a0e00f mov lr, pc
39b0: e593f008 ldr pc, [r3, #8]
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
39b4: e5943004 ldr r3, [r4, #4]
39b8: e3530000 cmp r3, #0
39bc: 1afffff7 bne 39a0 <rtems_filesystem_eval_path_recursive+0x44>
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
39c0: e5943014 ldr r3, [r4, #20]
39c4: e2433001 sub r3, r3, #1
39c8: e5843014 str r3, [r4, #20]
ctx->path = saved_path;
39cc: e5848000 str r8, [r4]
ctx->pathlen = saved_pathlen;
39d0: e5847004 str r7, [r4, #4]
rtems_filesystem_eval_path_error(ctx, ELOOP);
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
}
}
39d4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
ctx->pathlen = saved_pathlen;
} else {
rtems_filesystem_eval_path_error(ctx, ELOOP);
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
39d8: e3a01002 mov r1, #2 <== NOT EXECUTED
} }
39dc: e8bd41f0 pop {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
ctx->pathlen = saved_pathlen;
} else {
rtems_filesystem_eval_path_error(ctx, ELOOP);
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
39e0: eafffee2 b 3570 <rtems_filesystem_eval_path_error> <== NOT EXECUTED
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
const char *saved_path = ctx->path;
size_t saved_pathlen = ctx->pathlen;
if (rtems_filesystem_is_delimiter(path [0])) {
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
39e4: e2801030 add r1, r0, #48 ; 0x30
39e8: ebffffc1 bl 38f4 <rtems_filesystem_eval_path_restart>
39ec: e5943014 ldr r3, [r4, #20]
39f0: eaffffe7 b 3994 <rtems_filesystem_eval_path_recursive+0x38>
--ctx->recursionlevel;
ctx->path = saved_path;
ctx->pathlen = saved_pathlen;
} else {
rtems_filesystem_eval_path_error(ctx, ELOOP);
39f4: e3a0105c mov r1, #92 ; 0x5c
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
}
}
39f8: e8bd41f0 pop {r4, r5, r6, r7, r8, lr}
--ctx->recursionlevel;
ctx->path = saved_path;
ctx->pathlen = saved_pathlen;
} else {
rtems_filesystem_eval_path_error(ctx, ELOOP);
39fc: eafffedb b 3570 <rtems_filesystem_eval_path_error>
0000223c <rtems_filesystem_initialize>:
/*
* Default mode for created files.
*/
void rtems_filesystem_initialize( void )
{
223c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
2240: e59fc044 ldr ip, [pc, #68] ; 228c <rtems_filesystem_initialize+0x50>
2244: e89c000f ldm ip, {r0, r1, r2, r3}
2248: e59cc010 ldr ip, [ip, #16]
/*
* Default mode for created files.
*/
void rtems_filesystem_initialize( void )
{
224c: e24dd004 sub sp, sp, #4
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
2250: e58dc000 str ip, [sp]
2254: eb0001f3 bl 2a28 <mount>
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
2258: e3500000 cmp r0, #0
225c: 1a000006 bne 227c <rtems_filesystem_initialize+0x40>
*
* 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);
2260: e59f0028 ldr r0, [pc, #40] ; 2290 <rtems_filesystem_initialize+0x54>
2264: e59f1028 ldr r1, [pc, #40] ; 2294 <rtems_filesystem_initialize+0x58>
2268: eb0001b2 bl 2938 <mkdir>
if ( rv != 0 )
226c: e3500000 cmp r0, #0
2270: 1a000003 bne 2284 <rtems_filesystem_initialize+0x48>
* 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.
*/
}
2274: e28dd004 add sp, sp, #4
2278: e8bd8000 pop {pc}
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
rtems_fatal_error_occurred( 0xABCD0002 );
227c: e59f0014 ldr r0, [pc, #20] ; 2298 <rtems_filesystem_initialize+0x5c><== NOT EXECUTED
2280: eb0012b5 bl 6d5c <rtems_fatal_error_occurred> <== NOT EXECUTED
* created that way by the IMFS.
*/
rv = mkdir( "/dev", 0777);
if ( rv != 0 )
rtems_fatal_error_occurred( 0xABCD0003 );
2284: e59f0010 ldr r0, [pc, #16] ; 229c <rtems_filesystem_initialize+0x60><== NOT EXECUTED
2288: eb0012b3 bl 6d5c <rtems_fatal_error_occurred> <== NOT EXECUTED
00003af8 <rtems_filesystem_location_remove_from_mt_entry>:
}
void rtems_filesystem_location_remove_from_mt_entry(
rtems_filesystem_location_info_t *loc
)
{
3af8: e92d0030 push {r4, r5}
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3afc: e10f4000 mrs r4, CPSR
3b00: e3843080 orr r3, r4, #128 ; 0x80
3b04: e129f003 msr CPSR_fc, r3
rtems_filesystem_mt_entry_declare_lock_context(lock_context);
bool do_unmount;
rtems_filesystem_mt_entry_lock(lock_context);
rtems_chain_extract_unprotected(&loc->mt_entry_node);
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
3b08: e5903014 ldr r3, [r0, #20]
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
&& mt_entry->mt_fs_root->reference_count == 1;
3b0c: e5d3c028 ldrb ip, [r3, #40] ; 0x28
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
3b10: e8900006 ldm r0, {r1, r2}
3b14: e35c0000 cmp ip, #0
next->previous = previous;
3b18: e5812004 str r2, [r1, #4]
previous->next = next;
3b1c: e5821000 str r1, [r2]
static inline bool rtems_filesystem_is_ready_for_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
3b20: 13a0c000 movne ip, #0
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
&& mt_entry->mt_fs_root->reference_count == 1;
3b24: 1a000003 bne 3b38 <rtems_filesystem_location_remove_from_mt_entry+0x40>
static inline bool rtems_filesystem_is_ready_for_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
3b28: e5931014 ldr r1, [r3, #20]
3b2c: e593201c ldr r2, [r3, #28]
3b30: e1510002 cmp r1, r2
3b34: 0a000007 beq 3b58 <rtems_filesystem_location_remove_from_mt_entry+0x60>
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3b38: e129f004 msr CPSR_fc, r4
rtems_filesystem_mt_entry_unlock(lock_context);
if (do_unmount) {
3b3c: e35c0000 cmp ip, #0
3b40: 1a000001 bne 3b4c <rtems_filesystem_location_remove_from_mt_entry+0x54>
rtems_filesystem_do_unmount(loc->mt_entry);
}
}
3b44: e8bd0030 pop {r4, r5}
3b48: e12fff1e bx lr
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);
3b4c: e5900014 ldr r0, [r0, #20] <== NOT EXECUTED
} }
3b50: e8bd0030 pop {r4, r5} <== 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);
3b54: eaffffc7 b 3a78 <rtems_filesystem_do_unmount> <== NOT EXECUTED
&& mt_entry->mt_fs_root->reference_count == 1;
3b58: e5932024 ldr r2, [r3, #36] ; 0x24
3b5c: e5922018 ldr r2, [r2, #24]
3b60: e3520001 cmp r2, #1
3b64: 1afffff3 bne 3b38 <rtems_filesystem_location_remove_from_mt_entry+0x40>
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 );
3b68: e2831014 add r1, r3, #20 <== NOT EXECUTED
3b6c: e2835018 add r5, r3, #24 <== NOT EXECUTED
head->next = tail;
head->previous = NULL;
3b70: e583c018 str ip, [r3, #24] <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3b74: e5835014 str r5, [r3, #20] <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3b78: e583101c str r1, [r3, #28] <== NOT EXECUTED
static inline bool rtems_filesystem_is_ready_for_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
bool ready = !mt_entry->mounted
3b7c: e1a0c002 mov ip, r2 <== NOT EXECUTED
3b80: eaffffec b 3b38 <rtems_filesystem_location_remove_from_mt_entry+0x40><== NOT EXECUTED
00003d8c <rtems_filesystem_location_transform_to_global>:
}
rtems_filesystem_global_location_t *rtems_filesystem_location_transform_to_global(
rtems_filesystem_location_info_t *loc
)
{
3d8c: e92d4030 push {r4, r5, lr}
3d90: e1a05000 mov r5, r0
3d94: e24dd004 sub sp, sp, #4
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
3d98: e3a00024 mov r0, #36 ; 0x24
3d9c: ebfffaaa bl 284c <malloc>
if (global_loc != NULL) {
3da0: e2504000 subs r4, r0, #0
3da4: 0a00000b beq 3dd8 <rtems_filesystem_location_transform_to_global+0x4c>
global_loc->reference_count = 1;
global_loc->deferred_released_next = NULL;
3da8: e3a03000 mov r3, #0
)
{
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
if (global_loc != NULL) {
global_loc->reference_count = 1;
3dac: e3a02001 mov r2, #1
3db0: e5842018 str r2, [r4, #24]
global_loc->deferred_released_next = NULL;
3db4: e584301c str r3, [r4, #28]
global_loc->deferred_released_count = 0;
3db8: e5843020 str r3, [r4, #32]
rtems_filesystem_location_copy(&global_loc->location, loc);
3dbc: e1a01005 mov r1, r5
3dc0: ebffff0e bl 3a00 <rtems_filesystem_location_copy>
rtems_filesystem_location_remove_from_mt_entry(loc);
3dc4: e1a00005 mov r0, r5
3dc8: ebffff4a bl 3af8 <rtems_filesystem_location_remove_from_mt_entry>
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
}
return global_loc;
}
3dcc: e1a00004 mov r0, r4
3dd0: e28dd004 add sp, sp, #4
3dd4: e8bd8030 pop {r4, r5, pc}
global_loc->deferred_released_next = NULL;
global_loc->deferred_released_count = 0;
rtems_filesystem_location_copy(&global_loc->location, loc);
rtems_filesystem_location_remove_from_mt_entry(loc);
} else {
rtems_filesystem_location_free(loc);
3dd8: e1a00005 mov r0, r5 <== NOT EXECUTED
3ddc: eb001b7e bl abdc <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;
3de0: e28d0004 add r0, sp, #4 <== NOT EXECUTED
3de4: e5204004 str r4, [r0, #-4]! <== NOT EXECUTED
return rtems_filesystem_global_location_obtain( &global_loc );
3de8: e1a0000d mov r0, sp <== NOT EXECUTED
3dec: ebffffb6 bl 3ccc <rtems_filesystem_global_location_obtain> <== NOT EXECUTED
3df0: e1a04000 mov r4, r0 <== NOT EXECUTED
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
3df4: eb00267b bl d7e8 <__errno> <== NOT EXECUTED
3df8: e3a0300c mov r3, #12 <== NOT EXECUTED
3dfc: e5803000 str r3, [r0] <== NOT EXECUTED
3e00: eafffff1 b 3dcc <rtems_filesystem_location_transform_to_global+0x40><== NOT EXECUTED
00002e38 <rtems_gxx_key_create>:
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
2e38: e92d4070 push {r4, r5, r6, lr}
2e3c: 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 ) );
2e40: e3a00008 mov r0, #8
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
2e44: 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 ) );
2e48: eb0000f4 bl 3220 <malloc>
*key = new_key; new_key->val = NULL;
2e4c: e3a03000 mov r3, #0
* 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 ) );
2e50: e1a04000 mov r4, r0
*key = new_key;
2e54: 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 );
2e58: e1a01004 mov r1, r4
2e5c: e1a00003 mov r0, r3
2e60: 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;
2e64: e8840028 stm r4, {r3, 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 );
2e68: eb0011ec bl 7620 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL )
2e6c: e3500000 cmp r0, #0
2e70: 08bd8070 popeq {r4, r5, r6, pc}
return 0;
free( new_key );
2e74: e1a00004 mov r0, r4 <== NOT EXECUTED
2e78: ebffff81 bl 2c84 <free> <== NOT EXECUTED
return -1;
2e7c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
2e80: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00002dbc <rtems_gxx_once>:
/* uncomment this if you need to debug this interface */
/*#define DEBUG_GXX_WRAPPERS 1*/
int rtems_gxx_once(__gthread_once_t *once, void (*func) (void))
{
2dbc: e92d4030 push {r4, r5, lr}
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
2dc0: e5903000 ldr r3, [r0]
2dc4: e3530000 cmp r3, #0
/* uncomment this if you need to debug this interface */
/*#define DEBUG_GXX_WRAPPERS 1*/
int rtems_gxx_once(__gthread_once_t *once, void (*func) (void))
{
2dc8: e24dd004 sub sp, sp, #4
2dcc: e1a04000 mov r4, r0
2dd0: e1a05001 mov r5, r1
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
2dd4: 0a000002 beq 2de4 <rtems_gxx_once+0x28>
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
if ( o == 0 )
(*func)();
}
return 0;
}
2dd8: e3a00000 mov r0, #0
2ddc: e28dd004 add sp, sp, #4
2de0: e8bd8030 pop {r4, r5, pc}
if ( *(volatile __gthread_once_t *)once == 0 ) {
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
2de4: e3a00c01 mov r0, #256 ; 0x100
2de8: e1a01000 mov r1, r0
2dec: e1a0200d mov r2, sp
2df0: eb001193 bl 7444 <rtems_task_mode>
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
2df4: e5943000 ldr r3, [r4]
2df8: e3530000 cmp r3, #0
2dfc: 1a000008 bne 2e24 <rtems_gxx_once+0x68>
*(volatile __gthread_once_t *)once = 1;
2e00: e3a03001 mov r3, #1
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
2e04: e3a01c01 mov r1, #256 ; 0x100
2e08: e1a0200d mov r2, sp
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
*(volatile __gthread_once_t *)once = 1;
2e0c: e5843000 str r3, [r4]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
2e10: e59d0000 ldr r0, [sp]
2e14: eb00118a bl 7444 <rtems_task_mode>
if ( o == 0 )
(*func)();
2e18: e1a0e00f mov lr, pc
2e1c: e12fff15 bx r5
2e20: eaffffec b 2dd8 <rtems_gxx_once+0x1c>
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
*(volatile __gthread_once_t *)once = 1;
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
2e24: e59d0000 ldr r0, [sp] <== NOT EXECUTED
2e28: e3a01c01 mov r1, #256 ; 0x100 <== NOT EXECUTED
2e2c: e1a0200d mov r2, sp <== NOT EXECUTED
2e30: eb001183 bl 7444 <rtems_task_mode> <== NOT EXECUTED
2e34: eaffffe7 b 2dd8 <rtems_gxx_once+0x1c> <== NOT EXECUTED
00003df0 <rtems_ide_part_table_free>:
* RETURNS:
* N/A
*/
void
rtems_ide_part_table_free(rtems_disk_desc_t *disk_desc)
{
3df0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
3df4: e1a06000 mov r6, r0 <== NOT EXECUTED
* * RETURNS: * N/A */ void rtems_ide_part_table_free(rtems_disk_desc_t *disk_desc)
3df8: e2805024 add r5, r0, #36 ; 0x24 <== NOT EXECUTED
3dfc: 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]);
3e00: e5b50004 ldr r0, [r5, #4]! <== NOT EXECUTED
3e04: ebfffed5 bl 3960 <partition_free> <== NOT EXECUTED
static void
partition_table_free(rtems_disk_desc_t *disk_desc)
{
int part_num;
for (part_num = 0;
3e08: e2544001 subs r4, r4, #1 <== NOT EXECUTED
3e0c: 1afffffb bne 3e00 <rtems_ide_part_table_free+0x10> <== NOT EXECUTED
part_num++)
{
partition_free(disk_desc->partitions[part_num]);
}
free(disk_desc);
3e10: e1a00006 mov r0, r6 <== NOT EXECUTED
*/
void
rtems_ide_part_table_free(rtems_disk_desc_t *disk_desc)
{
partition_table_free( disk_desc );
}
3e14: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED
part_num++)
{
partition_free(disk_desc->partitions[part_num]);
}
free(disk_desc);
3e18: ea0002c1 b 4924 <free> <== NOT EXECUTED
00003e1c <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 );
3e1c: eaffff88 b 3c44 <partition_table_get> <== NOT EXECUTED
00003e20 <rtems_ide_part_table_initialize>:
* RTEMS_NO_MEMOTY if cannot have not enough memory,
* RTEMS_INTERNAL_ERROR if other error occurs.
*/
rtems_status_code
rtems_ide_part_table_initialize(const char *dev_name)
{
3e20: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_part_desc_t *part_desc;
/* logical device name /dev/hdxyy */
char name[RTEMS_IDE_PARTITION_DEV_NAME_LENGTH_MAX];
disk_desc = (rtems_disk_desc_t *) calloc(1, sizeof(rtems_disk_desc_t));
3e24: e3a01f49 mov r1, #292 ; 0x124
* RTEMS_NO_MEMOTY if cannot have not enough memory,
* RTEMS_INTERNAL_ERROR if other error occurs.
*/
rtems_status_code
rtems_ide_part_table_initialize(const char *dev_name)
{
3e28: e24dd02c sub sp, sp, #44 ; 0x2c
3e2c: e1a08000 mov r8, r0
rtems_part_desc_t *part_desc;
/* logical device name /dev/hdxyy */
char name[RTEMS_IDE_PARTITION_DEV_NAME_LENGTH_MAX];
disk_desc = (rtems_disk_desc_t *) calloc(1, sizeof(rtems_disk_desc_t));
3e30: e3a00001 mov r0, #1
3e34: eb0001ff bl 4638 <calloc>
if (disk_desc == NULL)
3e38: e2505000 subs r5, r0, #0
{
return RTEMS_NO_MEMORY;
3e3c: 03a0b01a moveq fp, #26
3e40: 058db014 streq fp, [sp, #20]
/* logical device name /dev/hdxyy */
char name[RTEMS_IDE_PARTITION_DEV_NAME_LENGTH_MAX];
disk_desc = (rtems_disk_desc_t *) calloc(1, sizeof(rtems_disk_desc_t));
if (disk_desc == NULL)
3e44: 0a00003d beq 3f40 <rtems_ide_part_table_initialize+0x120>
{
return RTEMS_NO_MEMORY;
}
/* get partition table */
rc = partition_table_get(dev_name, disk_desc);
3e48: e1a00008 mov r0, r8
3e4c: e1a01005 mov r1, r5
3e50: ebffff7b bl 3c44 <partition_table_get>
if (rc != RTEMS_SUCCESSFUL)
3e54: e3500000 cmp r0, #0
3e58: e58d0014 str r0, [sp, #20]
3e5c: 1a000035 bne 3f38 <rtems_ide_part_table_initialize+0x118>
* RTEMS_SUCCESSFUL if success,
* RTEMS_NO_MEMOTY if cannot have not enough memory,
* RTEMS_INTERNAL_ERROR if other error occurs.
*/
rtems_status_code
rtems_ide_part_table_initialize(const char *dev_name)
3e60: e285c024 add ip, r5, #36 ; 0x24
3e64: e58dc018 str ip, [sp, #24]
/* To avoid device numbers conflicts we have to use for logic disk the same
* device major number as ATA device has, and minor number that equals to
* sum of logic disk partition number and the minor number of physical disk
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
3e68: e595a000 ldr sl, [r5]
3e6c: e5959004 ldr r9, [r5, #4]
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
3e70: e59d4014 ldr r4, [sp, #20]
3e74: e1a0600c mov r6, ip
{
sprintf(name, "%s%d", dev_name, part_num + 1);
3e78: e28d701c add r7, sp, #28
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
3e7c: e5953024 ldr r3, [r5, #36] ; 0x24
3e80: e1540003 cmp r4, r3
{
sprintf(name, "%s%d", dev_name, part_num + 1);
3e84: e2844001 add r4, r4, #1
3e88: e59f10bc ldr r1, [pc, #188] ; 3f4c <rtems_ide_part_table_initialize+0x12c>
3e8c: e1a02008 mov r2, r8
3e90: e1a00007 mov r0, r7
3e94: e1a03004 mov r3, r4
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
3e98: aa000020 bge 3f20 <rtems_ide_part_table_initialize+0x100>
{
sprintf(name, "%s%d", dev_name, part_num + 1);
3e9c: eb004045 bl 13fb8 <sprintf>
dev = rtems_filesystem_make_dev_t(major, ++minor);
part_desc = disk_desc->partitions[part_num];
3ea0: e5b63004 ldr r3, [r6, #4]!
if (part_desc == NULL)
3ea4: e3530000 cmp r3, #0
{
continue;
}
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
3ea8: e1a0000a mov r0, sl
* RTEMS_SUCCESSFUL if success, * RTEMS_NO_MEMOTY if cannot have not enough memory, * RTEMS_INTERNAL_ERROR if other error occurs. */ rtems_status_code rtems_ide_part_table_initialize(const char *dev_name)
3eac: e0841009 add r1, r4, r9
{
sprintf(name, "%s%d", dev_name, part_num + 1);
dev = rtems_filesystem_make_dev_t(major, ++minor);
part_desc = disk_desc->partitions[part_num];
if (part_desc == NULL)
3eb0: 0afffff1 beq 3e7c <rtems_ide_part_table_initialize+0x5c>
{
continue;
}
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
3eb4: e5932004 ldr r2, [r3, #4]
3eb8: e8951800 ldm r5, {fp, ip}
3ebc: e58d2000 str r2, [sp]
3ec0: e58db00c str fp, [sp, #12]
3ec4: e58dc010 str ip, [sp, #16]
3ec8: e593c008 ldr ip, [r3, #8]
3ecc: e28d300c add r3, sp, #12
3ed0: e893000c ldm r3, {r2, r3}
3ed4: e58dc004 str ip, [sp, #4]
3ed8: e58d7008 str r7, [sp, #8]
3edc: ebfffd74 bl 34b4 <rtems_disk_create_log>
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
3ee0: e2503000 subs r3, r0, #0
3ee4: 0affffe4 beq 3e7c <rtems_ide_part_table_initialize+0x5c>
{
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
3ee8: e59fc060 ldr ip, [pc, #96] ; 3f50 <rtems_ide_part_table_initialize+0x130><== NOT EXECUTED
3eec: e59c2000 ldr r2, [ip] <== NOT EXECUTED
3ef0: e59f105c ldr r1, [pc, #92] ; 3f54 <rtems_ide_part_table_initialize+0x134><== NOT EXECUTED
3ef4: e5920008 ldr r0, [r2, #8] <== NOT EXECUTED
3ef8: e1a02007 mov r2, r7 <== NOT EXECUTED
3efc: eb003ddb bl 13670 <fprintf> <== NOT EXECUTED
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
3f00: e5953024 ldr r3, [r5, #36] ; 0x24 <== NOT EXECUTED
3f04: e1540003 cmp r4, r3 <== NOT EXECUTED
{
sprintf(name, "%s%d", dev_name, part_num + 1);
3f08: e2844001 add r4, r4, #1 <== NOT EXECUTED
3f0c: e59f1038 ldr r1, [pc, #56] ; 3f4c <rtems_ide_part_table_initialize+0x12c><== NOT EXECUTED
3f10: e1a02008 mov r2, r8 <== NOT EXECUTED
3f14: e1a00007 mov r0, r7 <== NOT EXECUTED
3f18: e1a03004 mov r3, r4 <== NOT EXECUTED
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
3f1c: baffffde blt 3e9c <rtems_ide_part_table_initialize+0x7c> <== NOT EXECUTED
3f20: e59d6018 ldr r6, [sp, #24]
3f24: e3a04004 mov r4, #4
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
partition_free(disk_desc->partitions[part_num]);
3f28: e5b60004 ldr r0, [r6, #4]!
3f2c: ebfffe8b bl 3960 <partition_free>
static void
partition_table_free(rtems_disk_desc_t *disk_desc)
{
int part_num;
for (part_num = 0;
3f30: e2544001 subs r4, r4, #1
3f34: 1afffffb bne 3f28 <rtems_ide_part_table_initialize+0x108>
part_num++)
{
partition_free(disk_desc->partitions[part_num]);
}
free(disk_desc);
3f38: e1a00005 mov r0, r5
3f3c: eb000278 bl 4924 <free>
}
partition_table_free(disk_desc);
return RTEMS_SUCCESSFUL;
}
3f40: e59d0014 ldr r0, [sp, #20]
3f44: e28dd02c add sp, sp, #44 ; 0x2c
3f48: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000264c <rtems_libio_init>:
rtems_id rtems_libio_semaphore;
rtems_libio_t *rtems_libio_iops;
rtems_libio_t *rtems_libio_iop_freelist;
void rtems_libio_init( void )
{
264c: e92d4010 push {r4, lr}
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
2650: e59f30b4 ldr r3, [pc, #180] ; 270c <rtems_libio_init+0xc0>
2654: e5934000 ldr r4, [r3]
2658: e3540000 cmp r4, #0
rtems_id rtems_libio_semaphore;
rtems_libio_t *rtems_libio_iops;
rtems_libio_t *rtems_libio_iop_freelist;
void rtems_libio_init( void )
{
265c: e24dd004 sub sp, sp, #4
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
2660: 0a000016 beq 26c0 <rtems_libio_init+0x74>
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
2664: e1a00004 mov r0, r4
2668: e3a01030 mov r1, #48 ; 0x30
266c: ebffff0b bl 22a0 <calloc>
2670: e59f3098 ldr r3, [pc, #152] ; 2710 <rtems_libio_init+0xc4>
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
2674: e3500000 cmp r0, #0
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
2678: e5830000 str r0, [r3]
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
267c: 0a000020 beq 2704 <rtems_libio_init+0xb8>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
2680: e59f308c ldr r3, [pc, #140] ; 2714 <rtems_libio_init+0xc8>
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
2684: e3540001 cmp r4, #1
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
2688: e5830000 str r0, [r3]
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
268c: 9a000009 bls 26b8 <rtems_libio_init+0x6c>
2690: e1a03000 mov r3, r0
2694: e3a02001 mov r2, #1
iop->data1 = iop + 1;
2698: e2822001 add r2, r2, #1
269c: e2833030 add r3, r3, #48 ; 0x30
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
26a0: e1520004 cmp r2, r4
iop->data1 = iop + 1;
26a4: e5033004 str r3, [r3, #-4]
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
26a8: 1afffffa bne 2698 <rtems_libio_init+0x4c>
rtems_id rtems_libio_semaphore;
rtems_libio_t *rtems_libio_iops;
rtems_libio_t *rtems_libio_iop_freelist;
void rtems_libio_init( void )
26ac: e2422001 sub r2, r2, #1
26b0: e0822082 add r2, r2, r2, lsl #1
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
26b4: e0800202 add r0, r0, r2, lsl #4
iop->data1 = iop + 1;
iop->data1 = NULL;
26b8: e3a03000 mov r3, #0
26bc: e580302c str r3, [r0, #44] ; 0x2c
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
26c0: e59fc050 ldr ip, [pc, #80] ; 2718 <rtems_libio_init+0xcc>
26c4: e59f0050 ldr r0, [pc, #80] ; 271c <rtems_libio_init+0xd0>
26c8: e3a01001 mov r1, #1
26cc: e3a02054 mov r2, #84 ; 0x54
26d0: e3a03000 mov r3, #0
26d4: e58dc000 str ip, [sp]
26d8: eb000f2c bl 6390 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
26dc: e3500000 cmp r0, #0
26e0: 1a000006 bne 2700 <rtems_libio_init+0xb4>
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
26e4: e59f3034 ldr r3, [pc, #52] ; 2720 <rtems_libio_init+0xd4>
26e8: e5933000 ldr r3, [r3]
26ec: e3530000 cmp r3, #0
(* rtems_fs_init_helper)();
26f0: 11a0e00f movne lr, pc
26f4: 112fff13 bxne r3
}
26f8: e28dd004 add sp, sp, #4
26fc: e8bd8010 pop {r4, pc}
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
rtems_fatal_error_occurred( rc );
2700: eb001195 bl 6d5c <rtems_fatal_error_occurred> <== NOT EXECUTED
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
2704: e3a0001a mov r0, #26
2708: eb001193 bl 6d5c <rtems_fatal_error_occurred>
00003c5c <rtems_libio_share_private_env>:
return sc;
}
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
3c5c: e92d4030 push {r4, r5, lr}
3c60: e24dd004 sub sp, sp, #4
3c64: e1a05000 mov r5, r0
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_id self_task_id = rtems_task_self();
3c68: eb0005d3 bl 53bc <rtems_task_self>
if (task_id != RTEMS_SELF && self_task_id != task_id) {
3c6c: e1500005 cmp r0, r5
3c70: 13550000 cmpne r5, #0
3c74: 03a00000 moveq r0, #0
3c78: 13a00001 movne r0, #1
return sc;
}
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
3c7c: 01a05000 moveq r5, r0
rtems_id self_task_id = rtems_task_self();
if (task_id != RTEMS_SELF && self_task_id != task_id) {
3c80: 1a000002 bne 3c90 <rtems_libio_share_private_env+0x34>
}
}
}
return sc;
}
3c84: e1a00005 mov r0, r5
3c88: e28dd004 add sp, sp, #4
3c8c: e8bd8030 pop {r4, r5, pc}
*
* 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;
3c90: e59f3080 ldr r3, [pc, #128] ; 3d18 <rtems_libio_share_private_env+0xbc>
3c94: e5932000 ldr r2, [r3]
++level;
3c98: e2822001 add r2, r2, #1
_Thread_Dispatch_disable_level = level;
3c9c: 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(
3ca0: e59f4074 ldr r4, [pc, #116] ; 3d1c <rtems_libio_share_private_env+0xc0>
3ca4: e1a00005 mov r0, r5
3ca8: e1a01004 mov r1, r4
3cac: e1a0200d mov r2, sp
3cb0: eb000634 bl 5588 <rtems_task_variable_get>
task_id,
(void *) &rtems_current_user_env,
(void *) &env
);
if (sc == RTEMS_SUCCESSFUL) {
3cb4: e2505000 subs r5, r0, #0
3cb8: 1a00000e bne 3cf8 <rtems_libio_share_private_env+0x9c>
++env->reference_count;
3cbc: e59d3000 ldr r3, [sp]
3cc0: e5932028 ldr r2, [r3, #40] ; 0x28
3cc4: e2822001 add r2, r2, #1
3cc8: e5832028 str r2, [r3, #40] ; 0x28
} else {
sc = RTEMS_UNSATISFIED;
}
_Thread_Enable_dispatch();
3ccc: eb000de8 bl 7474 <_Thread_Enable_dispatch>
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_task_variable_add(
3cd0: e1a00005 mov r0, r5
3cd4: e1a01004 mov r1, r4
3cd8: e59f2040 ldr r2, [pc, #64] ; 3d20 <rtems_libio_share_private_env+0xc4>
3cdc: eb0005d5 bl 5438 <rtems_task_variable_add>
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
3ce0: e2505000 subs r5, r0, #0
3ce4: 0a000006 beq 3d04 <rtems_libio_share_private_env+0xa8>
free_user_env_protected(rtems_current_user_env);
rtems_current_user_env = env;
} else {
free_user_env_protected(env);
3ce8: e59d0000 ldr r0, [sp] <== NOT EXECUTED
3cec: ebffff8e bl 3b2c <free_user_env_protected> <== NOT EXECUTED
sc = RTEMS_TOO_MANY;
3cf0: e3a05005 mov r5, #5 <== NOT EXECUTED
3cf4: eaffffe2 b 3c84 <rtems_libio_share_private_env+0x28> <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL) {
++env->reference_count;
} else {
sc = RTEMS_UNSATISFIED;
}
_Thread_Enable_dispatch();
3cf8: eb000ddd bl 7474 <_Thread_Enable_dispatch>
(void *) &env
);
if (sc == RTEMS_SUCCESSFUL) {
++env->reference_count;
} else {
sc = RTEMS_UNSATISFIED;
3cfc: e3a0500d mov r5, #13
3d00: eaffffdf b 3c84 <rtems_libio_share_private_env+0x28>
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
free_user_env_protected(rtems_current_user_env);
3d04: e5940000 ldr r0, [r4]
3d08: ebffff87 bl 3b2c <free_user_env_protected>
rtems_current_user_env = env;
3d0c: e59d3000 ldr r3, [sp]
3d10: e5843000 str r3, [r4]
3d14: eaffffda b 3c84 <rtems_libio_share_private_env+0x28>
0000acf4 <rtems_libio_to_fcntl_flags>:
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
acf4: e2002006 and r2, r0, #6
acf8: e3520006 cmp r2, #6
return flags;
}
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
acfc: e1a03000 mov r3, r0
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
ad00: 03a00002 moveq r0, #2
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
ad04: 0a000002 beq ad14 <rtems_libio_to_fcntl_flags+0x20>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
ad08: e3130002 tst r3, #2
fcntl_flags |= O_RDONLY;
ad0c: 13a00000 movne r0, #0
{
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
ad10: 0a000006 beq ad30 <rtems_libio_to_fcntl_flags+0x3c>
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
ad14: e3130001 tst r3, #1
fcntl_flags |= O_NONBLOCK;
ad18: 13800901 orrne r0, r0, #16384 ; 0x4000
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
ad1c: e3130c02 tst r3, #512 ; 0x200
fcntl_flags |= O_APPEND;
ad20: 13800008 orrne r0, r0, #8
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
ad24: e3130b01 tst r3, #1024 ; 0x400
fcntl_flags |= O_CREAT;
ad28: 13800c02 orrne r0, r0, #512 ; 0x200
}
return fcntl_flags;
}
ad2c: e12fff1e bx lr
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
ad30: e3130004 tst r3, #4 <== NOT EXECUTED
ad34: 03a00000 moveq r0, #0 <== NOT EXECUTED
ad38: 13a00001 movne r0, #1 <== NOT EXECUTED
ad3c: eafffff4 b ad14 <rtems_libio_to_fcntl_flags+0x20> <== NOT EXECUTED
00003d24 <rtems_libio_use_global_env>:
return sc;
}
void rtems_libio_use_global_env(void)
{
3d24: 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) {
3d28: e59f402c ldr r4, [pc, #44] ; 3d5c <rtems_libio_use_global_env+0x38>
3d2c: e59f502c ldr r5, [pc, #44] ; 3d60 <rtems_libio_use_global_env+0x3c>
3d30: e5943000 ldr r3, [r4]
3d34: e1530005 cmp r3, r5
3d38: 08bd8030 popeq {r4, r5, pc}
sc = rtems_task_variable_delete(
3d3c: e3a00000 mov r0, #0
3d40: e1a01004 mov r1, r4
3d44: eb0005e8 bl 54ec <rtems_task_variable_delete>
RTEMS_SELF,
(void **) &rtems_current_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
3d48: e3500000 cmp r0, #0
rtems_fatal_error_occurred(0xdeadbeef);
}
rtems_current_user_env = &rtems_global_user_env;
3d4c: 05845000 streq r5, [r4]
if (uses_private_env) {
sc = rtems_task_variable_delete(
RTEMS_SELF,
(void **) &rtems_current_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
3d50: 08bd8030 popeq {r4, r5, pc}
rtems_fatal_error_occurred(0xdeadbeef);
3d54: e59f0008 ldr r0, [pc, #8] ; 3d64 <rtems_libio_use_global_env+0x40><== NOT EXECUTED
3d58: eb000690 bl 57a0 <rtems_fatal_error_occurred> <== NOT EXECUTED
000077a4 <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
77a4: e92d45f0 push {r4, r5, r6, r7, r8, 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;
77a8: e5906030 ldr r6, [r0, #48] ; 0x30
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
77ac: e1a05001 mov r5, r1
77b0: e1a04000 mov r4, r0
#include <stdlib.h>
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
77b4: e1a00001 mov r0, r1
77b8: e1a01006 mov r1, r6
77bc: eb00411f bl 17c40 <__umodsi3>
if (excess > 0) {
77c0: e3500000 cmp r0, #0
77c4: 01a06005 moveq r6, r5
77c8: 03a03001 moveq r3, #1
77cc: 0a000004 beq 77e4 <rtems_rbheap_allocate+0x40>
value += alignment - excess;
77d0: e0856006 add r6, r5, r6 <== NOT EXECUTED
77d4: e0606006 rsb r6, r0, r6 <== NOT EXECUTED
77d8: e1550006 cmp r5, r6 <== NOT EXECUTED
77dc: 83a03000 movhi r3, #0 <== NOT EXECUTED
77e0: 93a03001 movls r3, #1 <== NOT EXECUTED
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) {
77e4: e3550000 cmp r5, #0
77e8: 03a05000 moveq r5, #0
77ec: 12035001 andne r5, r3, #1
77f0: e3550000 cmp r5, #0
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
77f4: 01a00005 moveq r0, 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) {
77f8: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
77fc: e1a02004 mov r2, r4
7800: e4927004 ldr r7, [r2], #4
{
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) {
7804: e1570002 cmp r7, r2
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
7808: 03a00000 moveq r0, #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) {
780c: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current;
if (free_chunk->size >= size) {
7810: e597801c ldr r8, [r7, #28]
7814: e1560008 cmp r6, r8
7818: 8a00001a bhi 7888 <rtems_rbheap_allocate+0xe4>
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) {
781c: e3570000 cmp r7, #0
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
7820: 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) {
7824: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
uintptr_t free_size = free_chunk->size;
if (free_size > aligned_size) {
7828: e1580006 cmp r8, r6
782c: 9a00001c bls 78a4 <rtems_rbheap_allocate+0x100>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
7830: e1a0a004 mov sl, r4
7834: 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 );
7838: e2843010 add r3, r4, #16
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
783c: e1550003 cmp r5, r3
7840: 0a00001f beq 78c4 <rtems_rbheap_allocate+0x120>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
7844: e5953000 ldr r3, [r5]
head->next = new_first;
7848: e584300c str r3, [r4, #12]
new_first->previous = head;
784c: e583a004 str sl, [r3, #4]
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;
7850: e5972018 ldr r2, [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;
7854: e0668008 rsb r8, r6, r8
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
7858: e3a03000 mov r3, #0
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
785c: e0882002 add r2, r8, r2
7860: e1a01005 mov r1, r5
rtems_rbheap_chunk *new_chunk = get_chunk(control);
if (new_chunk != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
7864: e587801c str r8, [r7, #28]
new_chunk->begin = free_chunk->begin + new_free_size;
7868: e5852018 str r2, [r5, #24]
new_chunk->size = aligned_size;
786c: e585601c str r6, [r5, #28]
7870: e5853004 str r3, [r5, #4]
7874: 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);
7878: e2840018 add r0, r4, #24
787c: eb0006a7 bl 9320 <_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;
7880: e5950018 ldr r0, [r5, #24]
7884: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
7888: e5977000 ldr r7, [r7]
{
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) {
788c: e0523007 subs r3, r2, r7
7890: 13a03001 movne r3, #1
7894: e3530000 cmp r3, #0
7898: 1affffdc bne 7810 <rtems_rbheap_allocate+0x6c>
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
789c: e1a00003 mov r0, r3
78a0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
78a4: e8970006 ldm r7, {r1, r2}
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
78a8: e3a03000 mov r3, #0
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
78ac: e5812004 str r2, [r1, #4]
previous->next = next;
78b0: e5821000 str r1, [r2]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
78b4: e5873004 str r3, [r7, #4]
78b8: e5873000 str r3, [r7]
ptr = (void *) new_chunk->begin;
}
} else {
rtems_chain_extract_unprotected(&free_chunk->chain_node);
rtems_chain_set_off_chain(&free_chunk->chain_node);
ptr = (void *) free_chunk->begin;
78bc: e5970018 ldr r0, [r7, #24]
78c0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
{
rtems_chain_control *chain = &control->spare_descriptor_chain;
rtems_chain_node *chunk = rtems_chain_get_unprotected(chain);
if (chunk == NULL) {
(*control->extend_descriptors)(control);
78c4: e1a00004 mov r0, r4 <== NOT EXECUTED
78c8: e1a0e00f mov lr, pc <== NOT EXECUTED
78cc: 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;
78d0: 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))
78d4: e1550003 cmp r5, r3 <== NOT EXECUTED
78d8: 0a000004 beq 78f0 <rtems_rbheap_allocate+0x14c> <== 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;
78dc: e5932000 ldr r2, [r3] <== NOT EXECUTED
head->next = new_first;
new_first->previous = head;
78e0: e1a05003 mov r5, r3 <== 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;
78e4: e584200c str r2, [r4, #12] <== NOT EXECUTED
new_first->previous = head;
78e8: e582a004 str sl, [r2, #4] <== NOT EXECUTED
78ec: eaffffd7 b 7850 <rtems_rbheap_allocate+0xac> <== NOT EXECUTED
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
78f0: e3a00000 mov r0, #0 <== NOT EXECUTED
}
}
}
return ptr;
}
78f4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
00007a6c <rtems_rbheap_extend_descriptors_with_malloc>:
void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control)
{
7a6c: e92d4010 push {r4, lr} <== NOT EXECUTED
7a70: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
7a74: e3a00020 mov r0, #32 <== NOT EXECUTED
7a78: ebffed70 bl 3040 <malloc> <== NOT EXECUTED
if (chunk != NULL) {
7a7c: e3500000 cmp r0, #0 <== NOT EXECUTED
7a80: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
7a84: e594300c ldr r3, [r4, #12] <== 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);
7a88: e284200c add r2, r4, #12 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
7a8c: e5802004 str r2, [r0, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
7a90: e584000c str r0, [r4, #12] <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
7a94: 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;
7a98: e5803000 str r3, [r0] <== NOT EXECUTED
7a9c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
000188e4 <rtems_rfs_bitmap_map_clear_all>:
}
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
188e4: e92d4070 push {r4, r5, r6, lr}
188e8: e24dd004 sub sp, sp, #4
rtems_rfs_bitmap_bit last_search_bit;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
188ec: e1a0100d mov r1, sp
return 0;
}
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
188f0: 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);
188f4: ebfffeb1 bl 183c0 <rtems_rfs_bitmap_load_map>
if (rc > 0)
188f8: e3500000 cmp r0, #0
188fc: da000001 ble 18908 <rtems_rfs_bitmap_map_clear_all+0x24>
rtems_rfs_bitmap_mask (last_search_bit));
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
}
18900: e28dd004 add sp, sp, #4
18904: e8bd8070 pop {r4, r5, r6, pc}
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
18908: e594600c ldr r6, [r4, #12] 1890c: e2466001 sub r6, r6, #1 18910: e1a062a6 lsr r6, r6, #5 18914: e2861001 add r1, r6, #1
control->free = elements;
for (e = 0; e < elements; e++)
18918: e3a02000 mov r2, #0
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
1891c: e5841010 str r1, [r4, #16] 18920: e59dc000 ldr ip, [sp]
for (e = 0; e < elements; e++)
18924: e1a03002 mov r3, r2
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
18928: e3e00000 mvn r0, #0
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
1892c: e2833001 add r3, r3, #1 18930: e1510003 cmp r1, r3
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
18934: e78c0102 str r0, [ip, r2, lsl #2] 18938: e3e05000 mvn r5, #0
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
1893c: e1a02003 mov r2, r3
18940: 8afffff9 bhi 1892c <rtems_rfs_bitmap_map_clear_all+0x48>
* Set the un-mapped bits in the last search element so the available logic
* works.
*/
last_search_bit = rtems_rfs_bitmap_map_offset (elements);
if (last_search_bit == 0)
18944: e211101f ands r1, r1, #31 18948: 12611020 rsbne r1, r1, #32 1894c: 11a05135 lsrne r5, r5, r1
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
18950: e1b012a6 lsrs r1, r6, #5 18954: 05940014 ldreq r0, [r4, #20]
18958: 0a000008 beq 18980 <rtems_rfs_bitmap_map_clear_all+0x9c>
1895c: e3a02000 mov r2, #0 <== NOT EXECUTED 18960: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED 18964: e1a03002 mov r3, r2 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
18968: e3e0c000 mvn ip, #0 <== NOT EXECUTED
if (last_search_bit == 0)
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
1896c: e2833001 add r3, r3, #1 <== NOT EXECUTED 18970: e1530001 cmp r3, r1 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
18974: e780c102 str ip, [r0, r2, lsl #2] <== NOT EXECUTED
if (last_search_bit == 0)
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
18978: e1a02003 mov r2, r3 <== NOT EXECUTED 1897c: 1afffffa bne 1896c <rtems_rfs_bitmap_map_clear_all+0x88> <== NOT EXECUTED
control->search_bits[elements - 1] =
rtems_rfs_bitmap_merge (RTEMS_RFS_BITMAP_ELEMENT_CLEAR,
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask (last_search_bit));
rtems_rfs_buffer_mark_dirty (control->buffer);
18980: e5943000 ldr r3, [r4] 18984: e3a02001 mov r2, #1
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] =
18988: e7805101 str r5, [r0, r1, 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);
1898c: e5c32000 strb r2, [r3]
return 0;
18990: e3a00000 mov r0, #0 18994: eaffffd9 b 18900 <rtems_rfs_bitmap_map_clear_all+0x1c>
000186cc <rtems_rfs_bitmap_map_set>:
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
186cc: e92d4030 push {r4, r5, lr}
186d0: e24dd004 sub sp, sp, #4
186d4: 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);
186d8: e1a0100d mov r1, sp
}
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
186dc: 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);
186e0: ebffff36 bl 183c0 <rtems_rfs_bitmap_load_map>
if (rc > 0)
186e4: e3500000 cmp r0, #0
186e8: da000001 ble 186f4 <rtems_rfs_bitmap_map_set+0x28>
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
control->free--;
rtems_rfs_buffer_mark_dirty (control->buffer);
}
return 0;
}
186ec: e28dd004 add sp, sp, #4
186f0: e8bd8030 pop {r4, r5, pc}
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
186f4: e594300c ldr r3, [r4, #12] 186f8: e1550003 cmp r5, r3
return EINVAL;
186fc: 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)
18700: 2afffff9 bcs 186ec <rtems_rfs_bitmap_map_set+0x20>
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);
18704: e59d1000 ldr r1, [sp]
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
18708: e1a032c5 asr r3, 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);
1870c: e7910103 ldr r0, [r1, r3, 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);
18710: e205c01f and ip, r5, #31
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
18714: e3a02001 mov r2, #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);
18718: e1c00c12 bic r0, r0, r2, lsl ip
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))
1871c: 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;
18720: e594c014 ldr ip, [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);
18724: e7810103 str r0, [r1, r3, 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;
18728: 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))
1872c: 1affffee bne 186ec <rtems_rfs_bitmap_map_set+0x20>
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
18730: 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);
18734: e79c1105 ldr r1, [ip, 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);
18738: e203301f and r3, r3, #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);
1873c: e1c13312 bic r3, r1, r2, lsl r3 <== 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);
18740: e78c3105 str r3, [ip, r5, lsl #2] <== NOT EXECUTED
control->free--;
18744: e5941010 ldr r1, [r4, #16] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
18748: e5943000 ldr r3, [r4] <== NOT EXECUTED
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
control->free--;
1874c: e2411001 sub r1, r1, #1 <== NOT EXECUTED 18750: e5841010 str r1, [r4, #16] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
18754: e5c32000 strb r2, [r3] <== NOT EXECUTED 18758: eaffffe3 b 186ec <rtems_rfs_bitmap_map_set+0x20> <== NOT EXECUTED
0001869c <rtems_rfs_bitmap_mask>:
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);
1869c: e3e03000 mvn r3, #0 <== NOT EXECUTED 186a0: e2600020 rsb r0, r0, #32 <== NOT EXECUTED
return mask; }
186a4: e1a00033 lsr r0, r3, r0 <== NOT EXECUTED 186a8: e12fff1e bx lr <== NOT EXECUTED
000186ac <rtems_rfs_bitmap_mask_section>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
rtems_rfs_bitmap_element mask = 0;
if (end > start)
186ac: e1510000 cmp r1, r0 <== NOT EXECUTED
mask = rtems_rfs_bitmap_mask (end - start) << start;
186b0: 80601001 rsbhi r1, r0, r1 <== 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);
186b4: 82611020 rsbhi r1, r1, #32 <== NOT EXECUTED 186b8: 83e03000 mvnhi r3, #0 <== NOT EXECUTED 186bc: 81a01133 lsrhi r1, r3, r1 <== NOT EXECUTED
}
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
rtems_rfs_bitmap_element mask = 0;
186c0: 93a00000 movls r0, #0 <== NOT EXECUTED
if (end > start)
mask = rtems_rfs_bitmap_mask (end - start) << start;
186c4: 81a00011 lslhi r0, r1, r0 <== NOT EXECUTED
return mask; }
186c8: e12fff1e bx lr <== NOT EXECUTED
00018d8c <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)
{
18d8c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
18d90: e1a04003 mov r4, 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);
18d94: 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)
{
18d98: e1a05000 mov r5, r0 18d9c: e1a06001 mov r6, r1 18da0: e1a07002 mov r7, r2 18da4: e59d8018 ldr r8, [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);
18da8: eb00044d bl 19ee4 <rtems_rfs_buffer_handle_request>
if (rc > 0)
18dac: e3500000 cmp r0, #0
18db0: c8bd81f0 popgt {r4, r5, r6, r7, r8, pc}
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
18db4: e5963008 ldr r3, [r6, #8] 18db8: e593101c ldr r1, [r3, #28] 18dbc: e0812104 add r2, r1, r4, lsl #2 18dc0: e5d23003 ldrb r3, [r2, #3] 18dc4: e7d10104 ldrb r0, [r1, r4, lsl #2] 18dc8: e5d21001 ldrb r1, [r2, #1] 18dcc: e1833c00 orr r3, r3, r0, lsl #24 18dd0: e5d22002 ldrb r2, [r2, #2] 18dd4: e1833801 orr r3, r3, r1, lsl #16 18dd8: e1833402 orr r3, r3, r2, lsl #8
if ((*result + 1) == 0)
*result = 0;
18ddc: e3730001 cmn r3, #1 18de0: 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)
18de4: e5883000 str r3, [r8]
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
18de8: e5952004 ldr r2, [r5, #4] 18dec: e1530002 cmp r3, r2
18df0: 2a000001 bcs 18dfc <rtems_rfs_block_find_indirect+0x70>
18df4: e3a00000 mov r0, #0
*result = 0;
rc = EIO;
}
return 0;
}
18df8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
if ((*result + 1) == 0)
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
18dfc: e3a00a01 mov r0, #4096 ; 0x1000 <== NOT EXECUTED 18e00: e3a01000 mov r1, #0 <== NOT EXECUTED 18e04: ebffe689 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 18e08: e3500000 cmp r0, #0 <== NOT EXECUTED 18e0c: 1a000002 bne 18e1c <rtems_rfs_block_find_indirect+0x90> <== NOT EXECUTED
printf ("rtems-rfs: block-find: invalid block in table:"
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
18e10: e3a00000 mov r0, #0 <== NOT EXECUTED
18e14: e5880000 str r0, [r8] <== NOT EXECUTED
18e18: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
printf ("rtems-rfs: block-find: invalid block in table:"
18e1c: e5981000 ldr r1, [r8] <== NOT EXECUTED 18e20: e1a02007 mov r2, r7 <== NOT EXECUTED 18e24: e1a03004 mov r3, r4 <== NOT EXECUTED 18e28: e59f0004 ldr r0, [pc, #4] ; 18e34 <rtems_rfs_block_find_indirect+0xa8><== NOT EXECUTED 18e2c: eb001d9c bl 204a4 <printf> <== NOT EXECUTED 18e30: eafffff6 b 18e10 <rtems_rfs_block_find_indirect+0x84> <== NOT EXECUTED
00018e98 <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)
{
18e98: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
18e9c: e1a06001 mov r6, r1 <== NOT EXECUTED
18ea0: e1a07002 mov r7, r2 <== NOT EXECUTED
if (pos == 0)
18ea4: e1962007 orrs r2, r6, r7 <== NOT EXECUTED
void
rtems_rfs_block_get_block_size (rtems_rfs_file_system* fs,
rtems_rfs_pos pos,
rtems_rfs_block_size* size)
{
18ea8: e1a04003 mov r4, r3 <== 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;
18eac: 03a03000 moveq r3, #0 <== NOT EXECUTED 18eb0: 05843000 streq r3, [r4] <== NOT EXECUTED
size->offset = 0;
18eb4: 05843004 streq r3, [r4, #4] <== NOT EXECUTED
if (pos == 0)
18eb8: 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;
18ebc: e5905008 ldr r5, [r0, #8] <== NOT EXECUTED 18ec0: e3a03000 mov r3, #0 <== NOT EXECUTED 18ec4: e1a02005 mov r2, r5 <== NOT EXECUTED 18ec8: e1a00001 mov r0, r1 <== NOT EXECUTED 18ecc: e1a01007 mov r1, r7 <== NOT EXECUTED 18ed0: eb00553d bl 2e3cc <__udivdi3> <== NOT EXECUTED 18ed4: e2800001 add r0, r0, #1 <== NOT EXECUTED 18ed8: e5840000 str r0, [r4] <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
18edc: e1a01007 mov r1, r7 <== NOT EXECUTED
18ee0: e1a00006 mov r0, r6 <== NOT EXECUTED
18ee4: e1a02005 mov r2, r5 <== NOT EXECUTED
18ee8: e3a03000 mov r3, #0 <== NOT EXECUTED
18eec: eb00565a bl 2e85c <__umoddi3> <== NOT EXECUTED
18ef0: e5840004 str r0, [r4, #4] <== NOT EXECUTED
18ef4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
0001926c <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)
{
1926c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
19270: e1a06003 mov r6, r3
int rc = 0;
*block = 0;
19274: e3a03000 mov r3, #0 19278: e5863000 str r3, [r6]
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
1927c: e5928000 ldr r8, [r2] 19280: 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)
{
19284: e24dd00c sub sp, sp, #12 19288: e1a05002 mov r5, r2 1928c: e1a07000 mov r7, r0 19290: e1a04001 mov r4, r1
*block = 0;
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
19294: e591a008 ldr sl, [r1, #8]
19298: 0a000004 beq 192b0 <rtems_rfs_block_map_find+0x44>
1929c: e35a0000 cmp sl, #0
192a0: 1a000002 bne 192b0 <rtems_rfs_block_map_find+0x44>
return ENXIO;
192a4: e3a00006 mov r0, #6
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
map->bpos.block = *block;
}
return rc;
}
192a8: e28dd00c add sp, sp, #12
192ac: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
*block = 0;
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
192b0: e158000a cmp r8, sl
192b4: 2afffffa bcs 192a4 <rtems_rfs_block_map_find+0x38>
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))
192b8: e5943010 ldr r3, [r4, #16] 192bc: e1580003 cmp r8, r3
192c0: 0a00000d beq 192fc <rtems_rfs_block_map_find+0x90>
/*
* 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)
192c4: e35a0005 cmp sl, #5
192c8: 8a00000f bhi 1930c <rtems_rfs_block_map_find+0xa0>
{
*block = map->blocks[bpos->bno];
192cc: e2888009 add r8, r8, #9 192d0: e7943108 ldr r3, [r4, r8, lsl #2] 192d4: e5863000 str r3, [r6]
}
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
192d8: e895000c ldm r5, {r2, r3}
192dc: e5951008 ldr r1, [r5, #8]
192e0: e5842010 str r2, [r4, #16]
192e4: e5841018 str r1, [r4, #24]
192e8: e5843014 str r3, [r4, #20]
map->bpos.block = *block;
192ec: e5963000 ldr r3, [r6] 192f0: e3a00000 mov r0, #0 192f4: e5843018 str r3, [r4, #24] 192f8: eaffffea b 192a8 <rtems_rfs_block_map_find+0x3c>
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))
192fc: e5943018 ldr r3, [r4, #24] 19300: e3530000 cmp r3, #0
19304: 0affffee beq 192c4 <rtems_rfs_block_map_find+0x58>
19308: eafffff1 b 192d4 <rtems_rfs_block_map_find+0x68>
* 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;
1930c: e5979034 ldr r9, [r7, #52] ; 0x34 19310: e1a00008 mov r0, r8 19314: e1a01009 mov r1, r9 19318: eb004f36 bl 2cff8 <__umodsi3>
singly = bpos->bno / fs->blocks_per_block;
1931c: 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;
19320: e58d0004 str r0, [sp, #4]
singly = bpos->bno / fs->blocks_per_block;
19324: e1a00008 mov r0, r8 19328: ebffa1de bl 1aa8 <__aeabi_uidiv>
if (map->size.count <= fs->block_map_singly_blocks)
1932c: e5973038 ldr r3, [r7, #56] ; 0x38 19330: e153000a cmp r3, sl
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
singly = bpos->bno / fs->blocks_per_block;
19334: e1a0b000 mov fp, r0 19338: e58d0008 str r0, [sp, #8]
if (map->size.count <= fs->block_map_singly_blocks)
1933c: 2a00001c bcs 193b4 <rtems_rfs_block_map_find+0x148>
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
19340: e1a01009 mov r1, r9 <== NOT EXECUTED 19344: eb004f2b bl 2cff8 <__umodsi3> <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
19348: e597303c ldr r3, [r7, #60] ; 0x3c <== NOT EXECUTED 1934c: e153000a cmp r3, sl <== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
19350: e1a08000 mov r8, r0 <== NOT EXECUTED 19354: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
19358: 9affffd1 bls 192a4 <rtems_rfs_block_map_find+0x38> <== NOT EXECUTED
/*
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
1935c: e1a01009 mov r1, r9 <== NOT EXECUTED 19360: e1a0000b mov r0, fp <== NOT EXECUTED 19364: ebffa1cf bl 1aa8 <__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,
19368: e2800009 add r0, r0, #9 <== NOT EXECUTED 1936c: e7942100 ldr r2, [r4, r0, lsl #2] <== NOT EXECUTED 19370: e28dc008 add ip, sp, #8 <== NOT EXECUTED 19374: e2841044 add r1, r4, #68 ; 0x44 <== NOT EXECUTED 19378: e1a00007 mov r0, r7 <== NOT EXECUTED 1937c: e1a03008 mov r3, r8 <== NOT EXECUTED 19380: e58dc000 str ip, [sp] <== NOT EXECUTED 19384: ebfffe80 bl 18d8c <rtems_rfs_block_find_indirect> <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
singly, &singly);
if (rc == 0)
19388: e3500000 cmp r0, #0 <== NOT EXECUTED 1938c: 1affffc5 bne 192a8 <rtems_rfs_block_map_find+0x3c> <== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
19390: e1a00007 mov r0, r7 <== NOT EXECUTED 19394: e2841038 add r1, r4, #56 ; 0x38 <== NOT EXECUTED 19398: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 1939c: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 193a0: e58d6000 str r6, [sp] <== NOT EXECUTED 193a4: ebfffe78 bl 18d8c <rtems_rfs_block_find_indirect> <== NOT EXECUTED
}
}
}
}
if (rc == 0)
193a8: e3500000 cmp r0, #0
193ac: 1affffbd bne 192a8 <rtems_rfs_block_map_find+0x3c>
193b0: eaffffc8 b 192d8 <rtems_rfs_block_map_find+0x6c>
{
/*
* This is a single indirect table of blocks anchored off a slot in the
* inode.
*/
rc = rtems_rfs_block_find_indirect (fs,
193b4: e280b009 add fp, r0, #9 193b8: e794210b ldr r2, [r4, fp, lsl #2] 193bc: e1a00007 mov r0, r7 193c0: e2841038 add r1, r4, #56 ; 0x38 193c4: e59d3004 ldr r3, [sp, #4] 193c8: e58d6000 str r6, [sp] 193cc: ebfffe6e bl 18d8c <rtems_rfs_block_find_indirect> 193d0: eafffff4 b 193a8 <rtems_rfs_block_map_find+0x13c>
00019484 <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)
{
19484: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
19488: e1a06000 mov r6, r0
1948c: e24dd01c sub sp, sp, #28
19490: e1a04001 mov r4, r1
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
19494: e3a00a02 mov r0, #8192 ; 0x2000 19498: 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)
{
1949c: e98d000c stmib sp, {r2, r3}
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
194a0: ebffe4e2 bl 12830 <rtems_rfs_trace> 194a4: e3500000 cmp r0, #0
194a8: 1a0000c7 bne 197cc <rtems_rfs_block_map_grow+0x348>
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))
194ac: e5942008 ldr r2, [r4, #8] 194b0: e59d1004 ldr r1, [sp, #4] 194b4: e596303c ldr r3, [r6, #60] ; 0x3c 194b8: e0812002 add r2, r1, r2 194bc: e1520003 cmp r2, r3
return EFBIG;
194c0: 23a0a01b movcs sl, #27
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))
194c4: 3a000002 bcc 194d4 <rtems_rfs_block_map_grow+0x50>
map->last_data_block = block;
map->dirty = true;
}
return 0;
}
194c8: e1a0000a mov r0, sl
194cc: e28dd01c add sp, sp, #28
194d0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* 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++)
194d4: e3510000 cmp r1, #0
*new_block = block;
map->last_data_block = block;
map->dirty = true;
}
return 0;
194d8: 059da004 ldreq sl, [sp, #4]
/*
* 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++)
194dc: 0afffff9 beq 194c8 <rtems_rfs_block_map_grow+0x44>
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
194e0: e2843044 add r3, r4, #68 ; 0x44 194e4: e58d3010 str r3, [sp, #16]
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
194e8: e2843038 add r3, r4, #56 ; 0x38
/*
* 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++)
194ec: e5941020 ldr r1, [r4, #32]
map->last_map_block = new_block;
return 0;
}
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
194f0: e3a05000 mov r5, #0
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
194f4: e3a08001 mov r8, #1
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
194f8: e58d300c str r3, [sp, #12] 194fc: ea00000f b 19540 <rtems_rfs_block_map_grow+0xbc>
false, &block);
if (rc > 0)
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
map->blocks[map->size.count] = block;
19500: e59d1014 ldr r1, [sp, #20] 19504: e28a3009 add r3, sl, #9 19508: e7841103 str r1, [r4, r3, lsl #2]
}
map->size.count++;
map->size.offset = 0;
if (b == 0)
1950c: e3550000 cmp r5, #0
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
map->size.offset = 0;
19510: e3a03000 mov r3, #0 19514: e584300c str r3, [r4, #12]
if (b == 0)
*new_block = block;
19518: 059d3008 ldreq r3, [sp, #8]
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
1951c: e28aa001 add sl, sl, #1 19520: e584a008 str sl, [r4, #8]
map->size.offset = 0;
if (b == 0)
*new_block = block;
19524: 05831000 streq r1, [r3]
/*
* 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++)
19528: e59d3004 ldr r3, [sp, #4] 1952c: e2855001 add r5, r5, #1 19530: e1550003 cmp r5, r3
map->size.count++;
map->size.offset = 0;
if (b == 0)
*new_block = block;
map->last_data_block = block;
19534: e5841020 str r1, [r4, #32]
map->dirty = true;
19538: e5c48000 strb r8, [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++)
1953c: 0a0000bb beq 19830 <rtems_rfs_block_map_grow+0x3ac>
/*
* 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,
19540: e1a00006 mov r0, r6 19544: e3a02000 mov r2, #0 19548: e28d3014 add r3, sp, #20 1954c: ebffdcfa bl 1093c <rtems_rfs_group_bitmap_alloc>
false, &block);
if (rc > 0)
19550: e3500000 cmp r0, #0
19554: ca0000b3 bgt 19828 <rtems_rfs_block_map_grow+0x3a4>
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
19558: e594a008 ldr sl, [r4, #8] 1955c: e35a0004 cmp sl, #4
19560: 9affffe6 bls 19500 <rtems_rfs_block_map_grow+0x7c>
* 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;
19564: e5969034 ldr r9, [r6, #52] ; 0x34 19568: e1a0000a mov r0, sl 1956c: e1a01009 mov r1, r9 19570: eb004ea0 bl 2cff8 <__umodsi3>
singly = map->size.count / fs->blocks_per_block;
19574: e1a01009 mov r1, r9
* 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;
19578: e1a07000 mov r7, r0
singly = map->size.count / fs->blocks_per_block;
1957c: e1a0000a mov r0, sl 19580: ebffa148 bl 1aa8 <__aeabi_uidiv>
if (map->size.count < fs->block_map_singly_blocks)
19584: e5963038 ldr r3, [r6, #56] ; 0x38 19588: e15a0003 cmp sl, 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;
1958c: e1a0b000 mov fp, r0
if (map->size.count < fs->block_map_singly_blocks)
19590: 2a000029 bcs 1963c <rtems_rfs_block_map_grow+0x1b8>
* 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) ||
19594: e3570000 cmp r7, #0
19598: 0a000002 beq 195a8 <rtems_rfs_block_map_grow+0x124>
1959c: e3570005 cmp r7, #5 195a0: 03500000 cmpeq r0, #0
195a4: 1a000081 bne 197b0 <rtems_rfs_block_map_grow+0x32c>
/*
* 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,
195a8: e24a1005 sub r1, sl, #5 195ac: e271c000 rsbs ip, r1, #0 195b0: e28b3009 add r3, fp, #9 195b4: e0acc001 adc ip, ip, r1 195b8: e1a00006 mov r0, r6 195bc: e1a01004 mov r1, r4 195c0: e59d200c ldr r2, [sp, #12] 195c4: e0843103 add r3, r4, r3, lsl #2 195c8: e58dc000 str ip, [sp] 195cc: ebfffd9a bl 18c3c <rtems_rfs_block_map_indirect_alloc>
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
map->blocks[singly], true);
}
if (rc > 0)
195d0: e3500000 cmp r0, #0
195d4: ca00006f bgt 19798 <rtems_rfs_block_map_grow+0x314>
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
195d8: e5943040 ldr r3, [r4, #64] ; 0x40 195dc: e5dd2017 ldrb r2, [sp, #23] 195e0: e593301c ldr r3, [r3, #28] 195e4: e7c32107 strb r2, [r3, r7, lsl #2] 195e8: e5943040 ldr r3, [r4, #64] ; 0x40 195ec: e593301c ldr r3, [r3, #28] 195f0: e1dd21b6 ldrh r2, [sp, #22] 195f4: e1a07107 lsl r7, r7, #2 195f8: e0833007 add r3, r3, r7 195fc: e5c32001 strb r2, [r3, #1] 19600: e5943040 ldr r3, [r4, #64] ; 0x40 19604: e59d2014 ldr r2, [sp, #20] 19608: e593301c ldr r3, [r3, #28] 1960c: e1a02422 lsr r2, r2, #8 19610: e0833007 add r3, r3, r7 19614: e5c32002 strb r2, [r3, #2] 19618: e5943040 ldr r3, [r4, #64] ; 0x40 1961c: e593301c ldr r3, [r3, #28] 19620: e0837007 add r7, r3, r7 19624: e59d3014 ldr r3, [sp, #20] 19628: e5c73003 strb r3, [r7, #3] 1962c: e59d1014 ldr r1, [sp, #20] 19630: e5c48038 strb r8, [r4, #56] ; 0x38 19634: e594a008 ldr sl, [r4, #8] 19638: eaffffb3 b 1950c <rtems_rfs_block_map_grow+0x88>
* Doubly indirect tables are being used.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
1963c: e1a01009 mov r1, r9 <== NOT EXECUTED 19640: ebffa118 bl 1aa8 <__aeabi_uidiv> <== NOT EXECUTED
singly %= fs->blocks_per_block;
19644: e1a01009 mov r1, r9 <== NOT EXECUTED
* Doubly indirect tables are being used.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
19648: e1a0a000 mov sl, r0 <== NOT EXECUTED
singly %= fs->blocks_per_block;
1964c: e1a0000b mov r0, fp <== NOT EXECUTED 19650: eb004e68 bl 2cff8 <__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)
19654: e3570000 cmp r7, #0 <== NOT EXECUTED
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
19658: e1a09000 mov r9, r0 <== NOT EXECUTED
* Allocate a new block for a singly indirect table if direct is 0 as
* it is the first entry of a new block. We may also need to allocate a
* doubly indirect block as well. Both always occur when direct is 0
* and the doubly indirect block when singly is 0.
*/
if (direct == 0)
1965c: 1a000033 bne 19730 <rtems_rfs_block_map_grow+0x2ac> <== NOT EXECUTED
{
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
19660: e1a00006 mov r0, r6 <== NOT EXECUTED 19664: e1a01004 mov r1, r4 <== NOT EXECUTED 19668: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 1966c: e28d3018 add r3, sp, #24 <== NOT EXECUTED 19670: e58d7000 str r7, [sp] <== NOT EXECUTED 19674: ebfffd70 bl 18c3c <rtems_rfs_block_map_indirect_alloc> <== NOT EXECUTED
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
19678: e3500000 cmp r0, #0 <== NOT EXECUTED 1967c: ca00006d bgt 19838 <rtems_rfs_block_map_grow+0x3b4> <== 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) ||
19680: e3590000 cmp r9, #0 <== NOT EXECUTED 19684: 0a000004 beq 1969c <rtems_rfs_block_map_grow+0x218> <== NOT EXECUTED 19688: e3590005 cmp r9, #5 <== NOT EXECUTED 1968c: 035a0000 cmpeq sl, #0 <== NOT EXECUTED 19690: 13a0b000 movne fp, #0 <== NOT EXECUTED 19694: 03a0b001 moveq fp, #1 <== NOT EXECUTED 19698: 1a000050 bne 197e0 <rtems_rfs_block_map_grow+0x35c> <== 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,
1969c: e594c008 ldr ip, [r4, #8] <== NOT EXECUTED 196a0: e5962038 ldr r2, [r6, #56] ; 0x38 <== NOT EXECUTED 196a4: e062200c rsb r2, r2, ip <== NOT EXECUTED 196a8: e272c000 rsbs ip, r2, #0 <== NOT EXECUTED 196ac: e28a3009 add r3, sl, #9 <== NOT EXECUTED 196b0: e0acc002 adc ip, ip, r2 <== NOT EXECUTED 196b4: e1a00006 mov r0, r6 <== NOT EXECUTED 196b8: e1a01004 mov r1, r4 <== NOT EXECUTED 196bc: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 196c0: e0843103 add r3, r4, r3, lsl #2 <== NOT EXECUTED 196c4: e58dc000 str ip, [sp] <== NOT EXECUTED 196c8: ebfffd5b bl 18c3c <rtems_rfs_block_map_indirect_alloc> <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
upping);
if (rc > 0)
196cc: e3500000 cmp r0, #0 <== NOT EXECUTED 196d0: ca00005e bgt 19850 <rtems_rfs_block_map_grow+0x3cc> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
}
rtems_rfs_block_set_number (&map->doubly_buffer,
196d4: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED 196d8: e5dd201b ldrb r2, [sp, #27] <== NOT EXECUTED 196dc: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 196e0: e7c32109 strb r2, [r3, r9, lsl #2] <== NOT EXECUTED 196e4: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED 196e8: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 196ec: e1dd21ba ldrh r2, [sp, #26] <== NOT EXECUTED 196f0: e1a09109 lsl r9, r9, #2 <== NOT EXECUTED 196f4: e0833009 add r3, r3, r9 <== NOT EXECUTED 196f8: e5c32001 strb r2, [r3, #1] <== NOT EXECUTED 196fc: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED 19700: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 19704: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 19708: e1a02422 lsr r2, r2, #8 <== NOT EXECUTED 1970c: e0833009 add r3, r3, r9 <== NOT EXECUTED 19710: e5c32002 strb r2, [r3, #2] <== NOT EXECUTED 19714: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED 19718: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 1971c: e0839009 add r9, r3, r9 <== NOT EXECUTED 19720: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 19724: e5c93003 strb r3, [r9, #3] <== NOT EXECUTED 19728: e5c48044 strb r8, [r4, #68] ; 0x44 <== NOT EXECUTED 1972c: eaffffa9 b 195d8 <rtems_rfs_block_map_grow+0x154> <== NOT EXECUTED
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
19730: e28aa009 add sl, sl, #9 <== NOT EXECUTED 19734: e1a00006 mov r0, r6 <== NOT EXECUTED 19738: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 1973c: e794210a ldr r2, [r4, sl, lsl #2] <== NOT EXECUTED 19740: e3a03001 mov r3, #1 <== NOT EXECUTED 19744: eb0001e6 bl 19ee4 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
true);
if (rc > 0)
19748: e3500000 cmp r0, #0 <== NOT EXECUTED 1974c: ca000011 bgt 19798 <rtems_rfs_block_map_grow+0x314> <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
19750: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED 19754: e593201c ldr r2, [r3, #28] <== NOT EXECUTED 19758: e0823109 add r3, r2, r9, lsl #2 <== NOT EXECUTED 1975c: e5d31003 ldrb r1, [r3, #3] <== NOT EXECUTED 19760: e7d2c109 ldrb ip, [r2, r9, lsl #2] <== NOT EXECUTED 19764: e5d32001 ldrb r2, [r3, #1] <== NOT EXECUTED 19768: e181cc0c orr ip, r1, ip, lsl #24 <== NOT EXECUTED 1976c: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED 19770: e18cc802 orr ip, ip, r2, lsl #16 <== NOT EXECUTED 19774: e18cc403 orr ip, ip, r3, lsl #8 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
19778: e1a00006 mov r0, r6 <== NOT EXECUTED 1977c: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 19780: e1a0200c mov r2, ip <== NOT EXECUTED 19784: 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,
19788: e58dc018 str ip, [sp, #24] <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
1978c: eb0001d4 bl 19ee4 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
singly_block, true);
if (rc > 0)
19790: e3500000 cmp r0, #0 <== NOT EXECUTED 19794: daffff8f ble 195d8 <rtems_rfs_block_map_grow+0x154> <== NOT EXECUTED 19798: e1a0a000 mov sl, r0 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
1979c: e3a01000 mov r1, #0 <== NOT EXECUTED 197a0: e1a00006 mov r0, r6 <== NOT EXECUTED 197a4: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 197a8: ebffdcea bl 10b58 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
197ac: eaffff45 b 194c8 <rtems_rfs_block_map_grow+0x44> <== NOT EXECUTED
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
197b0: e280b009 add fp, r0, #9 197b4: e59d100c ldr r1, [sp, #12] 197b8: e1a00006 mov r0, r6 197bc: e794210b ldr r2, [r4, fp, lsl #2] 197c0: e3a03001 mov r3, #1 197c4: eb0001c6 bl 19ee4 <rtems_rfs_buffer_handle_request> 197c8: eaffff80 b 195d0 <rtems_rfs_block_map_grow+0x14c>
rtems_rfs_block_no* new_block)
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
197cc: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 197d0: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 197d4: e59f009c ldr r0, [pc, #156] ; 19878 <rtems_rfs_block_map_grow+0x3f4><== NOT EXECUTED 197d8: eb001b31 bl 204a4 <printf> <== NOT EXECUTED 197dc: eaffff32 b 194ac <rtems_rfs_block_map_grow+0x28> <== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
197e0: e28aa009 add sl, sl, #9 <== NOT EXECUTED 197e4: e1a00006 mov r0, r6 <== NOT EXECUTED 197e8: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 197ec: e794210a ldr r2, [r4, sl, lsl #2] <== NOT EXECUTED 197f0: e3a03001 mov r3, #1 <== NOT EXECUTED 197f4: eb0001ba bl 19ee4 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
197f8: e3500000 cmp r0, #0 <== NOT EXECUTED 197fc: daffffb4 ble 196d4 <rtems_rfs_block_map_grow+0x250> <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
19800: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 19804: e1a0100b mov r1, fp <== NOT EXECUTED 19808: e1a0a000 mov sl, r0 <== NOT EXECUTED 1980c: e1a00006 mov r0, r6 <== NOT EXECUTED 19810: ebffdcd0 bl 10b58 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
19814: e1a00006 mov r0, r6 <== NOT EXECUTED 19818: e1a0100b mov r1, fp <== NOT EXECUTED 1981c: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 19820: ebffdccc bl 10b58 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
19824: eaffff27 b 194c8 <rtems_rfs_block_map_grow+0x44> <== NOT EXECUTED
19828: e1a0a000 mov sl, r0 1982c: eaffff25 b 194c8 <rtems_rfs_block_map_grow+0x44>
*new_block = block;
map->last_data_block = block;
map->dirty = true;
}
return 0;
19830: e3a0a000 mov sl, #0 19834: eaffff23 b 194c8 <rtems_rfs_block_map_grow+0x44>
19838: e1a0a000 mov sl, r0 <== NOT EXECUTED
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, block);
1983c: e1a01007 mov r1, r7 <== NOT EXECUTED 19840: e1a00006 mov r0, r6 <== NOT EXECUTED 19844: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 19848: ebffdcc2 bl 10b58 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
1984c: eaffff1d b 194c8 <rtems_rfs_block_map_grow+0x44> <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
upping);
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
19850: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 19854: e1a0a000 mov sl, r0 <== NOT EXECUTED 19858: e3a01000 mov r1, #0 <== NOT EXECUTED 1985c: e1a00006 mov r0, r6 <== NOT EXECUTED 19860: ebffdcbc bl 10b58 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
19864: e1a00006 mov r0, r6 <== NOT EXECUTED 19868: e3a01000 mov r1, #0 <== NOT EXECUTED 1986c: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 19870: ebffdcb8 bl 10b58 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
19874: eaffff13 b 194c8 <rtems_rfs_block_map_grow+0x44> <== NOT EXECUTED
00018c3c <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)
{
18c3c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
18c40: e24dd004 sub sp, sp, #4
18c44: e1a04001 mov r4, r1
18c48: e1a05002 mov r5, r2
18c4c: 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);
18c50: e591101c ldr r1, [r1, #28] 18c54: e3a02000 mov r2, #0 18c58: 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)
{
18c5c: e1a06000 mov r6, r0 18c60: 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);
18c64: ebffdf34 bl 1093c <rtems_rfs_group_bitmap_alloc>
if (rc > 0)
18c68: e250a000 subs sl, r0, #0
18c6c: da000002 ble 18c7c <rtems_rfs_block_map_indirect_alloc+0x40> } rtems_rfs_buffer_mark_dirty (buffer); *block = new_block; map->last_map_block = new_block; return 0; }
18c70: e1a0000a mov r0, sl
18c74: e28dd004 add sp, sp, #4
18c78: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
if (rc > 0)
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
18c7c: e1a00006 mov r0, r6 18c80: e1a01005 mov r1, r5 18c84: e59d2000 ldr r2, [sp] 18c88: e3a03000 mov r3, #0 18c8c: eb000494 bl 19ee4 <rtems_rfs_buffer_handle_request>
if (rc > 0)
18c90: e250a000 subs sl, r0, #0
18c94: da000004 ble 18cac <rtems_rfs_block_map_indirect_alloc+0x70>
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
18c98: e1a00006 mov r0, r6 <== NOT EXECUTED 18c9c: e3a01000 mov r1, #0 <== NOT EXECUTED 18ca0: e59d2000 ldr r2, [sp] <== NOT EXECUTED 18ca4: ebffdfab bl 10b58 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
18ca8: eafffff0 b 18c70 <rtems_rfs_block_map_indirect_alloc+0x34> <== NOT EXECUTED
} memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
18cac: e5953008 ldr r3, [r5, #8] 18cb0: e3a010ff mov r1, #255 ; 0xff 18cb4: e593001c ldr r0, [r3, #28] 18cb8: e5962008 ldr r2, [r6, #8] 18cbc: eb001d87 bl 202e0 <memset>
if (upping)
18cc0: e3570000 cmp r7, #0
18cc4: 1a000006 bne 18ce4 <rtems_rfs_block_map_indirect_alloc+0xa8>
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
18cc8: e59d3000 ldr r3, [sp]
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
}
rtems_rfs_buffer_mark_dirty (buffer);
18ccc: e3a02001 mov r2, #1 18cd0: e5c52000 strb r2, [r5]
*block = new_block; map->last_map_block = new_block; return 0;
18cd4: e3a0a000 mov sl, #0
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
18cd8: e5883000 str r3, [r8]
map->last_map_block = new_block;
18cdc: e584301c str r3, [r4, #28]
return 0;
18ce0: eaffffe2 b 18c70 <rtems_rfs_block_map_indirect_alloc+0x34>
}
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
if (upping)
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
18ce4: e3a00a02 mov r0, #8192 ; 0x2000 18ce8: e3a01000 mov r1, #0 18cec: ebffe6cf bl 12830 <rtems_rfs_trace> 18cf0: e3500000 cmp r0, #0
18cf4: 1a00001f bne 18d78 <rtems_rfs_block_map_indirect_alloc+0x13c>
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
18cf8: e1a03004 mov r3, r4
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)
{
18cfc: 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]);
18d00: e3a0c001 mov ip, #1 18d04: e5951008 ldr r1, [r5, #8] 18d08: e5d30027 ldrb r0, [r3, #39] ; 0x27 18d0c: e591101c ldr r1, [r1, #28] 18d10: e7c10002 strb r0, [r1, r2] 18d14: e5951008 ldr r1, [r5, #8] 18d18: e591101c ldr r1, [r1, #28] 18d1c: e1d302b6 ldrh r0, [r3, #38] ; 0x26 18d20: e0811002 add r1, r1, r2 18d24: e5c10001 strb r0, [r1, #1] 18d28: e5951008 ldr r1, [r5, #8] 18d2c: e5930024 ldr r0, [r3, #36] ; 0x24 18d30: e591101c ldr r1, [r1, #28] 18d34: e1a00420 lsr r0, r0, #8 18d38: e0811002 add r1, r1, r2 18d3c: e5c10002 strb r0, [r1, #2] 18d40: e5951008 ldr r1, [r5, #8] 18d44: e591101c ldr r1, [r1, #28] 18d48: e5930024 ldr r0, [r3, #36] ; 0x24 18d4c: e0811002 add r1, r1, r2 18d50: 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++)
18d54: e3520014 cmp r2, #20
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
18d58: e5c10003 strb r0, [r1, #3] 18d5c: e2833004 add r3, r3, #4 18d60: e5c5c000 strb ip, [r5]
{
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++)
18d64: 1affffe6 bne 18d04 <rtems_rfs_block_map_indirect_alloc+0xc8>
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
18d68: e2840024 add r0, r4, #36 ; 0x24 18d6c: e3a01000 mov r1, #0 18d70: eb001d5a bl 202e0 <memset> 18d74: eaffffd3 b 18cc8 <rtems_rfs_block_map_indirect_alloc+0x8c>
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
if (upping)
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
18d78: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED 18d7c: e59f0004 ldr r0, [pc, #4] ; 18d88 <rtems_rfs_block_map_indirect_alloc+0x14c><== NOT EXECUTED 18d80: eb001dc7 bl 204a4 <printf> <== NOT EXECUTED 18d84: eaffffdb b 18cf8 <rtems_rfs_block_map_indirect_alloc+0xbc> <== NOT EXECUTED
00018b90 <rtems_rfs_block_map_indirect_shrink>:
rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no indirect,
rtems_rfs_block_no index)
{
18b90: e92d40f0 push {r4, r5, r6, r7, lr}
18b94: e59dc014 ldr ip, [sp, #20]
* block to be freed and the indirect block is now also free, or we have only * one indirect table and we can fit the remaining blocks into the inode, * then either move to the next indirect block or move the remaining blocks * into the inode and free the indirect table's block. */ if ((index == 0) ||
18b98: e35c0000 cmp ip, #0
rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no indirect,
rtems_rfs_block_no index)
{
18b9c: e1a04001 mov r4, r1
* block to be freed and the indirect block is now also free, or we have only * one indirect table and we can fit the remaining blocks into the inode, * then either move to the next indirect block or move the remaining blocks * into the inode and free the indirect table's block. */ if ((index == 0) || 18ba0: 0a00001c beq 18c18 <rtems_rfs_block_map_indirect_shrink+0x88>
18ba4: e35c0005 cmp ip, #5 18ba8: 03530000 cmpeq r3, #0 18bac: 13a0c000 movne ip, #0 18bb0: 03a0c001 moveq ip, #1
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no indirect,
rtems_rfs_block_no index)
{
int rc = 0;
18bb4: 11a0000c movne r0, ip
* block to be freed and the indirect block is now also free, or we have only * one indirect table and we can fit the remaining blocks into the inode, * then either move to the next indirect block or move the remaining blocks * into the inode and free the indirect table's block. */ if ((index == 0) ||
18bb8: 18bd80f0 popne {r4, r5, r6, r7, pc}
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
18bbc: e5923008 ldr r3, [r2, #8] 18bc0: e593301c ldr r3, [r3, #28] 18bc4: e5915024 ldr r5, [r1, #36] ; 0x24
* @param indirect The index index in the inode's block table. * @param index The index in the indirect table of the block. * @return int The error number (errno). No error if 0. */ static int rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system* fs,
18bc8: e2812020 add r2, r1, #32 18bcc: e2837014 add r7, r3, #20
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
map->blocks[b] = rtems_rfs_block_get_number (buffer, b);
18bd0: e5d31001 ldrb r1, [r3, #1] 18bd4: e5d36000 ldrb r6, [r3] 18bd8: e5d3e003 ldrb lr, [r3, #3] 18bdc: e1a01801 lsl r1, r1, #16 18be0: e5d3c002 ldrb ip, [r3, #2] 18be4: e1811c06 orr r1, r1, r6, lsl #24 18be8: e181100e orr r1, r1, lr 18bec: e2833004 add r3, r3, #4 18bf0: e181140c orr r1, r1, ip, lsl #8
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
18bf4: e1530007 cmp r3, r7
map->blocks[b] = rtems_rfs_block_get_number (buffer, b);
18bf8: e5a21004 str r1, [r2, #4]!
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
18bfc: 1afffff3 bne 18bd0 <rtems_rfs_block_map_indirect_shrink+0x40>
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
18c00: e3a01000 mov r1, #0 18c04: e1a02005 mov r2, r5 18c08: ebffdfd2 bl 10b58 <rtems_rfs_group_bitmap_free>
if (rc > 0)
18c0c: e3500000 cmp r0, #0
return rc;
map->last_map_block = block_to_free;
18c10: d584501c strle r5, [r4, #28]
}
return rc;
}
18c14: e8bd80f0 pop {r4, r5, r6, r7, pc}
* into the inode and free the indirect table's block.
*/
if ((index == 0) ||
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
18c18: e2833009 add r3, r3, #9 <== NOT EXECUTED 18c1c: e7915103 ldr r5, [r1, r3, lsl #2] <== NOT EXECUTED
else
{
/*
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
18c20: e781c103 str ip, [r1, r3, lsl #2] <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
18c24: e1a02005 mov r2, r5 <== NOT EXECUTED 18c28: e3a01000 mov r1, #0 <== NOT EXECUTED 18c2c: ebffdfc9 bl 10b58 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
18c30: e3500000 cmp r0, #0 <== NOT EXECUTED
return rc;
map->last_map_block = block_to_free;
18c34: d584501c strle r5, [r4, #28] <== NOT EXECUTED
}
return rc;
}
18c38: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00018f38 <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)
{
18f38: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, 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;
18f3c: e3a05000 mov r5, #0 18f40: e5c25000 strb r5, [r2]
map->inode = NULL;
18f44: e5825004 str r5, [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;
18f48: e5825008 str r5, [r2, #8]
size->offset = 0;
18f4c: e582500c str r5, [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;
18f50: e5825010 str r5, [r2, #16]
bpos->boff = 0;
18f54: e5825014 str r5, [r2, #20]
bpos->block = 0;
18f58: e5825018 str r5, [r2, #24]
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
18f5c: e5c25038 strb r5, [r2, #56] ; 0x38
handle->bnum = 0;
18f60: e582503c str r5, [r2, #60] ; 0x3c
handle->buffer = NULL;
18f64: e5825040 str r5, [r2, #64] ; 0x40
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
18f68: e5c25044 strb r5, [r2, #68] ; 0x44
handle->bnum = 0;
18f6c: e5825048 str r5, [r2, #72] ; 0x48
handle->buffer = NULL;
18f70: e582504c str r5, [r2, #76] ; 0x4c
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* inode,
rtems_rfs_block_map* map)
{
18f74: e1a04002 mov r4, r2 18f78: e1a07000 mov r7, r0 18f7c: e1a06001 mov r6, r1
return rc;
rc = rtems_rfs_buffer_handle_open (fs, &map->doubly_buffer);
if (rc > 0)
return rc;
rc = rtems_rfs_inode_load (fs, inode);
18f80: ebffdfa6 bl 10e20 <rtems_rfs_inode_load>
if (rc > 0)
18f84: e2508000 subs r8, r0, #0
18f88: ca000036 bgt 19068 <rtems_rfs_block_map_open+0x130>
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
18f8c: e596200c ldr r2, [r6, #12] 18f90: e5846004 str r6, [r4, #4]
block_size = rtems_rfs_fs_block_size (fs);
return (((uint64_t) (size->count - 1)) * block_size) + offset;
}
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
18f94: e284c020 add ip, r4, #32 18f98: e3a03001 mov r3, #1 18f9c: e282001c add r0, r2, #28
* @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]);
18fa0: e0801003 add r1, r0, r3 18fa4: e2858007 add r8, r5, #7 18fa8: e7d29108 ldrb r9, [r2, r8, lsl #2] 18fac: e5d1a002 ldrb sl, [r1, #2] 18fb0: e7d08003 ldrb r8, [r0, r3] 18fb4: e5d1b001 ldrb fp, [r1, #1] 18fb8: e18a1c09 orr r1, sl, r9, lsl #24 18fbc: e1811808 orr r1, r1, r8, lsl #16
/* * 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++)
18fc0: e2855001 add r5, r5, #1 18fc4: e181140b orr r1, r1, fp, lsl #8 18fc8: e3550005 cmp r5, #5
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
18fcc: e5ac1004 str r1, [ip, #4]!
/* * 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++)
18fd0: e2833004 add r3, r3, #4
18fd4: 1afffff1 bne 18fa0 <rtems_rfs_block_map_open+0x68>
* @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);
18fd8: e5d2300d ldrb r3, [r2, #13] 18fdc: e5d2c00c ldrb ip, [r2, #12] 18fe0: e5d2000f ldrb r0, [r2, #15] 18fe4: e1a03803 lsl r3, r3, #16 18fe8: e5d2100e ldrb r1, [r2, #14] 18fec: e1833c0c orr r3, r3, ip, lsl #24 18ff0: e1833000 orr r3, r3, r0 18ff4: e1833401 orr r3, r3, r1, lsl #8
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
map->size.count = rtems_rfs_inode_get_block_count (inode);
18ff8: e5843008 str r3, [r4, #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);
18ffc: e5d2100a ldrb r1, [r2, #10] 19000: e5d2300b ldrb r3, [r2, #11]
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
19004: e1833401 orr r3, r3, r1, lsl #8 19008: e584300c str r3, [r4, #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);
1900c: e5d23031 ldrb r3, [r2, #49] ; 0x31 19010: e5d2c030 ldrb ip, [r2, #48] ; 0x30 19014: e5d20033 ldrb r0, [r2, #51] ; 0x33 19018: e1a03803 lsl r3, r3, #16 1901c: e5d21032 ldrb r1, [r2, #50] ; 0x32 19020: e1833c0c orr r3, r3, ip, lsl #24 19024: e1833000 orr r3, r3, r0 19028: e1833401 orr r3, r3, r1, lsl #8
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
1902c: e584301c str r3, [r4, #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);
19030: e5d23035 ldrb r3, [r2, #53] ; 0x35 19034: e5d20034 ldrb r0, [r2, #52] ; 0x34 19038: e5d21037 ldrb r1, [r2, #55] ; 0x37 1903c: e1a03803 lsl r3, r3, #16 19040: e5d22036 ldrb r2, [r2, #54] ; 0x36 19044: e1833c00 orr r3, r3, r0, lsl #24 19048: e1833001 orr r3, r3, r1 1904c: e1833402 orr r3, r3, r2, lsl #8
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
rc = rtems_rfs_inode_unload (fs, inode, false);
19050: e1a00007 mov r0, r7 19054: e1a01006 mov r1, r6 19058: 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);
1905c: e5843020 str r3, [r4, #32]
rc = rtems_rfs_inode_unload (fs, inode, false);
return rc;
}
19060: e8bd4ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, 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);
19064: eaffdfd5 b 10fc0 <rtems_rfs_inode_unload>
*/
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);
19068: e2841038 add r1, r4, #56 ; 0x38 <== NOT EXECUTED 1906c: e1a00007 mov r0, r7 <== NOT EXECUTED 19070: eb000322 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
19074: e5c45038 strb r5, [r4, #56] ; 0x38 <== NOT EXECUTED
handle->bnum = 0;
19078: e584503c str r5, [r4, #60] ; 0x3c <== NOT EXECUTED
handle->buffer = NULL;
1907c: e5845040 str r5, [r4, #64] ; 0x40 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
19080: e1a00007 mov r0, r7 <== NOT EXECUTED 19084: e2841044 add r1, r4, #68 ; 0x44 <== NOT EXECUTED 19088: eb00031c bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
1908c: e5c45044 strb r5, [r4, #68] ; 0x44 <== NOT EXECUTED
handle->bnum = 0;
19090: e5845048 str r5, [r4, #72] ; 0x48 <== NOT EXECUTED
handle->buffer = NULL;
19094: e584504c str r5, [r4, #76] ; 0x4c <== NOT EXECUTED
return rc;
}
19098: e1a00008 mov r0, r8 <== NOT EXECUTED
1909c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0001987c <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
1987c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
19880: e1a05000 mov r5, r0
19884: e24dd014 sub sp, sp, #20
19888: e1a04001 mov r4, r1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
1988c: e3a00901 mov r0, #16384 ; 0x4000 19890: e3a01000 mov r1, #0
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
19894: e1a06002 mov r6, r2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
19898: ebffe3e4 bl 12830 <rtems_rfs_trace> 1989c: e3500000 cmp r0, #0
198a0: 1a00008c bne 19ad8 <rtems_rfs_block_map_shrink+0x25c>
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if (map->size.count == 0)
198a4: e5949008 ldr r9, [r4, #8] 198a8: e3590000 cmp r9, #0
return 0;
198ac: 01a00009 moveq r0, r9
{
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)
198b0: 0a000069 beq 19a5c <rtems_rfs_block_map_shrink+0x1e0>
198b4: e1560009 cmp r6, r9 198b8: 21a06009 movcs r6, r9
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
198bc: e3560000 cmp r6, #0
198c0: 0a00008c beq 19af8 <rtems_rfs_block_map_shrink+0x27c>
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,
198c4: e284c044 add ip, r4, #68 ; 0x44 198c8: e58dc010 str ip, [sp, #16]
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
198cc: e284c038 add ip, r4, #56 ; 0x38
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
map->blocks[block] = 0;
198d0: e3a0a000 mov sl, #0
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
198d4: e58dc00c str ip, [sp, #12] 198d8: e1a07006 mov r7, r6 198dc: ea000011 b 19928 <rtems_rfs_block_map_shrink+0xac>
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
198e0: e2899008 add r9, r9, #8 198e4: e7946109 ldr r6, [r4, r9, lsl #2]
map->blocks[block] = 0;
198e8: e784a109 str sl, [r4, r9, lsl #2]
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
198ec: e1a00005 mov r0, r5 198f0: e3a01000 mov r1, #0 198f4: e1a02006 mov r2, r6 198f8: ebffdc96 bl 10b58 <rtems_rfs_group_bitmap_free>
if (rc > 0)
198fc: e3500000 cmp r0, #0
19900: ca000055 bgt 19a5c <rtems_rfs_block_map_shrink+0x1e0>
return rc;
map->size.count--;
19904: e5949008 ldr r9, [r4, #8]
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
19908: e3a03001 mov r3, #1
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->size.count--;
1990c: e2499001 sub r9, r9, #1
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
19910: e2577001 subs r7, r7, #1
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->size.count--;
19914: e5849008 str r9, [r4, #8]
map->size.offset = 0;
19918: e584a00c str sl, [r4, #12]
map->last_data_block = block_to_free;
1991c: e5846020 str r6, [r4, #32]
map->dirty = true;
19920: e5c43000 strb r3, [r4]
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
19924: 0a000070 beq 19aec <rtems_rfs_block_map_shrink+0x270>
{
rtems_rfs_block_no block;
rtems_rfs_block_no block_to_free;
int rc;
block = map->size.count - 1;
19928: e249b001 sub fp, r9, #1
if (block < RTEMS_RFS_INODE_BLOCKS)
1992c: e35b0004 cmp fp, #4
19930: 9affffea bls 198e0 <rtems_rfs_block_map_shrink+0x64>
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
19934: e5956034 ldr r6, [r5, #52] ; 0x34 19938: e1a0000b mov r0, fp 1993c: e1a01006 mov r1, r6 19940: eb004dac bl 2cff8 <__umodsi3>
singly = block / fs->blocks_per_block;
19944: e1a01006 mov r1, r6
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
19948: e1a08000 mov r8, r0
singly = block / fs->blocks_per_block;
1994c: e1a0000b mov r0, fp 19950: ebffa054 bl 1aa8 <__aeabi_uidiv>
if (block < fs->block_map_singly_blocks)
19954: e5953038 ldr r3, [r5, #56] ; 0x38 19958: e15b0003 cmp fp, r3
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
singly = block / fs->blocks_per_block;
1995c: e58d0004 str r0, [sp, #4]
if (block < fs->block_map_singly_blocks)
19960: 3a00003f bcc 19a64 <rtems_rfs_block_map_shrink+0x1e8>
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)
19964: e595303c ldr r3, [r5, #60] ; 0x3c <== NOT EXECUTED 19968: e15b0003 cmp fp, r3 <== NOT EXECUTED 1996c: 2a00005e bcs 19aec <rtems_rfs_block_map_shrink+0x270> <== 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;
19970: e1a01006 mov r1, r6 <== NOT EXECUTED 19974: ebffa04b bl 1aa8 <__aeabi_uidiv> <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
19978: 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;
1997c: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
19980: e7942103 ldr r2, [r4, r3, lsl #2] <== NOT EXECUTED 19984: e1a00005 mov r0, r5 <== NOT EXECUTED 19988: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 1998c: e3a03001 mov r3, #1 <== NOT EXECUTED 19990: eb000153 bl 19ee4 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
19994: e3500000 cmp r0, #0 <== NOT EXECUTED 19998: ca00002f bgt 19a5c <rtems_rfs_block_map_shrink+0x1e0> <== 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;
1999c: e1a01006 mov r1, r6 <== NOT EXECUTED 199a0: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 199a4: eb004d93 bl 2cff8 <__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,
199a8: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED 199ac: e593201c ldr r2, [r3, #28] <== NOT EXECUTED 199b0: e0823100 add r3, r2, r0, lsl #2 <== NOT EXECUTED 199b4: e5d31003 ldrb r1, [r3, #3] <== NOT EXECUTED 199b8: e7d2b100 ldrb fp, [r2, r0, lsl #2] <== NOT EXECUTED 199bc: e5d32001 ldrb r2, [r3, #1] <== NOT EXECUTED 199c0: e181bc0b orr fp, r1, fp, lsl #24 <== NOT EXECUTED 199c4: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED 199c8: e18bb802 orr fp, fp, r2, lsl #16 <== NOT EXECUTED 199cc: e18bb403 orr fp, fp, 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;
199d0: e1a09000 mov r9, 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,
199d4: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 199d8: e1a00005 mov r0, r5 <== NOT EXECUTED 199dc: e1a0200b mov r2, fp <== NOT EXECUTED 199e0: e3a03001 mov r3, #1 <== NOT EXECUTED 199e4: eb00013e bl 19ee4 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
singly, true);
if (rc > 0)
199e8: e3500000 cmp r0, #0 <== NOT EXECUTED 199ec: ca00001a bgt 19a5c <rtems_rfs_block_map_shrink+0x1e0> <== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
199f0: e5943040 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED 199f4: e593201c ldr r2, [r3, #28] <== NOT EXECUTED 199f8: e0823108 add r3, r2, r8, lsl #2 <== NOT EXECUTED 199fc: e5d31003 ldrb r1, [r3, #3] <== NOT EXECUTED 19a00: e7d26108 ldrb r6, [r2, r8, lsl #2] <== NOT EXECUTED 19a04: e5d32001 ldrb r2, [r3, #1] <== NOT EXECUTED 19a08: e1816c06 orr r6, r1, r6, lsl #24 <== NOT EXECUTED 19a0c: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED 19a10: e1866802 orr r6, r6, r2, lsl #16 <== NOT EXECUTED
direct);
if (direct == 0)
19a14: e3580000 cmp r8, #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,
19a18: e1866403 orr r6, r6, r3, lsl #8 <== NOT EXECUTED
direct);
if (direct == 0)
19a1c: 1affffb2 bne 198ec <rtems_rfs_block_map_shrink+0x70> <== NOT EXECUTED
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
19a20: e1a00005 mov r0, r5 <== NOT EXECUTED 19a24: e1a01008 mov r1, r8 <== NOT EXECUTED 19a28: e1a0200b mov r2, fp <== NOT EXECUTED 19a2c: ebffdc49 bl 10b58 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
19a30: e3500000 cmp r0, #0 <== NOT EXECUTED 19a34: ca000008 bgt 19a5c <rtems_rfs_block_map_shrink+0x1e0> <== NOT EXECUTED
return rc;
map->last_map_block = singly;
19a38: e584b01c str fp, [r4, #28] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
19a3c: e1a00005 mov r0, r5 <== NOT EXECUTED 19a40: e1a01004 mov r1, r4 <== NOT EXECUTED 19a44: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 19a48: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 19a4c: e58d9000 str r9, [sp] <== NOT EXECUTED 19a50: ebfffc4e bl 18b90 <rtems_rfs_block_map_indirect_shrink> <== NOT EXECUTED
doubly, doubly_singly);
if (rc)
19a54: e3500000 cmp r0, #0 <== NOT EXECUTED 19a58: 0affffa3 beq 198ec <rtems_rfs_block_map_shrink+0x70> <== NOT EXECUTED
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
return 0;
}
19a5c: e28dd014 add sp, sp, #20
19a60: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
/*
* Request the indirect block and then obtain the block number from the
* indirect block.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
19a64: e2803009 add r3, r0, #9 19a68: e7942103 ldr r2, [r4, r3, lsl #2] 19a6c: e1a00005 mov r0, r5 19a70: e59d100c ldr r1, [sp, #12] 19a74: e3a03001 mov r3, #1 19a78: eb000119 bl 19ee4 <rtems_rfs_buffer_handle_request>
map->blocks[singly], true);
if (rc > 0)
19a7c: e3500000 cmp r0, #0
19a80: cafffff5 bgt 19a5c <rtems_rfs_block_map_shrink+0x1e0>
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
19a84: e5943040 ldr r3, [r4, #64] ; 0x40 19a88: e593c01c ldr ip, [r3, #28] 19a8c: e08ce108 add lr, ip, r8, lsl #2 19a90: e7dc9108 ldrb r9, [ip, r8, lsl #2] 19a94: e5dec002 ldrb ip, [lr, #2]
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
19a98: e59d3004 ldr r3, [sp, #4] 19a9c: e1a00005 mov r0, r5 19aa0: e1a01004 mov r1, r4 19aa4: e59d200c ldr r2, [sp, #12]
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,
19aa8: e5deb001 ldrb fp, [lr, #1] 19aac: e5de6003 ldrb r6, [lr, #3] 19ab0: e58dc004 str ip, [sp, #4]
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
19ab4: e58d8000 str r8, [sp] 19ab8: ebfffc34 bl 18b90 <rtems_rfs_block_map_indirect_shrink>
singly, direct);
if (rc)
19abc: e3500000 cmp r0, #0
19ac0: 1affffe5 bne 19a5c <rtems_rfs_block_map_shrink+0x1e0>
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,
19ac4: e1866c09 orr r6, r6, r9, lsl #24 19ac8: e59dc004 ldr ip, [sp, #4] 19acc: e186680b orr r6, r6, fp, lsl #16 19ad0: e186640c orr r6, r6, ip, lsl #8 19ad4: eaffff84 b 198ec <rtems_rfs_block_map_shrink+0x70>
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
19ad8: e1a01006 mov r1, r6 <== NOT EXECUTED 19adc: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 19ae0: e59f0080 ldr r0, [pc, #128] ; 19b68 <rtems_rfs_block_map_shrink+0x2ec><== NOT EXECUTED 19ae4: eb001a6e bl 204a4 <printf> <== NOT EXECUTED 19ae8: eaffff6d b 198a4 <rtems_rfs_block_map_shrink+0x28> <== NOT EXECUTED
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
19aec: e3590000 cmp r9, #0
{
map->last_map_block = 0;
19af0: 0584901c streq r9, [r4, #28]
map->last_data_block = 0;
19af4: 05849020 streq r9, [r4, #32]
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
19af8: e5943010 ldr r3, [r4, #16] 19afc: e3530000 cmp r3, #0
19b00: 1a000006 bne 19b20 <rtems_rfs_block_map_shrink+0x2a4>
19b04: e1590003 cmp r9, r3
19b08: 9a000006 bls 19b28 <rtems_rfs_block_map_shrink+0x2ac>
19b0c: e2492001 sub r2, r9, #1 19b10: e1530002 cmp r3, r2
19b14: 0a00000d beq 19b50 <rtems_rfs_block_map_shrink+0x2d4>
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
return 0;
19b18: e3a00000 mov r0, #0 <== NOT EXECUTED 19b1c: eaffffce b 19a5c <rtems_rfs_block_map_shrink+0x1e0> <== NOT EXECUTED
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
19b20: e3590000 cmp r9, #0
19b24: 1afffff6 bne 19b04 <rtems_rfs_block_map_shrink+0x288>
19b28: e594300c ldr r3, [r4, #12]
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
19b2c: e3a00000 mov r0, #0 19b30: e1530000 cmp r3, r0 19b34: e5849010 str r9, [r4, #16] 19b38: 12499001 subne r9, r9, #1 19b3c: e5843014 str r3, [r4, #20] 19b40: e5840018 str r0, [r4, #24] 19b44: 15849010 strne r9, [r4, #16]
return 0;
19b48: 01a00003 moveq r0, r3 19b4c: eaffffc2 b 19a5c <rtems_rfs_block_map_shrink+0x1e0>
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
19b50: e594300c ldr r3, [r4, #12] 19b54: e5942014 ldr r2, [r4, #20] 19b58: e1520003 cmp r2, r3
19b5c: 8afffff2 bhi 19b2c <rtems_rfs_block_map_shrink+0x2b0>
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
return 0;
19b60: e3a00000 mov r0, #0 <== NOT EXECUTED 19b64: eaffffbc b 19a5c <rtems_rfs_block_map_shrink+0x1e0> <== NOT EXECUTED
0001f2a8 <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
1f2a8: e92d4030 push {r4, r5, lr}
1f2ac: e1a05001 mov r5, r1
1f2b0: e1a04000 mov r4, r0
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
1f2b4: e3a01000 mov r1, #0 1f2b8: e3a00040 mov r0, #64 ; 0x40 1f2bc: ebffcd5b bl 12830 <rtems_rfs_trace> 1f2c0: e3500000 cmp r0, #0
}
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
1f2c4: e20550ff and r5, r5, #255 ; 0xff
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
1f2c8: 0a000007 beq 1f2ec <rtems_rfs_buffer_bdbuf_release+0x44>
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
1f2cc: e59fc044 ldr ip, [pc, #68] ; 1f318 <rtems_rfs_buffer_bdbuf_release+0x70><== NOT EXECUTED 1f2d0: e3550000 cmp r5, #0 <== NOT EXECUTED 1f2d4: e59f3040 ldr r3, [pc, #64] ; 1f31c <rtems_rfs_buffer_bdbuf_release+0x74><== NOT EXECUTED 1f2d8: e59f0040 ldr r0, [pc, #64] ; 1f320 <rtems_rfs_buffer_bdbuf_release+0x78><== NOT EXECUTED 1f2dc: e5941034 ldr r1, [r4, #52] ; 0x34 <== NOT EXECUTED 1f2e0: e5942018 ldr r2, [r4, #24] <== NOT EXECUTED 1f2e4: 01a0300c moveq r3, ip <== NOT EXECUTED 1f2e8: eb00046d bl 204a4 <printf> <== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
1f2ec: e3550000 cmp r5, #0
sc = rtems_bdbuf_release_modified (buffer);
1f2f0: 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)
1f2f4: 0a000003 beq 1f308 <rtems_rfs_buffer_bdbuf_release+0x60>
sc = rtems_bdbuf_release_modified (buffer);
1f2f8: ebffd69d bl 14d74 <rtems_bdbuf_release_modified>
else
sc = rtems_bdbuf_release (buffer);
if (sc != RTEMS_SUCCESSFUL)
1f2fc: e3500000 cmp r0, #0
#endif
rc = EIO;
}
return rc;
}
1f300: 13a00005 movne r0, #5
1f304: e8bd8030 pop {r4, r5, pc}
buffer->block, modified ? "(modified)" : "");
if (modified)
sc = rtems_bdbuf_release_modified (buffer);
else
sc = rtems_bdbuf_release (buffer);
1f308: ebffd668 bl 14cb0 <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL)
1f30c: e3500000 cmp r0, #0
#endif
rc = EIO;
}
return rc;
}
1f310: 13a00005 movne r0, #5
1f314: e8bd8030 pop {r4, r5, pc}
0001a518 <rtems_rfs_buffer_close>:
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
1a518: e92d4030 push {r4, r5, lr}
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
1a51c: e3a01000 mov r1, #0
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
1a520: e1a04000 mov r4, r0
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
1a524: e3a00010 mov r0, #16 1a528: ebffe0c0 bl 12830 <rtems_rfs_trace> 1a52c: e3500000 cmp r0, #0
1a530: 1a000010 bne 1a578 <rtems_rfs_buffer_close+0x60>
/*
* 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));
1a534: e5943010 ldr r3, [r4, #16] 1a538: e1a00004 mov r0, r4 1a53c: e5931020 ldr r1, [r3, #32] 1a540: ebffffb6 bl 1a420 <rtems_rfs_buffer_setblksize>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
1a544: e2505000 subs r5, r0, #0
1a548: da000004 ble 1a560 <rtems_rfs_buffer_close+0x48>
1a54c: e3a00010 mov r0, #16 <== NOT EXECUTED 1a550: e3a01000 mov r1, #0 <== NOT EXECUTED 1a554: ebffe0b5 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1a558: e3500000 cmp r0, #0 <== NOT EXECUTED 1a55c: 1a000008 bne 1a584 <rtems_rfs_buffer_close+0x6c> <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
rc, strerror (rc));
if (close (fs->device) < 0)
1a560: e594000c ldr r0, [r4, #12] 1a564: ebffb28a bl 6f94 <close> 1a568: e3500000 cmp r0, #0
1a56c: ba00000e blt 1a5ac <rtems_rfs_buffer_close+0x94>
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
rc, strerror (rc));
}
return rc;
}
1a570: e1a00005 mov r0, r5
1a574: e8bd8030 pop {r4, r5, pc}
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
printf ("rtems-rfs: buffer-close: closing\n");
1a578: e59f0064 ldr r0, [pc, #100] ; 1a5e4 <rtems_rfs_buffer_close+0xcc><== NOT EXECUTED 1a57c: eb001860 bl 20704 <puts> <== NOT EXECUTED 1a580: eaffffeb b 1a534 <rtems_rfs_buffer_close+0x1c> <== NOT EXECUTED
* all buffers.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
1a584: e1a00005 mov r0, r5 <== NOT EXECUTED 1a588: eb001c73 bl 2175c <strerror> <== NOT EXECUTED 1a58c: e1a01005 mov r1, r5 <== NOT EXECUTED 1a590: e1a02000 mov r2, r0 <== NOT EXECUTED 1a594: e59f004c ldr r0, [pc, #76] ; 1a5e8 <rtems_rfs_buffer_close+0xd0><== NOT EXECUTED 1a598: eb0017c1 bl 204a4 <printf> <== NOT EXECUTED
rc, strerror (rc));
if (close (fs->device) < 0)
1a59c: e594000c ldr r0, [r4, #12] <== NOT EXECUTED 1a5a0: ebffb27b bl 6f94 <close> <== NOT EXECUTED 1a5a4: e3500000 cmp r0, #0 <== NOT EXECUTED 1a5a8: aafffff0 bge 1a570 <rtems_rfs_buffer_close+0x58> <== NOT EXECUTED
{
rc = errno;
1a5ac: eb0013f8 bl 1f594 <__errno> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
1a5b0: 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;
1a5b4: e5905000 ldr r5, [r0] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
1a5b8: e3a00010 mov r0, #16 <== NOT EXECUTED 1a5bc: ebffe09b bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1a5c0: e3500000 cmp r0, #0 <== NOT EXECUTED 1a5c4: 0affffe9 beq 1a570 <rtems_rfs_buffer_close+0x58> <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
1a5c8: e1a00005 mov r0, r5 <== NOT EXECUTED 1a5cc: eb001c62 bl 2175c <strerror> <== NOT EXECUTED 1a5d0: e1a01005 mov r1, r5 <== NOT EXECUTED 1a5d4: e1a02000 mov r2, r0 <== NOT EXECUTED 1a5d8: e59f000c ldr r0, [pc, #12] ; 1a5ec <rtems_rfs_buffer_close+0xd4><== NOT EXECUTED 1a5dc: eb0017b0 bl 204a4 <printf> <== NOT EXECUTED 1a5e0: eaffffe2 b 1a570 <rtems_rfs_buffer_close+0x58> <== NOT EXECUTED
00019d00 <rtems_rfs_buffer_handle_release>:
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
19d00: e92d4070 push {r4, r5, r6, lr}
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
19d04: e5916008 ldr r6, [r1, #8] 19d08: e3560000 cmp r6, #0
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
19d0c: e24dd004 sub sp, sp, #4 19d10: e1a04001 mov r4, r1 19d14: e1a05000 mov r5, r0
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
19d18: 0a00000e beq 19d58 <rtems_rfs_buffer_handle_release+0x58>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
19d1c: e3a00c02 mov r0, #512 ; 0x200 19d20: e3a01000 mov r1, #0 19d24: ebffe2c1 bl 12830 <rtems_rfs_trace> 19d28: e3500000 cmp r0, #0
19d2c: 1a00000c bne 19d64 <rtems_rfs_buffer_handle_release+0x64>
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)
19d30: e5940008 ldr r0, [r4, #8] 19d34: e5906030 ldr r6, [r0, #48] ; 0x30 19d38: e3560000 cmp r6, #0
rtems_rfs_buffer_refs_down (handle);
19d3c: c2466001 subgt r6, r6, #1 19d40: c5806030 strgt r6, [r0, #48] ; 0x30
if (rtems_rfs_buffer_refs (handle) == 0)
19d44: e3560000 cmp r6, #0
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
int rc = 0;
19d48: 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)
19d4c: 0a00001a beq 19dbc <rtems_rfs_buffer_handle_release+0xbc>
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
}
}
}
handle->buffer = NULL;
19d50: e3a03000 mov r3, #0 19d54: e5843008 str r3, [r4, #8]
}
return rc;
}
19d58: e1a00006 mov r0, r6
19d5c: e28dd004 add sp, sp, #4
19d60: e8bd8070 pop {r4, r5, r6, pc}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
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" : "");
19d64: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 19d68: 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",
19d6c: e5d46000 ldrb r6, [r4] <== NOT EXECUTED 19d70: e59fe158 ldr lr, [pc, #344] ; 19ed0 <rtems_rfs_buffer_handle_release+0x1d0><== NOT EXECUTED 19d74: e3530000 cmp r3, #0 <== NOT EXECUTED 19d78: e59fc154 ldr ip, [pc, #340] ; 19ed4 <rtems_rfs_buffer_handle_release+0x1d4><== NOT EXECUTED 19d7c: 11a0c00e movne ip, lr <== NOT EXECUTED 19d80: e3560000 cmp r6, #0 <== NOT EXECUTED 19d84: e5941004 ldr r1, [r4, #4] <== NOT EXECUTED 19d88: e59f2148 ldr r2, [pc, #328] ; 19ed8 <rtems_rfs_buffer_handle_release+0x1d8><== NOT EXECUTED 19d8c: e59f0148 ldr r0, [pc, #328] ; 19edc <rtems_rfs_buffer_handle_release+0x1dc><== NOT EXECUTED 19d90: 01a0200e moveq r2, lr <== NOT EXECUTED 19d94: e58dc000 str ip, [sp] <== NOT EXECUTED 19d98: eb0019c1 bl 204a4 <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)
19d9c: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED 19da0: e5906030 ldr r6, [r0, #48] ; 0x30 <== NOT EXECUTED 19da4: e3560000 cmp r6, #0 <== NOT EXECUTED
rtems_rfs_buffer_refs_down (handle);
19da8: c2466001 subgt r6, r6, #1 <== NOT EXECUTED 19dac: c5806030 strgt r6, [r0, #48] ; 0x30 <== NOT EXECUTED
if (rtems_rfs_buffer_refs (handle) == 0)
19db0: e3560000 cmp r6, #0 <== NOT EXECUTED
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
int rc = 0;
19db4: 13a06000 movne r6, #0 <== NOT EXECUTED
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)
19db8: 1affffe4 bne 19d50 <rtems_rfs_buffer_handle_release+0x50> <== NOT EXECUTED
19dbc: ebfff42a bl 16e6c <_Chain_Extract>
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
19dc0: e5953050 ldr r3, [r5, #80] ; 0x50
if (rtems_rfs_fs_no_local_cache (fs))
19dc4: e5952000 ldr r2, [r5]
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
19dc8: e2433001 sub r3, r3, #1
if (rtems_rfs_fs_no_local_cache (fs))
19dcc: e3120002 tst r2, #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--;
19dd0: e5853050 str r3, [r5, #80] ; 0x50
if (rtems_rfs_fs_no_local_cache (fs))
19dd4: 1a00000f bne 19e18 <rtems_rfs_buffer_handle_release+0x118>
* 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 +
19dd8: e5951070 ldr r1, [r5, #112] ; 0x70 19ddc: e5952060 ldr r2, [r5, #96] ; 0x60 19de0: e5953040 ldr r3, [r5, #64] ; 0x40 19de4: e0812002 add r2, r1, r2 19de8: e1520003 cmp r2, r3
19dec: 2a000016 bcs 19e4c <rtems_rfs_buffer_handle_release+0x14c>
}
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
}
if (rtems_rfs_buffer_dirty (handle))
19df0: e5d43000 ldrb r3, [r4] 19df4: e3530000 cmp r3, #0
19df8: 0a00000c beq 19e30 <rtems_rfs_buffer_handle_release+0x130>
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
19dfc: e2850064 add r0, r5, #100 ; 0x64 19e00: e5941008 ldr r1, [r4, #8] 19e04: ebffca20 bl c68c <_Chain_Append>
{
rtems_chain_append (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
19e08: e5953070 ldr r3, [r5, #112] ; 0x70 19e0c: e2833001 add r3, r3, #1 19e10: e5853070 str r3, [r5, #112] ; 0x70 19e14: eaffffcd b 19d50 <rtems_rfs_buffer_handle_release+0x50>
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
if (rtems_rfs_fs_no_local_cache (fs))
{
handle->buffer->user = (void*) 0;
19e18: e5940008 ldr r0, [r4, #8]
rc = rtems_rfs_buffer_io_release (handle->buffer,
19e1c: e5d41000 ldrb r1, [r4]
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
if (rtems_rfs_fs_no_local_cache (fs))
{
handle->buffer->user = (void*) 0;
19e20: e5806034 str r6, [r0, #52] ; 0x34
rc = rtems_rfs_buffer_io_release (handle->buffer,
19e24: eb00151f bl 1f2a8 <rtems_rfs_buffer_bdbuf_release> 19e28: e1a06000 mov r6, r0 19e2c: eaffffc7 b 19d50 <rtems_rfs_buffer_handle_release+0x50> 19e30: e2850054 add r0, r5, #84 ; 0x54 19e34: e5941008 ldr r1, [r4, #8] 19e38: ebffca13 bl c68c <_Chain_Append>
fs->release_modified_count++;
}
else
{
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
19e3c: e5953060 ldr r3, [r5, #96] ; 0x60 19e40: e2833001 add r3, r3, #1 19e44: e5853060 str r3, [r5, #96] ; 0x60 19e48: eaffffc0 b 19d50 <rtems_rfs_buffer_handle_release+0x50>
fs->release_modified_count) >= fs->max_held_buffers)
{
rtems_rfs_buffer* buffer;
bool modified;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
19e4c: e3a00c02 mov r0, #512 ; 0x200 19e50: e3a01000 mov r1, #0 19e54: ebffe275 bl 12830 <rtems_rfs_trace> 19e58: e3500000 cmp r0, #0
19e5c: 1a000015 bne 19eb8 <rtems_rfs_buffer_handle_release+0x1b8>
printf ("rtems-rfs: buffer-release: local cache overflow:"
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
19e60: e5952060 ldr r2, [r5, #96] ; 0x60 19e64: e5953070 ldr r3, [r5, #112] ; 0x70 19e68: e1520003 cmp r2, r3
19e6c: 9a00000a bls 19e9c <rtems_rfs_buffer_handle_release+0x19c>
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
19e70: e2850054 add r0, r5, #84 ; 0x54 19e74: ebffca0f bl c6b8 <_Chain_Get>
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
19e78: e5953060 ldr r3, [r5, #96] ; 0x60 19e7c: e2433001 sub r3, r3, #1 19e80: e5853060 str r3, [r5, #96] ; 0x60
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
modified = true;
}
buffer->user = (void*) 0;
19e84: e3a03000 mov r3, #0
rc = rtems_rfs_buffer_io_release (buffer, modified);
19e88: e1a01006 mov r1, r6
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
modified = true;
}
buffer->user = (void*) 0;
19e8c: e5803034 str r3, [r0, #52] ; 0x34
rc = rtems_rfs_buffer_io_release (buffer, modified);
19e90: eb001504 bl 1f2a8 <rtems_rfs_buffer_bdbuf_release> 19e94: e1a06000 mov r6, r0 19e98: eaffffd4 b 19df0 <rtems_rfs_buffer_handle_release+0xf0> 19e9c: e2850064 add r0, r5, #100 ; 0x64 19ea0: ebffca04 bl c6b8 <_Chain_Get>
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
19ea4: e5953070 ldr r3, [r5, #112] ; 0x70 19ea8: e2433001 sub r3, r3, #1 19eac: e5853070 str r3, [r5, #112] ; 0x70 19eb0: e3a06001 mov r6, #1 19eb4: eafffff2 b 19e84 <rtems_rfs_buffer_handle_release+0x184>
{
rtems_rfs_buffer* buffer;
bool modified;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: local cache overflow:"
19eb8: e5951070 ldr r1, [r5, #112] ; 0x70 <== NOT EXECUTED 19ebc: e5953060 ldr r3, [r5, #96] ; 0x60 <== NOT EXECUTED 19ec0: e59f0018 ldr r0, [pc, #24] ; 19ee0 <rtems_rfs_buffer_handle_release+0x1e0><== NOT EXECUTED 19ec4: e0811003 add r1, r1, r3 <== NOT EXECUTED 19ec8: eb001975 bl 204a4 <printf> <== NOT EXECUTED 19ecc: eaffffe3 b 19e60 <rtems_rfs_buffer_handle_release+0x160> <== NOT EXECUTED
00019ee4 <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)
{
19ee4: e92d41f0 push {r4, r5, r6, r7, r8, lr}
19ee8: e1a04001 mov r4, r1
/*
* 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))
19eec: e5911008 ldr r1, [r1, #8] 19ef0: e3510000 cmp r1, #0
int
rtems_rfs_buffer_handle_request (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle,
rtems_rfs_buffer_block block,
bool read)
{
19ef4: e24dd004 sub sp, sp, #4 19ef8: e1a05000 mov r5, r0 19efc: e1a06002 mov r6, r2 19f00: e20380ff and r8, 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))
19f04: 0a000015 beq 19f60 <rtems_rfs_buffer_handle_request+0x7c>
{
/*
* Treat block 0 as special to handle the loading of the super block.
*/
if (block && (rtems_rfs_buffer_bnum (handle) == block))
19f08: e3520000 cmp r2, #0
19f0c: 0a000003 beq 19f20 <rtems_rfs_buffer_handle_request+0x3c>
19f10: e5943004 ldr r3, [r4, #4] 19f14: e1530002 cmp r3, r2
return 0;
19f18: 03a07000 moveq r7, #0
if (rtems_rfs_buffer_handle_has_block (handle))
{
/*
* Treat block 0 as special to handle the loading of the super block.
*/
if (block && (rtems_rfs_buffer_bnum (handle) == block))
19f1c: 0a000009 beq 19f48 <rtems_rfs_buffer_handle_request+0x64>
return 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
19f20: e3a00c01 mov r0, #256 ; 0x100 19f24: e3a01000 mov r1, #0 19f28: ebffe240 bl 12830 <rtems_rfs_trace> 19f2c: e3500000 cmp r0, #0
19f30: 1a000036 bne 1a010 <rtems_rfs_buffer_handle_request+0x12c>
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
19f34: e1a00005 mov r0, r5 19f38: e1a01004 mov r1, r4 19f3c: ebffff6f bl 19d00 <rtems_rfs_buffer_handle_release>
if (rc > 0)
19f40: e2507000 subs r7, r0, #0
19f44: da000002 ble 19f54 <rtems_rfs_buffer_handle_request+0x70>
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;
}
19f48: e1a00007 mov r0, r7
19f4c: e28dd004 add sp, sp, #4
19f50: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
if (rc > 0)
return rc;
handle->dirty = false;
19f54: e3a03000 mov r3, #0 19f58: e5c43000 strb r3, [r4]
handle->bnum = 0;
19f5c: e5843004 str r3, [r4, #4]
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
19f60: e3a00c01 mov r0, #256 ; 0x100 19f64: e3a01000 mov r1, #0 19f68: ebffe230 bl 12830 <rtems_rfs_trace> 19f6c: e3500000 cmp r0, #0
19f70: 1a000069 bne 1a11c <rtems_rfs_buffer_handle_request+0x238> * 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)
19f74: e5953050 ldr r3, [r5, #80] ; 0x50 19f78: e3530000 cmp r3, #0
19f7c: 1a000053 bne 1a0d0 <rtems_rfs_buffer_handle_request+0x1ec>
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",
19f80: e5943008 ldr r3, [r4, #8]
/* * 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) &&
19f84: e5952000 ldr r2, [r5] 19f88: e3120002 tst r2, #2
19f8c: 0a000023 beq 1a020 <rtems_rfs_buffer_handle_request+0x13c>
}
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
19f90: e3530000 cmp r3, #0
19f94: 0a000033 beq 1a068 <rtems_rfs_buffer_handle_request+0x184>
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
19f98: e5932030 ldr r2, [r3, #48] ; 0x30 19f9c: e2822001 add r2, r2, #1
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
19fa0: e1a01003 mov r1, r3 19fa4: e5832030 str r2, [r3, #48] ; 0x30 19fa8: e2850044 add r0, r5, #68 ; 0x44 19fac: ebffc9b6 bl c68c <_Chain_Append>
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle)); fs->buffers_count++;
19fb0: e5952050 ldr r2, [r5, #80] ; 0x50
handle->buffer->user = (void*) ((intptr_t) block);
19fb4: e5943008 ldr r3, [r4, #8]
/* * Increase the reference count of the buffer. */ rtems_rfs_buffer_refs_up (handle); rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle)); fs->buffers_count++;
19fb8: e2822001 add r2, r2, #1 19fbc: e5852050 str r2, [r5, #80] ; 0x50
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
19fc0: 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);
19fc4: e5836034 str r6, [r3, #52] ; 0x34
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
19fc8: 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;
19fcc: e5846004 str r6, [r4, #4]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
19fd0: ebffe216 bl 12830 <rtems_rfs_trace> 19fd4: e2507000 subs r7, r0, #0
19fd8: 0affffda beq 19f48 <rtems_rfs_buffer_handle_request+0x64>
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
block, read ? "read" : "get", handle->buffer->block,
19fdc: e5942008 ldr r2, [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",
19fe0: e59fe17c ldr lr, [pc, #380] ; 1a164 <rtems_rfs_buffer_handle_request+0x280><== NOT EXECUTED 19fe4: e592c030 ldr ip, [r2, #48] ; 0x30 <== NOT EXECUTED 19fe8: e3580000 cmp r8, #0 <== NOT EXECUTED 19fec: e5923018 ldr r3, [r2, #24] <== NOT EXECUTED 19ff0: e1a01006 mov r1, r6 <== NOT EXECUTED 19ff4: e59f216c ldr r2, [pc, #364] ; 1a168 <rtems_rfs_buffer_handle_request+0x284><== NOT EXECUTED 19ff8: e59f016c ldr r0, [pc, #364] ; 1a16c <rtems_rfs_buffer_handle_request+0x288><== NOT EXECUTED 19ffc: 01a0200e moveq r2, lr <== NOT EXECUTED 1a000: e58dc000 str ip, [sp] <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
1a004: e3a07000 mov r7, #0 <== 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",
1a008: eb001925 bl 204a4 <printf> <== NOT EXECUTED 1a00c: eaffffcd b 19f48 <rtems_rfs_buffer_handle_request+0x64> <== NOT EXECUTED
*/
if (block && (rtems_rfs_buffer_bnum (handle) == block))
return 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
1a010: e5941004 ldr r1, [r4, #4] <== NOT EXECUTED 1a014: e59f0154 ldr r0, [pc, #340] ; 1a170 <rtems_rfs_buffer_handle_request+0x28c><== NOT EXECUTED 1a018: eb001921 bl 204a4 <printf> <== NOT EXECUTED 1a01c: eaffffc4 b 19f34 <rtems_rfs_buffer_handle_request+0x50> <== NOT EXECUTED
/* * If the buffer has not been found check the local cache of released * buffers. There are release and released modified lists to preserve the * state. */ if (!rtems_rfs_fs_no_local_cache (fs) &&
1a020: e3530000 cmp r3, #0
1a024: 1affffdb bne 19f98 <rtems_rfs_buffer_handle_request+0xb4>
!rtems_rfs_buffer_handle_has_block (handle))
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
1a028: e5953060 ldr r3, [r5, #96] ; 0x60 1a02c: e3530000 cmp r3, #0
1a030: 1a000042 bne 1a140 <rtems_rfs_buffer_handle_request+0x25c>
handle->buffer = rtems_rfs_scan_chain (&fs->release,
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
1a034: e5953070 ldr r3, [r5, #112] ; 0x70 1a038: e3530000 cmp r3, #0
1a03c: 0a000009 beq 1a068 <rtems_rfs_buffer_handle_request+0x184>
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
1a040: e1a02006 mov r2, r6 1a044: e2850064 add r0, r5, #100 ; 0x64 1a048: e2851070 add r1, r5, #112 ; 0x70 1a04c: ebfffeee bl 19c0c <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))
1a050: e3500000 cmp r0, #0
rtems_rfs_buffer_mark_dirty (handle);
1a054: 13a02001 movne r2, #1
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
1a058: e1a03000 mov r3, r0 1a05c: 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);
1a060: 15c42000 strbne r2, [r4]
&fs->release_modified_count,
block);
/*
* If we found a buffer retain the dirty buffer state.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
1a064: 1affffcb bne 19f98 <rtems_rfs_buffer_handle_request+0xb4>
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
1a068: e1a00005 mov r0, r5 1a06c: e1a01006 mov r1, r6 1a070: e1a02008 mov r2, r8 1a074: e2843008 add r3, r4, #8 1a078: eb00147d bl 1f274 <rtems_rfs_buffer_bdbuf_request>
if (rc > 0)
1a07c: e2507000 subs r7, r0, #0
1a080: da000029 ble 1a12c <rtems_rfs_buffer_handle_request+0x248>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
1a084: e3a00c01 mov r0, #256 ; 0x100 <== NOT EXECUTED 1a088: e3a01000 mov r1, #0 <== NOT EXECUTED 1a08c: ebffe1e7 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1a090: e3500000 cmp r0, #0 <== NOT EXECUTED 1a094: 0affffab beq 19f48 <rtems_rfs_buffer_handle_request+0x64> <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
1a098: e59f30c8 ldr r3, [pc, #200] ; 1a168 <rtems_rfs_buffer_handle_request+0x284><== NOT EXECUTED 1a09c: e59f20c0 ldr r2, [pc, #192] ; 1a164 <rtems_rfs_buffer_handle_request+0x280><== NOT EXECUTED 1a0a0: e3580000 cmp r8, #0 <== NOT EXECUTED 1a0a4: e1a00007 mov r0, r7 <== NOT EXECUTED 1a0a8: 11a08003 movne r8, r3 <== NOT EXECUTED 1a0ac: 01a08002 moveq r8, r2 <== NOT EXECUTED 1a0b0: eb001da9 bl 2175c <strerror> <== NOT EXECUTED 1a0b4: e1a01006 mov r1, r6 <== NOT EXECUTED 1a0b8: e58d0000 str r0, [sp] <== NOT EXECUTED 1a0bc: e1a02008 mov r2, r8 <== NOT EXECUTED 1a0c0: e1a03007 mov r3, r7 <== NOT EXECUTED 1a0c4: e59f00a8 ldr r0, [pc, #168] ; 1a174 <rtems_rfs_buffer_handle_request+0x290><== NOT EXECUTED 1a0c8: eb0018f5 bl 204a4 <printf> <== NOT EXECUTED 1a0cc: eaffff9d b 19f48 <rtems_rfs_buffer_handle_request+0x64> <== NOT EXECUTED
if (fs->buffers_count)
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
1a0d0: e2850044 add r0, r5, #68 ; 0x44 1a0d4: e2851050 add r1, r5, #80 ; 0x50 1a0d8: e1a02006 mov r2, r6 1a0dc: ebfffeca bl 19c0c <rtems_rfs_scan_chain>
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
1a0e0: e3500000 cmp r0, #0
if (fs->buffers_count)
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
1a0e4: e5840008 str r0, [r4, #8]
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
1a0e8: 01a03000 moveq r3, r0
1a0ec: 0affffa4 beq 19f84 <rtems_rfs_buffer_handle_request+0xa0>
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
1a0f0: e3a00c01 mov r0, #256 ; 0x100 1a0f4: e3a01000 mov r1, #0 1a0f8: ebffe1cc bl 12830 <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) &&
1a0fc: 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);
1a100: e5943008 ldr r3, [r4, #8]
* 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) &&
1a104: 0affff9e beq 19f84 <rtems_rfs_buffer_handle_request+0xa0>
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n",
1a108: e5931030 ldr r1, [r3, #48] ; 0x30 <== NOT EXECUTED 1a10c: e59f0064 ldr r0, [pc, #100] ; 1a178 <rtems_rfs_buffer_handle_request+0x294><== NOT EXECUTED 1a110: e2811001 add r1, r1, #1 <== NOT EXECUTED 1a114: eb0018e2 bl 204a4 <printf> <== NOT EXECUTED 1a118: eaffff98 b 19f80 <rtems_rfs_buffer_handle_request+0x9c> <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
1a11c: e1a01006 mov r1, r6 <== NOT EXECUTED 1a120: e59f0054 ldr r0, [pc, #84] ; 1a17c <rtems_rfs_buffer_handle_request+0x298><== NOT EXECUTED 1a124: eb0018de bl 204a4 <printf> <== NOT EXECUTED 1a128: eaffff91 b 19f74 <rtems_rfs_buffer_handle_request+0x90> <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
block, read ? "read" : "get", rc, strerror (rc));
return rc;
}
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
1a12c: e5943008 ldr r3, [r4, #8] 1a130: e3a02000 mov r2, #0 1a134: e5832004 str r2, [r3, #4] 1a138: e5832000 str r2, [r3] 1a13c: eaffff95 b 19f98 <rtems_rfs_buffer_handle_request+0xb4>
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
handle->buffer = rtems_rfs_scan_chain (&fs->release,
1a140: e2850054 add r0, r5, #84 ; 0x54 1a144: e2851060 add r1, r5, #96 ; 0x60 1a148: e1a02006 mov r2, r6 1a14c: ebfffeae bl 19c0c <rtems_rfs_scan_chain>
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
1a150: e3500000 cmp r0, #0
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
handle->buffer = rtems_rfs_scan_chain (&fs->release,
1a154: e1a03000 mov r3, r0 1a158: e5840008 str r0, [r4, #8]
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
1a15c: 1affff8d bne 19f98 <rtems_rfs_buffer_handle_request+0xb4>
1a160: eaffffb3 b 1a034 <rtems_rfs_buffer_handle_request+0x150>
0001a180 <rtems_rfs_buffer_open>:
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
1a180: e92d4030 push {r4, r5, lr}
1a184: e1a05000 mov r5, r0
1a188: e24dd048 sub sp, sp, #72 ; 0x48
1a18c: e1a04001 mov r4, r1
struct stat st;
#if RTEMS_RFS_USE_LIBBLOCK
int rv;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
1a190: e3a00020 mov r0, #32 1a194: e3a01000 mov r1, #0 1a198: ebffe1a4 bl 12830 <rtems_rfs_trace> 1a19c: e3500000 cmp r0, #0
1a1a0: 1a000015 bne 1a1fc <rtems_rfs_buffer_open+0x7c>
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
fs->device = open (name, O_RDWR);
1a1a4: e1a00005 mov r0, r5 1a1a8: e3a01002 mov r1, #2 1a1ac: ebffb7d4 bl 8104 <open>
if (fs->device < 0)
1a1b0: 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);
1a1b4: e584000c str r0, [r4, #12]
if (fs->device < 0)
1a1b8: ba000018 blt 1a220 <rtems_rfs_buffer_open+0xa0>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: cannot open file\n");
return ENXIO;
}
if (fstat (fs->device, &st) < 0)
1a1bc: e1a0100d mov r1, sp 1a1c0: ebffb445 bl 72dc <fstat> 1a1c4: e3500000 cmp r0, #0
1a1c8: ba000031 blt 1a294 <rtems_rfs_buffer_open+0x114>
#if RTEMS_RFS_USE_LIBBLOCK
/*
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
1a1cc: e59d300c ldr r3, [sp, #12] 1a1d0: e2033a0f and r3, r3, #61440 ; 0xf000 1a1d4: e3530a06 cmp r3, #24576 ; 0x6000
1a1d8: 0a000019 beq 1a244 <rtems_rfs_buffer_open+0xc4>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
1a1dc: e3a00008 mov r0, #8 <== NOT EXECUTED 1a1e0: e3a01000 mov r1, #0 <== NOT EXECUTED 1a1e4: ebffe191 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1a1e8: e3500000 cmp r0, #0 <== NOT EXECUTED 1a1ec: 1a000023 bne 1a280 <rtems_rfs_buffer_open+0x100> <== 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;
1a1f0: 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;
}
1a1f4: e28dd048 add sp, sp, #72 ; 0x48
1a1f8: e8bd8030 pop {r4, r5, pc}
#if RTEMS_RFS_USE_LIBBLOCK
int rv;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
1a1fc: e1a01005 mov r1, r5 <== NOT EXECUTED 1a200: e59f00f4 ldr r0, [pc, #244] ; 1a2fc <rtems_rfs_buffer_open+0x17c><== NOT EXECUTED 1a204: eb0018a6 bl 204a4 <printf> <== NOT EXECUTED
fs->device = open (name, O_RDWR);
1a208: e1a00005 mov r0, r5 <== NOT EXECUTED 1a20c: e3a01002 mov r1, #2 <== NOT EXECUTED 1a210: ebffb7bb bl 8104 <open> <== NOT EXECUTED
if (fs->device < 0)
1a214: e3500000 cmp r0, #0 <== NOT EXECUTED
#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);
1a218: e584000c str r0, [r4, #12] <== NOT EXECUTED
if (fs->device < 0)
1a21c: aaffffe6 bge 1a1bc <rtems_rfs_buffer_open+0x3c> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
1a220: e3a00008 mov r0, #8 <== NOT EXECUTED 1a224: e3a01000 mov r1, #0 <== NOT EXECUTED 1a228: ebffe180 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1a22c: e3500000 cmp r0, #0 <== NOT EXECUTED 1a230: 0affffee beq 1a1f0 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
1a234: e59f00c4 ldr r0, [pc, #196] ; 1a300 <rtems_rfs_buffer_open+0x180><== NOT EXECUTED 1a238: eb001931 bl 20704 <puts> <== NOT EXECUTED
return ENXIO;
1a23c: e3a00006 mov r0, #6 <== NOT EXECUTED 1a240: eaffffeb b 1a1f4 <rtems_rfs_buffer_open+0x74> <== 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);
1a244: e594000c ldr r0, [r4, #12] 1a248: e59f10b4 ldr r1, [pc, #180] ; 1a304 <rtems_rfs_buffer_open+0x184> 1a24c: e2842010 add r2, r4, #16 1a250: ebffb46d bl 740c <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)
1a254: e2505000 subs r5, r0, #0
1a258: 0a00001b beq 1a2cc <rtems_rfs_buffer_open+0x14c>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
1a25c: e3a00008 mov r0, #8 <== NOT EXECUTED 1a260: e3a01000 mov r1, #0 <== NOT EXECUTED 1a264: ebffe171 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1a268: e3500000 cmp r0, #0 <== NOT EXECUTED 1a26c: 0affffdf beq 1a1f0 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
1a270: e59f0090 ldr r0, [pc, #144] ; 1a308 <rtems_rfs_buffer_open+0x188><== NOT EXECUTED 1a274: eb001922 bl 20704 <puts> <== NOT EXECUTED
return ENXIO;
1a278: e3a00006 mov r0, #6 <== NOT EXECUTED 1a27c: eaffffdc b 1a1f4 <rtems_rfs_buffer_open+0x74> <== NOT EXECUTED
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
1a280: e59f0084 ldr r0, [pc, #132] ; 1a30c <rtems_rfs_buffer_open+0x18c><== NOT EXECUTED 1a284: e1a01005 mov r1, r5 <== NOT EXECUTED 1a288: eb001885 bl 204a4 <printf> <== NOT EXECUTED
return ENXIO;
1a28c: e3a00006 mov r0, #6 <== NOT EXECUTED 1a290: eaffffd7 b 1a1f4 <rtems_rfs_buffer_open+0x74> <== NOT EXECUTED
return ENXIO;
}
if (fstat (fs->device, &st) < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
1a294: e3a00008 mov r0, #8 <== NOT EXECUTED 1a298: e3a01000 mov r1, #0 <== NOT EXECUTED 1a29c: ebffe163 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1a2a0: e3500000 cmp r0, #0 <== NOT EXECUTED 1a2a4: 0affffd1 beq 1a1f0 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
1a2a8: eb0014b9 bl 1f594 <__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",
1a2ac: e5900000 ldr r0, [r0] <== NOT EXECUTED 1a2b0: eb001d29 bl 2175c <strerror> <== NOT EXECUTED 1a2b4: e1a01005 mov r1, r5 <== NOT EXECUTED 1a2b8: e1a02000 mov r2, r0 <== NOT EXECUTED 1a2bc: e59f004c ldr r0, [pc, #76] ; 1a310 <rtems_rfs_buffer_open+0x190><== NOT EXECUTED 1a2c0: eb001877 bl 204a4 <printf> <== NOT EXECUTED
name, strerror (errno));
return ENXIO;
1a2c4: e3a00006 mov r0, #6 <== NOT EXECUTED 1a2c8: eaffffc9 b 1a1f4 <rtems_rfs_buffer_open+0x74> <== NOT EXECUTED
#else
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
1a2cc: e3a00020 mov r0, #32 1a2d0: e3a01000 mov r1, #0 1a2d4: ebffe155 bl 12830 <rtems_rfs_trace> 1a2d8: e3500000 cmp r0, #0
1a2dc: 0affffc4 beq 1a1f4 <rtems_rfs_buffer_open+0x74>
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
1a2e0: 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",
1a2e4: e283101c add r1, r3, #28 <== NOT EXECUTED
1a2e8: e59f0024 ldr r0, [pc, #36] ; 1a314 <rtems_rfs_buffer_open+0x194><== NOT EXECUTED
1a2ec: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
1a2f0: eb00186b bl 204a4 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
1a2f4: e1a00005 mov r0, r5 <== NOT EXECUTED 1a2f8: eaffffbd b 1a1f4 <rtems_rfs_buffer_open+0x74> <== NOT EXECUTED
0001a420 <rtems_rfs_buffer_setblksize>:
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
1a420: e92d4030 push {r4, r5, lr}
1a424: e24dd004 sub sp, sp, #4
1a428: e58d1000 str r1, [sp]
1a42c: e1a04000 mov r4, r0
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
1a430: e3a01000 mov r1, #0 1a434: e3a00b01 mov r0, #1024 ; 0x400 1a438: ebffe0fc bl 12830 <rtems_rfs_trace> 1a43c: e3500000 cmp r0, #0
1a440: 1a00001b bne 1a4b4 <rtems_rfs_buffer_setblksize+0x94>
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
rc = rtems_rfs_buffers_release (fs);
1a444: e1a00004 mov r0, r4 1a448: ebffffd6 bl 1a3a8 <rtems_rfs_buffers_release>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
1a44c: e2505000 subs r5, r0, #0
1a450: da000004 ble 1a468 <rtems_rfs_buffer_setblksize+0x48>
1a454: e3a00b01 mov r0, #1024 ; 0x400 <== NOT EXECUTED 1a458: e3a01000 mov r1, #0 <== NOT EXECUTED 1a45c: ebffe0f3 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1a460: e3500000 cmp r0, #0 <== NOT EXECUTED 1a464: 1a00001d bne 1a4e0 <rtems_rfs_buffer_setblksize+0xc0> <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
1a468: e1a00004 mov r0, r4 1a46c: ebffffa9 bl 1a318 <rtems_rfs_buffer_sync>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
1a470: e2505000 subs r5, r0, #0
1a474: da000004 ble 1a48c <rtems_rfs_buffer_setblksize+0x6c>
1a478: e3a00b01 mov r0, #1024 ; 0x400 <== NOT EXECUTED 1a47c: e3a01000 mov r1, #0 <== NOT EXECUTED 1a480: ebffe0ea bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1a484: e3500000 cmp r0, #0 <== NOT EXECUTED 1a488: 1a00000d bne 1a4c4 <rtems_rfs_buffer_setblksize+0xa4> <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
1a48c: e5943010 ldr r3, [r4, #16] 1a490: e59f1070 ldr r1, [pc, #112] ; 1a508 <rtems_rfs_buffer_setblksize+0xe8> 1a494: e1a00003 mov r0, r3 1a498: e1a0200d mov r2, sp 1a49c: e1a0e00f mov lr, pc 1a4a0: e593f038 ldr pc, [r3, #56] ; 0x38
if (rc < 0)
1a4a4: e3500000 cmp r0, #0
1a4a8: ba000013 blt 1a4fc <rtems_rfs_buffer_setblksize+0xdc>
rc = errno;
#endif
return rc;
}
1a4ac: e28dd004 add sp, sp, #4
1a4b0: e8bd8030 pop {r4, r5, pc}
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
1a4b4: e59d1000 ldr r1, [sp] <== NOT EXECUTED 1a4b8: e59f004c ldr r0, [pc, #76] ; 1a50c <rtems_rfs_buffer_setblksize+0xec><== NOT EXECUTED 1a4bc: eb0017f8 bl 204a4 <printf> <== NOT EXECUTED 1a4c0: eaffffdf b 1a444 <rtems_rfs_buffer_setblksize+0x24> <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
1a4c4: e1a00005 mov r0, r5 <== NOT EXECUTED 1a4c8: eb001ca3 bl 2175c <strerror> <== NOT EXECUTED 1a4cc: e1a01005 mov r1, r5 <== NOT EXECUTED 1a4d0: e1a02000 mov r2, r0 <== NOT EXECUTED 1a4d4: e59f0034 ldr r0, [pc, #52] ; 1a510 <rtems_rfs_buffer_setblksize+0xf0><== NOT EXECUTED 1a4d8: eb0017f1 bl 204a4 <printf> <== NOT EXECUTED 1a4dc: eaffffea b 1a48c <rtems_rfs_buffer_setblksize+0x6c> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
rc = rtems_rfs_buffers_release (fs);
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
1a4e0: e1a00005 mov r0, r5 <== NOT EXECUTED 1a4e4: eb001c9c bl 2175c <strerror> <== NOT EXECUTED 1a4e8: e1a01005 mov r1, r5 <== NOT EXECUTED 1a4ec: e1a02000 mov r2, r0 <== NOT EXECUTED 1a4f0: e59f001c ldr r0, [pc, #28] ; 1a514 <rtems_rfs_buffer_setblksize+0xf4><== NOT EXECUTED 1a4f4: eb0017ea bl 204a4 <printf> <== NOT EXECUTED 1a4f8: eaffffda b 1a468 <rtems_rfs_buffer_setblksize+0x48> <== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
if (rc < 0)
rc = errno;
1a4fc: eb001424 bl 1f594 <__errno> <== NOT EXECUTED 1a500: e5900000 ldr r0, [r0] <== NOT EXECUTED 1a504: eaffffe8 b 1a4ac <rtems_rfs_buffer_setblksize+0x8c> <== NOT EXECUTED
0001a318 <rtems_rfs_buffer_sync>:
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
1a318: 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))
1a31c: e3a01000 mov r1, #0
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
1a320: 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))
1a324: e3a00020 mov r0, #32 1a328: ebffe140 bl 12830 <rtems_rfs_trace> 1a32c: e3500000 cmp r0, #0
1a330: 1a000017 bne 1a394 <rtems_rfs_buffer_sync+0x7c>
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
1a334: e5940010 ldr r0, [r4, #16] 1a338: ebffeaf7 bl 14f1c <rtems_bdbuf_syncdev>
if (sc != RTEMS_SUCCESSFUL)
1a33c: e2505000 subs r5, r0, #0
1a340: 1a000003 bne 1a354 <rtems_rfs_buffer_sync+0x3c>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
rtems_status_text (sc));
result = EIO;
}
rtems_disk_release (fs->disk);
1a344: e5940010 ldr r0, [r4, #16] 1a348: ebffa49e bl 35c8 <rtems_disk_release>
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
1a34c: e1a00005 mov r0, r5
1a350: e8bd8030 pop {r4, r5, pc}
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
1a354: e3a00020 mov r0, #32 <== NOT EXECUTED 1a358: e3a01000 mov r1, #0 <== NOT EXECUTED 1a35c: ebffe133 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1a360: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
rtems_status_text (sc));
result = EIO;
1a364: 03a05005 moveq r5, #5 <== NOT EXECUTED
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
1a368: 0afffff5 beq 1a344 <rtems_rfs_buffer_sync+0x2c> <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
1a36c: e1a00005 mov r0, r5 <== NOT EXECUTED 1a370: ebffb325 bl 700c <rtems_status_text> <== NOT EXECUTED 1a374: e1a01000 mov r1, r0 <== NOT EXECUTED 1a378: e59f0020 ldr r0, [pc, #32] ; 1a3a0 <rtems_rfs_buffer_sync+0x88><== NOT EXECUTED 1a37c: eb001848 bl 204a4 <printf> <== NOT EXECUTED
rtems_status_text (sc));
result = EIO;
1a380: e3a05005 mov r5, #5 <== NOT EXECUTED
} rtems_disk_release (fs->disk);
1a384: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 1a388: ebffa48e bl 35c8 <rtems_disk_release> <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
1a38c: e1a00005 mov r0, r5 <== NOT EXECUTED
1a390: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
rtems_status_code sc;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-sync: syncing\n");
1a394: e59f0008 ldr r0, [pc, #8] ; 1a3a4 <rtems_rfs_buffer_sync+0x8c><== NOT EXECUTED 1a398: eb0018d9 bl 20704 <puts> <== NOT EXECUTED 1a39c: eaffffe4 b 1a334 <rtems_rfs_buffer_sync+0x1c> <== NOT EXECUTED
0001a3a8 <rtems_rfs_buffers_release>:
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
1a3a8: e92d4030 push {r4, r5, lr}
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
1a3ac: e3a01000 mov r1, #0
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
1a3b0: e1a04000 mov r4, r0
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
1a3b4: e3a00040 mov r0, #64 ; 0x40 1a3b8: ebffe11c bl 12830 <rtems_rfs_trace> 1a3bc: e3500000 cmp r0, #0
1a3c0: 1a00000f bne 1a404 <rtems_rfs_buffers_release+0x5c>
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
1a3c4: e2841060 add r1, r4, #96 ; 0x60 1a3c8: e3a02000 mov r2, #0 1a3cc: e2840054 add r0, r4, #84 ; 0x54 1a3d0: ebfffde7 bl 19b74 <rtems_rfs_release_chain>
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
1a3d4: e2841070 add r1, r4, #112 ; 0x70
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
1a3d8: e1c05fc0 bic r5, r0, r0, asr #31
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
1a3dc: e3a02001 mov r2, #1 1a3e0: e2840064 add r0, r4, #100 ; 0x64 1a3e4: ebfffde2 bl 19b74 <rtems_rfs_release_chain>
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
1a3e8: e2753001 rsbs r3, r5, #1 1a3ec: 33a03000 movcc r3, #0 1a3f0: e3500000 cmp r0, #0 1a3f4: d3a03000 movle r3, #0
rrc = rc;
return rrc;
}
1a3f8: e3530000 cmp r3, #0
1a3fc: 01a00005 moveq r0, r5
1a400: e8bd8030 pop {r4, r5, pc}
{
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
1a404: e5941050 ldr r1, [r4, #80] ; 0x50 <== NOT EXECUTED 1a408: e5942060 ldr r2, [r4, #96] ; 0x60 <== NOT EXECUTED 1a40c: e5943070 ldr r3, [r4, #112] ; 0x70 <== NOT EXECUTED 1a410: e59f0004 ldr r0, [pc, #4] ; 1a41c <rtems_rfs_buffers_release+0x74><== NOT EXECUTED 1a414: eb001822 bl 204a4 <printf> <== NOT EXECUTED 1a418: eaffffe9 b 1a3c4 <rtems_rfs_buffers_release+0x1c> <== NOT EXECUTED
0001ab20 <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)
{
1ab20: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1ab24: e24dd074 sub sp, sp, #116 ; 0x74
1ab28: e58d1004 str r1, [sp, #4]
1ab2c: e1a05000 mov r5, r0
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))
1ab30: e3a01000 mov r1, #0 1ab34: e3a00202 mov r0, #536870912 ; 0x20000000
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)
{
1ab38: e1a0b002 mov fp, r2 1ab3c: e1a09003 mov r9, r3
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))
1ab40: ebffdf3a bl 12830 <rtems_rfs_trace> 1ab44: e3500000 cmp r0, #0
1ab48: 1a000076 bne 1ad28 <rtems_rfs_dir_add_entry+0x208>
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%zd\n", length);
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
1ab4c: e1a00005 mov r0, r5 1ab50: e59d1004 ldr r1, [sp, #4] 1ab54: e28d2008 add r2, sp, #8 1ab58: ebfff8f6 bl 18f38 <rtems_rfs_block_map_open>
if (rc > 0)
1ab5c: e2504000 subs r4, r0, #0
1ab60: da000002 ble 1ab70 <rtems_rfs_dir_add_entry+0x50>
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
1ab64: e1a00004 mov r0, r4
1ab68: e28dd074 add sp, sp, #116 ; 0x74
1ab6c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
1ab70: e3a03000 mov r3, #0 1ab74: e5cd3064 strb r3, [sp, #100] ; 0x64
handle->bnum = 0;
1ab78: e58d3068 str r3, [sp, #104] ; 0x68
handle->buffer = NULL;
1ab7c: 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;
1ab80: e58d3058 str r3, [sp, #88] ; 0x58
bpos->boff = 0;
1ab84: e58d305c str r3, [sp, #92] ; 0x5c
bpos->block = 0;
1ab88: 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)
1ab8c: e59f63a4 ldr r6, [pc, #932] ; 1af38 <rtems_rfs_dir_add_entry+0x418>
/*
* 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);
1ab90: e1a00005 mov r0, r5 1ab94: e28d1008 add r1, sp, #8 1ab98: e28d2058 add r2, sp, #88 ; 0x58 1ab9c: e28d3070 add r3, sp, #112 ; 0x70 1aba0: ebfff9b1 bl 1926c <rtems_rfs_block_map_find>
if (rc > 0)
1aba4: e3500000 cmp r0, #0
1aba8: da0000a4 ble 1ae40 <rtems_rfs_dir_add_entry+0x320>
{
if (rc != ENXIO)
1abac: e3500006 cmp r0, #6
1abb0: 1a0000b6 bne 1ae90 <rtems_rfs_dir_add_entry+0x370>
}
/*
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
1abb4: e1a00005 mov r0, r5 1abb8: e28d1008 add r1, sp, #8 1abbc: e3a02001 mov r2, #1 1abc0: e28d3070 add r3, sp, #112 ; 0x70 1abc4: ebfffa2e bl 19484 <rtems_rfs_block_map_grow>
if (rc > 0)
1abc8: e3500000 cmp r0, #0
1abcc: ca0000bf bgt 1aed0 <rtems_rfs_dir_add_entry+0x3b0>
1abd0: e3a03000 mov r3, #0
"block map grow failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
break;
}
read = false;
1abd4: e1a07003 mov r7, r3
}
bpos.bno++;
1abd8: e59dc058 ldr ip, [sp, #88] ; 0x58
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
1abdc: e1a00005 mov r0, r5
}
read = false;
}
bpos.bno++;
1abe0: e28cc001 add ip, ip, #1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
1abe4: e28d1064 add r1, sp, #100 ; 0x64 1abe8: e59d2070 ldr r2, [sp, #112] ; 0x70
}
read = false;
}
bpos.bno++;
1abec: e58dc058 str ip, [sp, #88] ; 0x58
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
1abf0: ebfffcbb bl 19ee4 <rtems_rfs_buffer_handle_request>
if (rc > 0)
1abf4: e3500000 cmp r0, #0
1abf8: ca000093 bgt 1ae4c <rtems_rfs_dir_add_entry+0x32c>
"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);
1abfc: e59d306c ldr r3, [sp, #108] ; 0x6c
if (!read)
1ac00: e3570000 cmp r7, #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);
1ac04: e593701c ldr r7, [r3, #28]
if (!read)
1ac08: 0a000058 beq 1ad70 <rtems_rfs_dir_add_entry+0x250>
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1ac0c: e5958008 ldr r8, [r5, #8] 1ac10: e258e00a subs lr, r8, #10
1ac14: 0affffdd beq 1ab90 <rtems_rfs_dir_add_entry+0x70>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
1ac18: e5d73009 ldrb r3, [r7, #9] 1ac1c: e5d70008 ldrb r0, [r7, #8] 1ac20: e1830400 orr r0, r3, r0, lsl #8
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1ac24: e1500006 cmp r0, r6
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
1ac28: e5d73000 ldrb r3, [r7] 1ac2c: e5d71001 ldrb r1, [r7, #1] 1ac30: e5d7c002 ldrb ip, [r7, #2] 1ac34: e5d72003 ldrb r2, [r7, #3]
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1ac38: 0a000051 beq 1ad84 <rtems_rfs_dir_add_entry+0x264>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
1ac3c: e1a0c40c lsl ip, ip, #8 1ac40: e18cc801 orr ip, ip, r1, lsl #16 1ac44: e18cc002 orr ip, ip, r2 1ac48: e18ccc03 orr ip, ip, r3, lsl #24
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
1ac4c: e3a04000 mov r4, #0 1ac50: ea000017 b 1acb4 <rtems_rfs_dir_add_entry+0x194>
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
1ac54: e595301c ldr r3, [r5, #28] 1ac58: e35c0000 cmp ip, #0 1ac5c: 11500003 cmpne r0, r3
1ac60: 2a000016 bcs 1acc0 <rtems_rfs_dir_add_entry+0x1a0>
1ac64: e5953014 ldr r3, [r5, #20] 1ac68: e153000c cmp r3, ip
1ac6c: 3a000013 bcc 1acc0 <rtems_rfs_dir_add_entry+0x1a0>
rtems_rfs_block_map_close (fs, &map);
return EIO;
}
entry += elength;
offset += elength;
1ac70: e0844000 add r4, r4, r0
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))
1ac74: e154000e cmp r4, lr 1ac78: e1a0a004 mov sl, r4
1ac7c: 2affffc3 bcs 1ab90 <rtems_rfs_dir_add_entry+0x70>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
1ac80: e5d72001 ldrb r2, [r7, #1]
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);
1ac84: e5d7c008 ldrb ip, [r7, #8] 1ac88: e5d70009 ldrb r0, [r7, #9]
eino = rtems_rfs_dir_entry_ino (entry);
1ac8c: e5d71000 ldrb r1, [r7] 1ac90: e1a02802 lsl r2, r2, #16 1ac94: e5d73003 ldrb r3, [r7, #3]
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);
1ac98: e180040c orr r0, r0, ip, lsl #8
eino = rtems_rfs_dir_entry_ino (entry);
1ac9c: e1822c01 orr r2, r2, r1, lsl #24 1aca0: e5d7c002 ldrb ip, [r7, #2] 1aca4: e1822003 orr r2, r2, r3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1aca8: e1500006 cmp r0, r6
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
1acac: e182c40c orr ip, r2, ip, lsl #8
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1acb0: 0a000034 beq 1ad88 <rtems_rfs_dir_add_entry+0x268>
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
1acb4: e350000a cmp r0, #10
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return EIO;
}
entry += elength;
1acb8: e0877000 add r7, r7, r0
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
1acbc: caffffe4 bgt 1ac54 <rtems_rfs_dir_add_entry+0x134>
1acc0: e1a0a000 mov sl, r0 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
1acc4: e3a01000 mov r1, #0 <== NOT EXECUTED 1acc8: e3a00202 mov r0, #536870912 ; 0x20000000 <== NOT EXECUTED 1accc: e1a0800c mov r8, ip <== NOT EXECUTED 1acd0: ebffded6 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1acd4: e3500000 cmp r0, #0 <== NOT EXECUTED 1acd8: 0a000006 beq 1acf8 <rtems_rfs_dir_add_entry+0x1d8> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
1acdc: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 1ace0: e1a0200a mov r2, sl <== NOT EXECUTED 1ace4: e5901008 ldr r1, [r0, #8] <== NOT EXECUTED 1ace8: e1a03008 mov r3, r8 <== NOT EXECUTED 1acec: e59f0248 ldr r0, [pc, #584] ; 1af3c <rtems_rfs_dir_add_entry+0x41c><== NOT EXECUTED 1acf0: e58d4000 str r4, [sp] <== NOT EXECUTED 1acf4: eb0015ea bl 204a4 <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);
1acf8: e28d1064 add r1, sp, #100 ; 0x64 <== NOT EXECUTED 1acfc: e1a00005 mov r0, r5 <== NOT EXECUTED 1ad00: ebfffbfe bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
1ad04: e3a03000 mov r3, #0 <== 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);
rtems_rfs_block_map_close (fs, &map);
1ad08: e1a00005 mov r0, r5 <== NOT EXECUTED 1ad0c: e28d1008 add r1, sp, #8 <== NOT EXECUTED 1ad10: e5cd3064 strb r3, [sp, #100] ; 0x64 <== NOT EXECUTED
handle->bnum = 0;
1ad14: e58d3068 str r3, [sp, #104] ; 0x68 <== NOT EXECUTED
handle->buffer = NULL;
1ad18: e58d306c str r3, [sp, #108] ; 0x6c <== NOT EXECUTED
return EIO;
1ad1c: e3a04005 mov r4, #5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
printf ("rtems-rfs: dir-add-entry: "
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04x\n",
rtems_rfs_inode_ino (dir), elength, eino, offset);
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
1ad20: ebfff8de bl 190a0 <rtems_rfs_block_map_close> <== NOT EXECUTED
return EIO;
1ad24: eaffff8e b 1ab64 <rtems_rfs_dir_add_entry+0x44> <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
1ad28: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 1ad2c: e59f020c ldr r0, [pc, #524] ; 1af40 <rtems_rfs_dir_add_entry+0x420><== NOT EXECUTED 1ad30: e5921008 ldr r1, [r2, #8] <== NOT EXECUTED 1ad34: eb0015da bl 204a4 <printf> <== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
1ad38: e3590000 cmp r9, #0 <== NOT EXECUTED 1ad3c: 0a000007 beq 1ad60 <rtems_rfs_dir_add_entry+0x240> <== NOT EXECUTED 1ad40: e3a03000 mov r3, #0 <== NOT EXECUTED 1ad44: e1a04003 mov r4, r3 <== NOT EXECUTED
printf ("%c", name[c]);
1ad48: e7db0003 ldrb r0, [fp, r3] <== 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++)
1ad4c: e2844001 add r4, r4, #1 <== NOT EXECUTED
printf ("%c", name[c]);
1ad50: eb00163d bl 2064c <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++)
1ad54: e1540009 cmp r4, r9 <== NOT EXECUTED 1ad58: e1a03004 mov r3, r4 <== NOT EXECUTED 1ad5c: 1afffff9 bne 1ad48 <rtems_rfs_dir_add_entry+0x228> <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%zd\n", length);
1ad60: e1a01009 mov r1, r9 <== NOT EXECUTED 1ad64: e59f01d8 ldr r0, [pc, #472] ; 1af44 <rtems_rfs_dir_add_entry+0x424><== NOT EXECUTED 1ad68: eb0015cd bl 204a4 <printf> <== NOT EXECUTED 1ad6c: eaffff76 b 1ab4c <rtems_rfs_dir_add_entry+0x2c> <== NOT EXECUTED
}
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
1ad70: e1a00007 mov r0, r7 1ad74: e3a010ff mov r1, #255 ; 0xff 1ad78: e5952008 ldr r2, [r5, #8] 1ad7c: eb001557 bl 202e0 <memset> 1ad80: eaffffa1 b 1ac0c <rtems_rfs_dir_add_entry+0xec>
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1ad84: e3a0a000 mov sl, #0
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) <
1ad88: e289300a add r3, r9, #10
(rtems_rfs_fs_block_size (fs) - offset))
1ad8c: e06a8008 rsb r8, sl, r8
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) <
1ad90: e1530008 cmp r3, r8
1ad94: 2affff7d bcs 1ab90 <rtems_rfs_dir_add_entry+0x70>
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
1ad98: e1a01009 mov r1, r9 1ad9c: e1a0000b mov r0, fp 1ada0: e58d3004 str r3, [sp, #4] 1ada4: eb00115e bl 1f324 <rtems_rfs_dir_hash>
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
1ada8: e59d3098 ldr r3, [sp, #152] ; 0x98
rtems_rfs_dir_set_entry_length (entry,
1adac: e59d2004 ldr r2, [sp, #4]
(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);
1adb0: e1a0e823 lsr lr, r3, #16 1adb4: e1a0c423 lsr ip, r3, #8 1adb8: e1a04c23 lsr r4, r3, #24
rtems_rfs_dir_set_entry_length (entry,
1adbc: e1a03422 lsr r3, r2, #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);
1adc0: e1a0ac20 lsr sl, r0, #24 1adc4: e1a08820 lsr r8, r0, #16 1adc8: e1a06420 lsr r6, r0, #8 1adcc: e5c70007 strb r0, [r7, #7]
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
1add0: e5c73008 strb r3, [r7, #8]
(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);
1add4: e59d0098 ldr r0, [sp, #152] ; 0x98
rtems_rfs_dir_set_entry_length (entry,
1add8: e59d3004 ldr r3, [sp, #4]
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
1addc: e1a02009 mov r2, r9 1ade0: e1a0100b mov r1, fp
(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);
1ade4: e5c74000 strb r4, [r7] 1ade8: e5c7e001 strb lr, [r7, #1] 1adec: e5c7c002 strb ip, [r7, #2] 1adf0: e5c70003 strb r0, [r7, #3]
rtems_rfs_dir_set_entry_length (entry,
1adf4: e5c73009 strb r3, [r7, #9]
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);
1adf8: e5c7a004 strb sl, [r7, #4] 1adfc: e5c78005 strb r8, [r7, #5] 1ae00: e5c76006 strb r6, [r7, #6]
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
1ae04: e287000a add r0, r7, #10 1ae08: eb0014b1 bl 200d4 <memcpy>
*/
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);
1ae0c: e28d1064 add r1, sp, #100 ; 0x64
rtems_rfs_buffer_mark_dirty (&buffer);
1ae10: e3a03001 mov r3, #1 1ae14: e1a00005 mov r0, r5
handle->dirty = false;
1ae18: e3a04000 mov r4, #0 1ae1c: e5cd3064 strb r3, [sp, #100] ; 0x64
*/
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);
1ae20: ebfffbb6 bl 19d00 <rtems_rfs_buffer_handle_release>
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
1ae24: e1a00005 mov r0, r5 1ae28: e28d1008 add r1, sp, #8
handle->dirty = false;
1ae2c: e5cd4064 strb r4, [sp, #100] ; 0x64
handle->bnum = 0;
1ae30: e58d4068 str r4, [sp, #104] ; 0x68
handle->buffer = NULL;
1ae34: e58d406c str r4, [sp, #108] ; 0x6c 1ae38: ebfff898 bl 190a0 <rtems_rfs_block_map_close>
return 0;
1ae3c: eaffff48 b 1ab64 <rtems_rfs_dir_add_entry+0x44>
* 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);
if (rc > 0)
1ae40: e3a03001 mov r3, #1
while (true)
{
rtems_rfs_block_no block;
uint8_t* entry;
int offset;
bool read = true;
1ae44: e1a07003 mov r7, r3 1ae48: eaffff62 b 1abd8 <rtems_rfs_dir_add_entry+0xb8>
1ae4c: e1a04000 mov r4, r0 <== NOT EXECUTED
bpos.bno++;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
1ae50: e3a01000 mov r1, #0 <== NOT EXECUTED 1ae54: e3a00202 mov r0, #536870912 ; 0x20000000 <== NOT EXECUTED 1ae58: ebffde74 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1ae5c: e3500000 cmp r0, #0 <== NOT EXECUTED 1ae60: 1a00002a bne 1af10 <rtems_rfs_dir_add_entry+0x3f0> <== 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);
1ae64: e28d1064 add r1, sp, #100 ; 0x64 <== NOT EXECUTED 1ae68: e1a00005 mov r0, r5 <== NOT EXECUTED 1ae6c: ebfffba3 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
1ae70: e3a03000 mov r3, #0 <== NOT EXECUTED
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
1ae74: e1a00005 mov r0, r5 <== NOT EXECUTED 1ae78: e28d1008 add r1, sp, #8 <== NOT EXECUTED 1ae7c: e5cd3064 strb r3, [sp, #100] ; 0x64 <== NOT EXECUTED
handle->bnum = 0;
1ae80: e58d3068 str r3, [sp, #104] ; 0x68 <== NOT EXECUTED
handle->buffer = NULL;
1ae84: e58d306c str r3, [sp, #108] ; 0x6c <== NOT EXECUTED 1ae88: ebfff884 bl 190a0 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
1ae8c: eaffff34 b 1ab64 <rtems_rfs_dir_add_entry+0x44> <== NOT EXECUTED 1ae90: e1a04000 mov r4, r0 <== NOT EXECUTED
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
if (rc > 0)
{
if (rc != ENXIO)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
1ae94: e3a01000 mov r1, #0 <== NOT EXECUTED 1ae98: e3a00202 mov r0, #536870912 ; 0x20000000 <== NOT EXECUTED 1ae9c: ebffde63 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1aea0: e3500000 cmp r0, #0 <== NOT EXECUTED 1aea4: 0affffee beq 1ae64 <rtems_rfs_dir_add_entry+0x344> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
1aea8: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 1aeac: e1a00004 mov r0, r4 <== NOT EXECUTED 1aeb0: e5936008 ldr r6, [r3, #8] <== NOT EXECUTED 1aeb4: eb001a28 bl 2175c <strerror> <== NOT EXECUTED 1aeb8: e1a01006 mov r1, r6 <== NOT EXECUTED 1aebc: e1a03000 mov r3, r0 <== NOT EXECUTED 1aec0: e1a02004 mov r2, r4 <== NOT EXECUTED 1aec4: e59f007c ldr r0, [pc, #124] ; 1af48 <rtems_rfs_dir_add_entry+0x428><== NOT EXECUTED 1aec8: eb001575 bl 204a4 <printf> <== NOT EXECUTED 1aecc: eaffffe4 b 1ae64 <rtems_rfs_dir_add_entry+0x344> <== NOT EXECUTED 1aed0: e1a04000 mov r4, r0 <== NOT EXECUTED
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
1aed4: e3a01000 mov r1, #0 <== NOT EXECUTED 1aed8: e3a00202 mov r0, #536870912 ; 0x20000000 <== NOT EXECUTED 1aedc: ebffde53 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1aee0: e3500000 cmp r0, #0 <== NOT EXECUTED 1aee4: 0affffde beq 1ae64 <rtems_rfs_dir_add_entry+0x344> <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
1aee8: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 1aeec: e5906008 ldr r6, [r0, #8] <== NOT EXECUTED 1aef0: e1a00004 mov r0, r4 <== NOT EXECUTED 1aef4: eb001a18 bl 2175c <strerror> <== NOT EXECUTED 1aef8: e1a01006 mov r1, r6 <== NOT EXECUTED 1aefc: e1a03000 mov r3, r0 <== NOT EXECUTED 1af00: e1a02004 mov r2, r4 <== NOT EXECUTED 1af04: e59f0040 ldr r0, [pc, #64] ; 1af4c <rtems_rfs_dir_add_entry+0x42c><== NOT EXECUTED 1af08: eb001565 bl 204a4 <printf> <== NOT EXECUTED 1af0c: eaffffd4 b 1ae64 <rtems_rfs_dir_add_entry+0x344> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
printf ("rtems-rfs: dir-add-entry: "
1af10: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 1af14: e1a00004 mov r0, r4 <== NOT EXECUTED 1af18: e5926008 ldr r6, [r2, #8] <== NOT EXECUTED 1af1c: eb001a0e bl 2175c <strerror> <== NOT EXECUTED 1af20: e1a01006 mov r1, r6 <== NOT EXECUTED 1af24: e1a03000 mov r3, r0 <== NOT EXECUTED 1af28: e1a02004 mov r2, r4 <== NOT EXECUTED 1af2c: e59f001c ldr r0, [pc, #28] ; 1af50 <rtems_rfs_dir_add_entry+0x430><== NOT EXECUTED 1af30: eb00155b bl 204a4 <printf> <== NOT EXECUTED 1af34: eaffffca b 1ae64 <rtems_rfs_dir_add_entry+0x344> <== NOT EXECUTED
0001af54 <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)
{
1af54: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1af58: e24dd074 sub sp, sp, #116 ; 0x74
1af5c: e58d100c str r1, [sp, #12]
1af60: e1a04000 mov r4, r0
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
1af64: e3a01000 mov r1, #0 1af68: e3a00101 mov r0, #1073741824 ; 0x40000000
int
rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_ino ino,
uint32_t offset)
{
1af6c: e1a09002 mov r9, r2 1af70: e58d3010 str r3, [sp, #16]
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
1af74: ebffde2d bl 12830 <rtems_rfs_trace> 1af78: e3500000 cmp r0, #0
1af7c: 1a000008 bne 1afa4 <rtems_rfs_dir_del_entry+0x50>
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
1af80: e1a00004 mov r0, r4 1af84: e59d100c ldr r1, [sp, #12] 1af88: e28d2014 add r2, sp, #20 1af8c: ebfff7e9 bl 18f38 <rtems_rfs_block_map_open>
if (rc > 0)
1af90: e2506000 subs r6, r0, #0
1af94: da00000e ble 1afd4 <rtems_rfs_dir_del_entry+0x80>
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
1af98: e1a00006 mov r0, r6
1af9c: e28dd074 add sp, sp, #116 ; 0x74
1afa0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
1afa4: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 1afa8: e1a02009 mov r2, r9 <== NOT EXECUTED 1afac: e59c1008 ldr r1, [ip, #8] <== NOT EXECUTED 1afb0: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 1afb4: e59f03dc ldr r0, [pc, #988] ; 1b398 <rtems_rfs_dir_del_entry+0x444><== NOT EXECUTED 1afb8: eb001539 bl 204a4 <printf> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
1afbc: e1a00004 mov r0, r4 <== NOT EXECUTED 1afc0: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 1afc4: e28d2014 add r2, sp, #20 <== NOT EXECUTED 1afc8: ebfff7da bl 18f38 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
1afcc: e2506000 subs r6, r0, #0 <== NOT EXECUTED 1afd0: cafffff0 bgt 1af98 <rtems_rfs_dir_del_entry+0x44> <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
1afd4: e3a05000 mov r5, #0 1afd8: e28dc070 add ip, sp, #112 ; 0x70 1afdc: e1a00004 mov r0, r4 1afe0: e28d1014 add r1, sp, #20 1afe4: e59d2010 ldr r2, [sp, #16] 1afe8: e1a03005 mov r3, r5 1afec: e58dc000 str ip, [sp] 1aff0: ebfff8f7 bl 193d4 <rtems_rfs_block_map_seek>
if (rc > 0)
1aff4: e2506000 subs r6, r0, #0
1aff8: da000005 ble 1b014 <rtems_rfs_dir_del_entry+0xc0>
{
if (rc == ENXIO)
rc = ENOENT;
1affc: e3560006 cmp r6, #6 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
1b000: e1a00004 mov r0, r4 <== NOT EXECUTED 1b004: e28d1014 add r1, sp, #20 <== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
if (rc > 0)
{
if (rc == ENXIO)
rc = ENOENT;
1b008: 03a06002 moveq r6, #2 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
1b00c: ebfff823 bl 190a0 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
1b010: eaffffe0 b 1af98 <rtems_rfs_dir_del_entry+0x44> <== NOT EXECUTED
}
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
1b014: e59d3010 ldr r3, [sp, #16]
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
1b018: e5cd5064 strb r5, [sp, #100] ; 0x64 1b01c: e273b001 rsbs fp, r3, #1
handle->bnum = 0;
1b020: e58d5068 str r5, [sp, #104] ; 0x68
handle->buffer = NULL;
1b024: e58d506c str r5, [sp, #108] ; 0x6c
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1b028: e59fc36c ldr ip, [pc, #876] ; 1b39c <rtems_rfs_dir_del_entry+0x448>
}
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
1b02c: 33a0b000 movcc fp, #0
while (rc == 0)
{
uint8_t* entry;
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
1b030: e1a00004 mov r0, r4 1b034: e28d1064 add r1, sp, #100 ; 0x64 1b038: e59d2070 ldr r2, [sp, #112] ; 0x70 1b03c: e3a03001 mov r3, #1 1b040: e58dc008 str ip, [sp, #8] 1b044: ebfffba6 bl 19ee4 <rtems_rfs_buffer_handle_request>
if (rc > 0)
1b048: e2506000 subs r6, r0, #0 1b04c: e59dc008 ldr ip, [sp, #8]
1b050: ca0000c1 bgt 1b35c <rtems_rfs_dir_del_entry+0x408>
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
1b054: e35b0000 cmp fp, #0
1b058: 0a000047 beq 1b17c <rtems_rfs_dir_del_entry+0x228>
1b05c: e3a02000 mov r2, #0 <== NOT EXECUTED 1b060: e5947008 ldr r7, [r4, #8] <== NOT EXECUTED
eoffset = 0;
1b064: e1a00002 mov r0, r2 <== 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))
1b068: e247a00a sub sl, r7, #10
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
1b06c: e59d306c ldr r3, [sp, #108] ; 0x6c
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1b070: e152000a cmp r2, sl
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
1b074: e593101c ldr r1, [r3, #28]
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1b078: 2a000047 bcs 1b19c <rtems_rfs_dir_del_entry+0x248>
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
1b07c: e0813002 add r3, r1, r2
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);
1b080: e5d3e009 ldrb lr, [r3, #9] 1b084: e5d38008 ldrb r8, [r3, #8] 1b088: e18e8408 orr r8, lr, r8, lsl #8
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1b08c: e158000c cmp r8, ip
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
1b090: e7d12002 ldrb r2, [r1, r2] 1b094: e5d35001 ldrb r5, [r3, #1] 1b098: e5d3e002 ldrb lr, [r3, #2] 1b09c: e5d31003 ldrb r1, [r3, #3]
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1b0a0: 0a00003d beq 1b19c <rtems_rfs_dir_del_entry+0x248>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
1b0a4: e1a05805 lsl r5, r5, #16 1b0a8: e185540e orr r5, r5, lr, lsl #8 1b0ac: e1855001 orr r5, r5, r1 1b0b0: e1855c02 orr r5, r5, r2, lsl #24 1b0b4: ea00001b b 1b128 <rtems_rfs_dir_del_entry+0x1d4>
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
1b0b8: e594201c ldr r2, [r4, #28] 1b0bc: e3550000 cmp r5, #0 1b0c0: 11580002 cmpne r8, r2
1b0c4: 2a000019 bcs 1b130 <rtems_rfs_dir_del_entry+0x1dc>
1b0c8: e5942014 ldr r2, [r4, #20] 1b0cc: e1520005 cmp r2, r5
1b0d0: 3a000016 bcc 1b130 <rtems_rfs_dir_del_entry+0x1dc>
rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
rc = EIO;
break;
}
if (ino == rtems_rfs_dir_entry_ino (entry))
1b0d4: e1590005 cmp r9, r5
1b0d8: 0a000047 beq 1b1fc <rtems_rfs_dir_del_entry+0x2a8>
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return 0;
}
if (!search)
1b0dc: e35b0000 cmp fp, #0 <== NOT EXECUTED
{
rc = EIO;
break;
}
entry += elength;
1b0e0: e0833008 add r3, r3, r8 <== NOT EXECUTED
eoffset += elength;
1b0e4: e0800008 add r0, r0, r8 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return 0;
}
if (!search)
1b0e8: 0a000017 beq 1b14c <rtems_rfs_dir_del_entry+0x1f8> <== 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))
1b0ec: e150000a cmp r0, sl <== NOT EXECUTED 1b0f0: 2a000029 bcs 1b19c <rtems_rfs_dir_del_entry+0x248> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
1b0f4: e5d31001 ldrb r1, [r3, #1] <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
1b0f8: e5d35009 ldrb r5, [r3, #9] <== NOT EXECUTED 1b0fc: e5d38008 ldrb r8, [r3, #8] <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
1b100: e5d3e000 ldrb lr, [r3] <== NOT EXECUTED 1b104: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 1b108: e5d32003 ldrb r2, [r3, #3] <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
1b10c: e1858408 orr r8, r5, r8, lsl #8 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
1b110: e1811c0e orr r1, r1, lr, lsl #24 <== NOT EXECUTED 1b114: e5d35002 ldrb r5, [r3, #2] <== NOT EXECUTED 1b118: e1811002 orr r1, r1, r2 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1b11c: e158000c cmp r8, ip <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
1b120: e1815405 orr r5, r1, r5, lsl #8 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1b124: 0a00001c beq 1b19c <rtems_rfs_dir_del_entry+0x248> <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
1b128: e358000a cmp r8, #10
1b12c: caffffe1 bgt 1b0b8 <rtems_rfs_dir_del_entry+0x164>
1b130: e1a0a005 mov sl, r5 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
1b134: e3a01000 mov r1, #0 <== NOT EXECUTED 1b138: e1a05000 mov r5, r0 <== NOT EXECUTED 1b13c: e3a00101 mov r0, #1073741824 ; 0x40000000 <== NOT EXECUTED 1b140: ebffddba bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1b144: e3500000 cmp r0, #0 <== NOT EXECUTED 1b148: 1a000021 bne 1b1d4 <rtems_rfs_dir_del_entry+0x280> <== NOT EXECUTED
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
1b14c: e3a06005 mov r6, #5 <== 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);
1b150: e28d1064 add r1, sp, #100 ; 0x64 <== NOT EXECUTED 1b154: e1a00004 mov r0, r4 <== NOT EXECUTED 1b158: ebfffae8 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
1b15c: e3a03000 mov r3, #0 <== NOT EXECUTED
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
1b160: e1a00004 mov r0, r4 <== NOT EXECUTED 1b164: e28d1014 add r1, sp, #20 <== NOT EXECUTED 1b168: e5cd3064 strb r3, [sp, #100] ; 0x64 <== NOT EXECUTED
handle->bnum = 0;
1b16c: e58d3068 str r3, [sp, #104] ; 0x68 <== NOT EXECUTED
handle->buffer = NULL;
1b170: e58d306c str r3, [sp, #108] ; 0x6c <== NOT EXECUTED 1b174: ebfff7c9 bl 190a0 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
1b178: eaffff86 b 1af98 <rtems_rfs_dir_del_entry+0x44> <== NOT EXECUTED
* skip to the offset in the block.
*/
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
1b17c: e5947008 ldr r7, [r4, #8] 1b180: e59d0010 ldr r0, [sp, #16] 1b184: e1a01007 mov r1, r7 1b188: e58dc008 str ip, [sp, #8] 1b18c: eb004799 bl 2cff8 <__umodsi3> 1b190: e59dc008 ldr ip, [sp, #8] 1b194: e1a02000 mov r2, r0 1b198: eaffffb2 b 1b068 <rtems_rfs_dir_del_entry+0x114>
entry += elength;
eoffset += elength;
}
if (rc == 0)
1b19c: e3560000 cmp r6, #0 <== NOT EXECUTED 1b1a0: 1affffea bne 1b150 <rtems_rfs_dir_del_entry+0x1fc> <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
1b1a4: e1a00004 mov r0, r4 <== NOT EXECUTED 1b1a8: e28d1014 add r1, sp, #20 <== NOT EXECUTED 1b1ac: e28d2070 add r2, sp, #112 ; 0x70 <== NOT EXECUTED 1b1b0: e58dc008 str ip, [sp, #8] <== NOT EXECUTED 1b1b4: ebfff8a5 bl 19450 <rtems_rfs_block_map_next_block> <== NOT EXECUTED
if (rc == ENXIO)
1b1b8: e3500006 cmp r0, #6 <== NOT EXECUTED
eoffset += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
1b1bc: e1a06000 mov r6, r0 <== NOT EXECUTED
if (rc == ENXIO)
1b1c0: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED 1b1c4: 0a000062 beq 1b354 <rtems_rfs_dir_del_entry+0x400> <== NOT EXECUTED
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
1b1c8: e3500000 cmp r0, #0 <== NOT EXECUTED 1b1cc: 0affff97 beq 1b030 <rtems_rfs_dir_del_entry+0xdc> <== NOT EXECUTED 1b1d0: eaffffde b 1b150 <rtems_rfs_dir_del_entry+0x1fc> <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: "
1b1d4: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 1b1d8: e59c1008 ldr r1, [ip, #8] <== NOT EXECUTED 1b1dc: e59dc070 ldr ip, [sp, #112] ; 0x70 <== NOT EXECUTED 1b1e0: e1a02008 mov r2, r8 <== NOT EXECUTED 1b1e4: e1a0300a mov r3, sl <== NOT EXECUTED 1b1e8: e59f01b0 ldr r0, [pc, #432] ; 1b3a0 <rtems_rfs_dir_del_entry+0x44c><== NOT EXECUTED 1b1ec: e58dc000 str ip, [sp] <== NOT EXECUTED 1b1f0: e58d5004 str r5, [sp, #4] <== NOT EXECUTED 1b1f4: eb0014aa bl 204a4 <printf> <== NOT EXECUTED 1b1f8: eaffffd3 b 1b14c <rtems_rfs_dir_del_entry+0x1f8> <== NOT EXECUTED
1b1fc: e1a02007 mov r2, r7
}
if (ino == rtems_rfs_dir_entry_ino (entry))
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
1b200: e0886000 add r6, r8, r0 1b204: e0666002 rsb r6, r6, r2 1b208: e1a07003 mov r7, r3
memmove (entry, entry + elength, remaining);
1b20c: e0831008 add r1, r3, r8 1b210: e1a02006 mov r2, r6 1b214: e1a05000 mov r5, r0 1b218: e1a00003 mov r0, r3 1b21c: eb0013e2 bl 201ac <memmove>
memset (entry + remaining, 0xff, elength);
1b220: e3a010ff mov r1, #255 ; 0xff 1b224: e1a02008 mov r2, r8 1b228: e0870006 add r0, r7, r6 1b22c: eb00142b bl 202e0 <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);
1b230: e5d76008 ldrb r6, [r7, #8] 1b234: e5d73009 ldrb r3, [r7, #9]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
1b238: e3a00101 mov r0, #1073741824 ; 0x40000000 1b23c: 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);
1b240: e1836406 orr r6, r3, r6, lsl #8
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
1b244: ebffdd79 bl 12830 <rtems_rfs_trace> 1b248: e3500000 cmp r0, #0
1b24c: 0a000011 beq 1b298 <rtems_rfs_dir_del_entry+0x344>
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");
1b250: e59d2024 ldr r2, [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: "
1b254: e3520000 cmp r2, #0 <== 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");
1b258: e59d101c ldr r1, [sp, #28] <== 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: "
1b25c: e59d3070 ldr r3, [sp, #112] ; 0x70 <== NOT EXECUTED 1b260: 1a000002 bne 1b270 <rtems_rfs_dir_del_entry+0x31c> <== 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");
1b264: e3510000 cmp r1, #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: "
1b268: 059fc134 ldreq ip, [pc, #308] ; 1b3a4 <rtems_rfs_dir_del_entry+0x450><== 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");
1b26c: 0a000004 beq 1b284 <rtems_rfs_dir_del_entry+0x330> <== NOT EXECUTED 1b270: e2411001 sub r1, r1, #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: "
1b274: e59f0128 ldr r0, [pc, #296] ; 1b3a4 <rtems_rfs_dir_del_entry+0x450><== NOT EXECUTED
1b278: e1520001 cmp r2, r1 <== NOT EXECUTED
1b27c: e59fc124 ldr ip, [pc, #292] ; 1b3a8 <rtems_rfs_dir_del_entry+0x454><== NOT EXECUTED
1b280: 01a0c000 moveq ip, r0 <== NOT EXECUTED
1b284: e59f0120 ldr r0, [pc, #288] ; 1b3ac <rtems_rfs_dir_del_entry+0x458><== NOT EXECUTED
1b288: e1a01009 mov r1, r9 <== NOT EXECUTED
1b28c: e1a02006 mov r2, r6 <== NOT EXECUTED
1b290: e88d1020 stm sp, {r5, ip} <== NOT EXECUTED
1b294: eb001482 bl 204a4 <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) &&
1b298: e59f30fc ldr r3, [pc, #252] ; 1b39c <rtems_rfs_dir_del_entry+0x448> 1b29c: e1560003 cmp r6, r3 1b2a0: 03550000 cmpeq r5, #0
1b2a4: 1a000019 bne 1b310 <rtems_rfs_dir_del_entry+0x3bc>
(eoffset == 0) && rtems_rfs_block_map_last (&map))
1b2a8: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 1b2ac: e3530000 cmp r3, #0 <== NOT EXECUTED 1b2b0: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED 1b2b4: 1a000022 bne 1b344 <rtems_rfs_dir_del_entry+0x3f0> <== NOT EXECUTED 1b2b8: e3520000 cmp r2, #0 <== NOT EXECUTED 1b2bc: 1a000020 bne 1b344 <rtems_rfs_dir_del_entry+0x3f0> <== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
1b2c0: e1a00004 mov r0, r4 <== NOT EXECUTED 1b2c4: e28d1014 add r1, sp, #20 <== NOT EXECUTED 1b2c8: e3a02001 mov r2, #1 <== NOT EXECUTED 1b2cc: ebfff96a bl 1987c <rtems_rfs_block_map_shrink> <== NOT EXECUTED
if (rc > 0)
1b2d0: e2505000 subs r5, r0, #0 <== NOT EXECUTED 1b2d4: da00000d ble 1b310 <rtems_rfs_dir_del_entry+0x3bc> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
1b2d8: e3a00101 mov r0, #1073741824 ; 0x40000000 <== NOT EXECUTED 1b2dc: e3a01000 mov r1, #0 <== NOT EXECUTED 1b2e0: ebffdd52 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1b2e4: e3500000 cmp r0, #0 <== NOT EXECUTED 1b2e8: 0a000008 beq 1b310 <rtems_rfs_dir_del_entry+0x3bc> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
1b2ec: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 1b2f0: e1a00005 mov r0, r5 <== NOT EXECUTED 1b2f4: e59c6008 ldr r6, [ip, #8] <== NOT EXECUTED 1b2f8: eb001917 bl 2175c <strerror> <== NOT EXECUTED 1b2fc: e1a01006 mov r1, r6 <== NOT EXECUTED 1b300: e1a03000 mov r3, r0 <== NOT EXECUTED 1b304: e1a02005 mov r2, r5 <== NOT EXECUTED 1b308: e59f00a0 ldr r0, [pc, #160] ; 1b3b0 <rtems_rfs_dir_del_entry+0x45c><== NOT EXECUTED 1b30c: eb001464 bl 204a4 <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);
1b310: e28d1064 add r1, sp, #100 ; 0x64
"block map shrink failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
1b314: e3a03001 mov r3, #1 1b318: e1a00004 mov r0, r4
handle->dirty = false;
1b31c: e3a06000 mov r6, #0 1b320: e5cd3064 strb r3, [sp, #100] ; 0x64
*/
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);
1b324: ebfffa75 bl 19d00 <rtems_rfs_buffer_handle_release>
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
1b328: e1a00004 mov r0, r4 1b32c: e28d1014 add r1, sp, #20
handle->dirty = false;
1b330: e5cd6064 strb r6, [sp, #100] ; 0x64
handle->bnum = 0;
1b334: e58d6068 str r6, [sp, #104] ; 0x68
handle->buffer = NULL;
1b338: e58d606c str r6, [sp, #108] ; 0x6c 1b33c: ebfff757 bl 190a0 <rtems_rfs_block_map_close>
return 0;
1b340: eaffff14 b 1af98 <rtems_rfs_dir_del_entry+0x44>
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
(eoffset == 0) && rtems_rfs_block_map_last (&map))
1b344: e2422001 sub r2, r2, #1 <== NOT EXECUTED 1b348: e1530002 cmp r3, r2 <== NOT EXECUTED 1b34c: 1affffef bne 1b310 <rtems_rfs_dir_del_entry+0x3bc> <== NOT EXECUTED 1b350: eaffffda b 1b2c0 <rtems_rfs_dir_del_entry+0x36c> <== NOT EXECUTED
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
1b354: e3a06002 mov r6, #2 <== NOT EXECUTED 1b358: eaffff7c b 1b150 <rtems_rfs_dir_del_entry+0x1fc> <== NOT EXECUTED
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
1b35c: e3a00101 mov r0, #1073741824 ; 0x40000000 <== NOT EXECUTED 1b360: e3a01000 mov r1, #0 <== NOT EXECUTED 1b364: ebffdd31 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1b368: e3500000 cmp r0, #0 <== NOT EXECUTED 1b36c: 0affff77 beq 1b150 <rtems_rfs_dir_del_entry+0x1fc> <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
1b370: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 1b374: e1a00006 mov r0, r6 <== NOT EXECUTED 1b378: e59c5008 ldr r5, [ip, #8] <== NOT EXECUTED 1b37c: eb0018f6 bl 2175c <strerror> <== NOT EXECUTED 1b380: e1a01005 mov r1, r5 <== NOT EXECUTED 1b384: e1a03000 mov r3, r0 <== NOT EXECUTED 1b388: e1a02006 mov r2, r6 <== NOT EXECUTED 1b38c: e59f0020 ldr r0, [pc, #32] ; 1b3b4 <rtems_rfs_dir_del_entry+0x460><== NOT EXECUTED 1b390: eb001443 bl 204a4 <printf> <== NOT EXECUTED 1b394: eaffff6d b 1b150 <rtems_rfs_dir_del_entry+0x1fc> <== NOT EXECUTED
0001b730 <rtems_rfs_dir_empty>:
}
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
1b730: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1b734: e1a05000 mov r5, r0
1b738: e24dd064 sub sp, sp, #100 ; 0x64
1b73c: e1a07001 mov r7, r1
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
1b740: e3a00102 mov r0, #-2147483648 ; 0x80000000 1b744: e3a01000 mov r1, #0 1b748: ebffdc38 bl 12830 <rtems_rfs_trace> 1b74c: e3500000 cmp r0, #0
1b750: 1a000008 bne 1b778 <rtems_rfs_dir_empty+0x48>
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
1b754: e1a00005 mov r0, r5 1b758: e1a01007 mov r1, r7 1b75c: e28d2004 add r2, sp, #4 1b760: ebfff5f4 bl 18f38 <rtems_rfs_block_map_open>
if (rc > 0)
1b764: e250b000 subs fp, r0, #0
1b768: da00000b ble 1b79c <rtems_rfs_dir_empty+0x6c>
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
1b76c: e1a0000b mov r0, fp
1b770: e28dd064 add sp, sp, #100 ; 0x64
1b774: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
1b778: e5971008 ldr r1, [r7, #8] <== NOT EXECUTED 1b77c: e59f01f0 ldr r0, [pc, #496] ; 1b974 <rtems_rfs_dir_empty+0x244><== NOT EXECUTED 1b780: eb001347 bl 204a4 <printf> <== NOT EXECUTED
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
1b784: e1a00005 mov r0, r5 <== NOT EXECUTED 1b788: e1a01007 mov r1, r7 <== NOT EXECUTED 1b78c: e28d2004 add r2, sp, #4 <== NOT EXECUTED 1b790: ebfff5e8 bl 18f38 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
1b794: e250b000 subs fp, r0, #0 <== NOT EXECUTED 1b798: cafffff3 bgt 1b76c <rtems_rfs_dir_empty+0x3c> <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
1b79c: e28d8060 add r8, sp, #96 ; 0x60 1b7a0: e1a00005 mov r0, r5 1b7a4: e28d1004 add r1, sp, #4 1b7a8: e3a02000 mov r2, #0 1b7ac: e3a03000 mov r3, #0 1b7b0: e58d8000 str r8, [sp] 1b7b4: ebfff706 bl 193d4 <rtems_rfs_block_map_seek>
if (rc > 0)
1b7b8: e250b000 subs fp, r0, #0
1b7bc: ca000068 bgt 1b964 <rtems_rfs_dir_empty+0x234>
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
1b7c0: e3a03000 mov r3, #0 1b7c4: e5cd3054 strb r3, [sp, #84] ; 0x54
handle->bnum = 0;
1b7c8: e58d3058 str r3, [sp, #88] ; 0x58
handle->buffer = NULL;
1b7cc: 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)
1b7d0: e59f61a0 ldr r6, [pc, #416] ; 1b978 <rtems_rfs_dir_empty+0x248>
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
1b7d4: e1a00005 mov r0, r5 1b7d8: e28d1054 add r1, sp, #84 ; 0x54 1b7dc: e59d2060 ldr r2, [sp, #96] ; 0x60 1b7e0: e3a03001 mov r3, #1 1b7e4: ebfff9be bl 19ee4 <rtems_rfs_buffer_handle_request>
if (rc > 0)
1b7e8: e250b000 subs fp, r0, #0
1b7ec: ca00003c bgt 1b8e4 <rtems_rfs_dir_empty+0x1b4>
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1b7f0: e5951008 ldr r1, [r5, #8]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
1b7f4: e59d305c ldr r3, [sp, #92] ; 0x5c
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1b7f8: e251100a subs r1, r1, #10
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
1b7fc: e593301c ldr r3, [r3, #28]
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1b800: 0a000047 beq 1b924 <rtems_rfs_dir_empty+0x1f4>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
1b804: e5d32009 ldrb r2, [r3, #9] 1b808: e5d39008 ldrb r9, [r3, #8] 1b80c: e1829409 orr r9, r2, r9, lsl #8
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1b810: e1590006 cmp r9, r6
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
1b814: e5d32000 ldrb r2, [r3] 1b818: e5d3e001 ldrb lr, [r3, #1] 1b81c: e5d3c002 ldrb ip, [r3, #2] 1b820: e5d30003 ldrb r0, [r3, #3]
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1b824: 0a00003e beq 1b924 <rtems_rfs_dir_empty+0x1f4>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
1b828: e1a0a80e lsl sl, lr, #16 1b82c: e18aa40c orr sl, sl, ip, lsl #8 1b830: e18aa000 orr sl, sl, r0 1b834: e18aac02 orr sl, sl, r2, lsl #24
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
1b838: e3a04000 mov r4, #0 1b83c: ea000018 b 1b8a4 <rtems_rfs_dir_empty+0x174>
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
1b840: e359000c cmp r9, #12
1b844: 1a000024 bne 1b8dc <rtems_rfs_dir_empty+0x1ac>
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
1b848: e5d3200a ldrb r2, [r3, #10] 1b84c: e352002e cmp r2, #46 ; 0x2e
1b850: 1a000021 bne 1b8dc <rtems_rfs_dir_empty+0x1ac>
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
1b854: e5d3200b ldrb r2, [r3, #11] 1b858: e352002e cmp r2, #46 ; 0x2e
1b85c: 1a00001e bne 1b8dc <rtems_rfs_dir_empty+0x1ac>
empty = false;
break;
}
entry += elength;
offset += elength;
1b860: e0844009 add r4, r4, r9
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1b864: e1540001 cmp r4, r1
1b868: 2a00002d bcs 1b924 <rtems_rfs_dir_empty+0x1f4>
{
empty = false;
break;
}
entry += elength;
1b86c: e0833009 add r3, r3, r9
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
1b870: e5d3a001 ldrb sl, [r3, #1] 1b874: e5d32000 ldrb r2, [r3]
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);
1b878: e5d39008 ldrb r9, [r3, #8] 1b87c: e5d3c009 ldrb ip, [r3, #9]
eino = rtems_rfs_dir_entry_ino (entry);
1b880: e1a0a80a lsl sl, sl, #16 1b884: e5d30003 ldrb r0, [r3, #3] 1b888: e18aac02 orr sl, sl, r2, lsl #24
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);
1b88c: e18c9409 orr r9, ip, r9, lsl #8
eino = rtems_rfs_dir_entry_ino (entry);
1b890: e5d32002 ldrb r2, [r3, #2] 1b894: e18aa000 orr sl, sl, r0
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1b898: e1590006 cmp r9, r6
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
1b89c: e18aa402 orr sl, sl, r2, lsl #8
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1b8a0: 0a00001f beq 1b924 <rtems_rfs_dir_empty+0x1f4>
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
1b8a4: e359000a cmp r9, #10
1b8a8: da000018 ble 1b910 <rtems_rfs_dir_empty+0x1e0>
1b8ac: e595201c ldr r2, [r5, #28] 1b8b0: e35a0000 cmp sl, #0 1b8b4: 11590002 cmpne r9, r2
1b8b8: 2a000014 bcs 1b910 <rtems_rfs_dir_empty+0x1e0>
1b8bc: e5952014 ldr r2, [r5, #20] 1b8c0: e152000a cmp r2, sl
1b8c4: 3a000011 bcc 1b910 <rtems_rfs_dir_empty+0x1e0>
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
1b8c8: e359000b cmp r9, #11
1b8cc: 1affffdb bne 1b840 <rtems_rfs_dir_empty+0x110>
1b8d0: e5d3200a ldrb r2, [r3, #10] 1b8d4: e352002e cmp r2, #46 ; 0x2e
1b8d8: 0affffe0 beq 1b860 <rtems_rfs_dir_empty+0x130>
}
}
}
if ((rc == 0) && !empty)
rc = ENOTEMPTY;
1b8dc: e35b0000 cmp fp, #0 1b8e0: 03a0b05a moveq fp, #90 ; 0x5a
*/
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);
1b8e4: e28d1054 add r1, sp, #84 ; 0x54 1b8e8: e1a00005 mov r0, r5 1b8ec: ebfff903 bl 19d00 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
1b8f0: e3a03000 mov r3, #0
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
1b8f4: e1a00005 mov r0, r5 1b8f8: e28d1004 add r1, sp, #4 1b8fc: e5cd3054 strb r3, [sp, #84] ; 0x54
handle->bnum = 0;
1b900: e58d3058 str r3, [sp, #88] ; 0x58
handle->buffer = NULL;
1b904: e58d305c str r3, [sp, #92] ; 0x5c 1b908: ebfff5e4 bl 190a0 <rtems_rfs_block_map_close>
return rc;
1b90c: eaffff96 b 1b76c <rtems_rfs_dir_empty+0x3c>
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
1b910: e3a00000 mov r0, #0 <== NOT EXECUTED 1b914: e3a01001 mov r1, #1 <== NOT EXECUTED 1b918: ebffdbc4 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1b91c: e3500000 cmp r0, #0 <== NOT EXECUTED 1b920: 1a000008 bne 1b948 <rtems_rfs_dir_empty+0x218> <== NOT EXECUTED
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
1b924: e1a00005 mov r0, r5 1b928: e28d1004 add r1, sp, #4 1b92c: e1a02008 mov r2, r8 1b930: ebfff6c6 bl 19450 <rtems_rfs_block_map_next_block>
if (rc > 0)
1b934: e250b000 subs fp, r0, #0
1b938: daffffa5 ble 1b7d4 <rtems_rfs_dir_empty+0xa4>
{
if (rc == ENXIO)
1b93c: e35b0006 cmp fp, #6 1b940: 03a0b000 moveq fp, #0 1b944: eaffffe6 b 1b8e4 <rtems_rfs_dir_empty+0x1b4>
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
printf ("rtems-rfs: dir-empty: "
1b948: e5971008 ldr r1, [r7, #8] <== NOT EXECUTED 1b94c: e1a02009 mov r2, r9 <== NOT EXECUTED 1b950: e1a0300a mov r3, sl <== NOT EXECUTED 1b954: e59f0020 ldr r0, [pc, #32] ; 1b97c <rtems_rfs_dir_empty+0x24c><== NOT EXECUTED 1b958: e58d4000 str r4, [sp] <== NOT EXECUTED 1b95c: eb0012d0 bl 204a4 <printf> <== NOT EXECUTED 1b960: eaffffef b 1b924 <rtems_rfs_dir_empty+0x1f4> <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
if (rc > 0)
{
rtems_rfs_block_map_close (fs, &map);
1b964: e1a00005 mov r0, r5 <== NOT EXECUTED 1b968: e28d1004 add r1, sp, #4 <== NOT EXECUTED 1b96c: ebfff5cb bl 190a0 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
1b970: eaffff7d b 1b76c <rtems_rfs_dir_empty+0x3c> <== NOT EXECUTED
0001f324 <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;
1f324: e59fc1b4 ldr ip, [pc, #436] ; 1f4e0 <rtems_rfs_dir_hash+0x1bc>
} 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)
1f328: e351000c cmp r1, #12
{
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;
1f32c: e081c00c add ip, r1, ip
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
1f330: e92d0ff0 push {r4, r5, r6, r7, r8, r9, sl, fp}
} 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)
1f334: e1a03000 mov r3, r0 1f338: e1a0200c mov r2, ip 1f33c: e1a0a00c mov sl, ip
1f340: 9a00002d bls 1f3fc <rtems_rfs_dir_hash+0xd8>
{
a += k[0];
1f344: e5d36000 ldrb r6, [r3]
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
1f348: e5d30008 ldrb r0, [r3, #8]
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
1f34c: e5d39001 ldrb r9, [r3, #1]
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
1f350: e5d38009 ldrb r8, [r3, #9]
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
1f354: e5d37004 ldrb r7, [r3, #4]
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
1f358: e086a00a add sl, r6, sl
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
1f35c: e080000c add r0, r0, ip
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
1f360: e5d36002 ldrb r6, [r3, #2]
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
1f364: e5d3500a ldrb r5, [r3, #10]
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
1f368: e5d3c003 ldrb ip, [r3, #3]
b += k[4];
b += ((uint32_t)k[5])<<8;
1f36c: e5d3b005 ldrb fp, [r3, #5]
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
1f370: e5d3400b ldrb r4, [r3, #11]
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
1f374: e08aa409 add sl, sl, r9, lsl #8
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
1f378: e0800408 add r0, r0, r8, lsl #8
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
1f37c: e0872002 add r2, r7, r2
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
1f380: e5d39006 ldrb r9, [r3, #6]
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
1f384: e08aa806 add sl, sl, r6, lsl #16
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
1f388: e0800805 add r0, r0, r5, lsl #16
c += ((uint32_t)k[11])<<24;
1f38c: e0804c04 add r4, r0, r4, lsl #24
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
1f390: e08acc0c add ip, sl, ip, lsl #24
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
1f394: e5d30007 ldrb r0, [r3, #7]
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
1f398: e082b40b add fp, r2, fp, lsl #8
b += ((uint32_t)k[6])<<16;
1f39c: e08bb809 add fp, fp, r9, lsl #16
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);
1f3a0: e064c00c rsb ip, r4, ip 1f3a4: e02cce64 eor ip, ip, r4, ror #28
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
1f3a8: e08bbc00 add fp, fp, r0, lsl #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);
1f3ac: e06c900b rsb r9, ip, fp 1f3b0: e0299d6c eor r9, r9, ip, ror #26 1f3b4: e084400b add r4, r4, fp 1f3b8: e0697004 rsb r7, r9, r4 1f3bc: e0277c69 eor r7, r7, r9, ror #24 1f3c0: e08cc004 add ip, ip, r4 1f3c4: e067a00c rsb sl, r7, ip 1f3c8: e02aa867 eor sl, sl, r7, ror #16 1f3cc: e089900c add r9, r9, ip 1f3d0: e06a2009 rsb r2, sl, r9 1f3d4: e02226ea eor r2, r2, sl, ror #13 1f3d8: e0877009 add r7, r7, r9
length -= 12;
1f3dc: 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);
1f3e0: e08aa007 add sl, sl, r7
} 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)
1f3e4: e351000c cmp 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);
1f3e8: e0627007 rsb r7, r2, r7 1f3ec: e027ce62 eor ip, r7, r2, ror #28
length -= 12;
k += 12;
1f3f0: e283300c add r3, r3, #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);
1f3f4: e082200a add r2, r2, sl
} 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)
1f3f8: 8affffd1 bhi 1f344 <rtems_rfs_dir_hash+0x20>
length -= 12;
k += 12;
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
1f3fc: e2411001 sub r1, r1, #1 1f400: e351000b cmp r1, #11 1f404: 979ff101 ldrls pc, [pc, r1, lsl #2]
1f408: ea000031 b 1f4d4 <rtems_rfs_dir_hash+0x1b0> <== NOT EXECUTED 1f40c: 0001f494 .word 0x0001f494 <== NOT EXECUTED 1f410: 0001f48c .word 0x0001f48c <== NOT EXECUTED 1f414: 0001f484 .word 0x0001f484 <== NOT EXECUTED 1f418: 0001f47c .word 0x0001f47c <== NOT EXECUTED 1f41c: 0001f474 .word 0x0001f474 <== NOT EXECUTED 1f420: 0001f46c .word 0x0001f46c <== NOT EXECUTED 1f424: 0001f464 .word 0x0001f464 <== NOT EXECUTED 1f428: 0001f45c .word 0x0001f45c <== NOT EXECUTED 1f42c: 0001f454 .word 0x0001f454 <== NOT EXECUTED 1f430: 0001f44c .word 0x0001f44c <== NOT EXECUTED 1f434: 0001f444 .word 0x0001f444 <== NOT EXECUTED 1f438: 0001f43c .word 0x0001f43c <== NOT EXECUTED
{
case 12: c+=((uint32_t)k[11])<<24;
1f43c: e5d3100b ldrb r1, [r3, #11] 1f440: e08ccc01 add ip, ip, r1, lsl #24
case 11: c+=((uint32_t)k[10])<<16;
1f444: e5d3100a ldrb r1, [r3, #10] 1f448: e08cc801 add ip, ip, r1, lsl #16
case 10: c+=((uint32_t)k[9])<<8;
1f44c: e5d31009 ldrb r1, [r3, #9] 1f450: e08cc401 add ip, ip, r1, lsl #8
case 9 : c+=k[8];
1f454: e5d31008 ldrb r1, [r3, #8] 1f458: e08cc001 add ip, ip, r1
case 8 : b+=((uint32_t)k[7])<<24;
1f45c: e5d31007 ldrb r1, [r3, #7] 1f460: e0822c01 add r2, r2, r1, lsl #24
case 7 : b+=((uint32_t)k[6])<<16;
1f464: e5d31006 ldrb r1, [r3, #6] 1f468: e0822801 add r2, r2, r1, lsl #16
case 6 : b+=((uint32_t)k[5])<<8;
1f46c: e5d31005 ldrb r1, [r3, #5] 1f470: e0822401 add r2, r2, r1, lsl #8
case 5 : b+=k[4];
1f474: e5d31004 ldrb r1, [r3, #4] 1f478: e0822001 add r2, r2, r1
case 4 : a+=((uint32_t)k[3])<<24;
1f47c: e5d31003 ldrb r1, [r3, #3] 1f480: e08aac01 add sl, sl, r1, lsl #24
case 3 : a+=((uint32_t)k[2])<<16;
1f484: e5d31002 ldrb r1, [r3, #2] 1f488: e08aa801 add sl, sl, r1, lsl #16
case 2 : a+=((uint32_t)k[1])<<8;
1f48c: e5d31001 ldrb r1, [r3, #1] 1f490: e08aa401 add sl, sl, r1, lsl #8
case 1 : a+=k[0];
1f494: e5d31000 ldrb r1, [r3]
break;
case 0 : return c;
}
}
final(a,b,c);
1f498: e02c3002 eor r3, ip, r2 1f49c: e0433962 sub r3, r3, r2, ror #18
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];
1f4a0: e08aa001 add sl, sl, r1
break;
case 0 : return c;
}
}
final(a,b,c);
1f4a4: e023a00a eor sl, r3, sl 1f4a8: e04aaae3 sub sl, sl, r3, ror #21 1f4ac: e02a2002 eor r2, sl, r2 1f4b0: e04223ea sub r2, r2, sl, ror #7 1f4b4: e0223003 eor r3, r2, r3 1f4b8: e0433862 sub r3, r3, r2, ror #16 1f4bc: e023a00a eor sl, r3, sl 1f4c0: e04aae63 sub sl, sl, r3, ror #28 1f4c4: e02a2002 eor r2, sl, r2 1f4c8: e042296a sub r2, r2, sl, ror #18 1f4cc: e022c003 eor ip, r2, r3 1f4d0: e04cc462 sub ip, ip, r2, ror #8
return c; }
1f4d4: e1a0000c mov r0, ip
1f4d8: e8bd0ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp}
1f4dc: e12fff1e bx lr
0001a5f0 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
1a5f0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1a5f4: e24dd074 sub sp, sp, #116 ; 0x74
1a5f8: e58d100c str r1, [sp, #12]
1a5fc: e1a06000 mov r6, r0
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
1a600: e3a01000 mov r1, #0 1a604: e3a00301 mov r0, #67108864 ; 0x4000000
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
1a608: e1a0b002 mov fp, r2 1a60c: e1a09003 mov r9, r3 1a610: e59d7098 ldr r7, [sp, #152] ; 0x98
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
1a614: ebffe085 bl 12830 <rtems_rfs_trace> 1a618: e3500000 cmp r0, #0
1a61c: 1a000012 bne 1a66c <rtems_rfs_dir_lookup_ino+0x7c>
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
*offset = 0;
1a620: e59dc09c ldr ip, [sp, #156] ; 0x9c
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
1a624: e3a04000 mov r4, #0 1a628: e5874000 str r4, [r7]
*offset = 0;
rc = rtems_rfs_block_map_open (fs, inode, &map);
1a62c: e1a00006 mov r0, r6
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
*offset = 0;
1a630: e58c4000 str r4, [ip]
rc = rtems_rfs_block_map_open (fs, inode, &map);
1a634: e59d100c ldr r1, [sp, #12] 1a638: e28d2014 add r2, sp, #20 1a63c: ebfffa3d bl 18f38 <rtems_rfs_block_map_open>
if (rc > 0)
1a640: e3500000 cmp r0, #0 1a644: e58d0008 str r0, [sp, #8]
1a648: da000017 ble 1a6ac <rtems_rfs_dir_lookup_ino+0xbc>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
1a64c: e3a00301 mov r0, #67108864 ; 0x4000000 <== NOT EXECUTED 1a650: e3a01000 mov r1, #0 <== NOT EXECUTED 1a654: ebffe075 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1a658: e1500004 cmp r0, r4 <== NOT EXECUTED 1a65c: 1a0000e7 bne 1aa00 <rtems_rfs_dir_lookup_ino+0x410> <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
1a660: e59d0008 ldr r0, [sp, #8]
1a664: e28dd074 add sp, sp, #116 ; 0x74
1a668: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
1a66c: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 1a670: e59f0478 ldr r0, [pc, #1144] ; 1aaf0 <rtems_rfs_dir_lookup_ino+0x500><== NOT EXECUTED 1a674: e59c1008 ldr r1, [ip, #8] <== NOT EXECUTED 1a678: eb001789 bl 204a4 <printf> <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
1a67c: e3590000 cmp r9, #0 <== NOT EXECUTED 1a680: da000005 ble 1a69c <rtems_rfs_dir_lookup_ino+0xac> <== NOT EXECUTED 1a684: e3a04000 mov r4, #0 <== NOT EXECUTED
printf ("%c", name[c]);
1a688: e7db0004 ldrb r0, [fp, r4] <== 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++)
1a68c: e2844001 add r4, r4, #1 <== NOT EXECUTED
printf ("%c", name[c]);
1a690: eb0017ed bl 2064c <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++)
1a694: e1540009 cmp r4, r9 <== NOT EXECUTED 1a698: 1afffffa bne 1a688 <rtems_rfs_dir_lookup_ino+0x98> <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
1a69c: e1a01009 mov r1, r9 <== NOT EXECUTED 1a6a0: e59f044c ldr r0, [pc, #1100] ; 1aaf4 <rtems_rfs_dir_lookup_ino+0x504><== NOT EXECUTED 1a6a4: eb00177e bl 204a4 <printf> <== NOT EXECUTED 1a6a8: eaffffdc b 1a620 <rtems_rfs_dir_lookup_ino+0x30> <== NOT EXECUTED
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
1a6ac: e1a01009 mov r1, r9 1a6b0: e1a0000b mov r0, fp
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
1a6b4: e5cd4064 strb r4, [sp, #100] ; 0x64
handle->bnum = 0;
1a6b8: e58d4068 str r4, [sp, #104] ; 0x68
handle->buffer = NULL;
1a6bc: e58d406c str r4, [sp, #108] ; 0x6c 1a6c0: eb001317 bl 1f324 <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);
1a6c4: e28de070 add lr, sp, #112 ; 0x70
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
1a6c8: e1a0a000 mov sl, r0
/*
* 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);
1a6cc: e28d1014 add r1, sp, #20 1a6d0: e1a00006 mov r0, r6 1a6d4: e3a02000 mov r2, #0 1a6d8: e3a03000 mov r3, #0 1a6dc: e58de000 str lr, [sp] 1a6e0: ebfffb3b bl 193d4 <rtems_rfs_block_map_seek>
if (rc > 0)
1a6e4: e3500000 cmp r0, #0 1a6e8: e58d0008 str r0, [sp, #8]
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)
1a6ec: d59f8404 ldrle r8, [pc, #1028] ; 1aaf8 <rtems_rfs_dir_lookup_ino+0x508>
/*
* 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);
if (rc > 0)
1a6f0: da00002c ble 1a7a8 <rtems_rfs_dir_lookup_ino+0x1b8>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
1a6f4: e3a00301 mov r0, #67108864 ; 0x4000000 <== NOT EXECUTED 1a6f8: e3a01000 mov r1, #0 <== NOT EXECUTED 1a6fc: ebffe04b bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1a700: e3500000 cmp r0, #0 <== NOT EXECUTED 1a704: 1a0000cf bne 1aa48 <rtems_rfs_dir_lookup_ino+0x458> <== 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);
1a708: e28d1064 add r1, sp, #100 ; 0x64 <== NOT EXECUTED 1a70c: e1a00006 mov r0, r6 <== NOT EXECUTED 1a710: ebfffd7a bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
rc, strerror (rc));
if (rc == ENXIO)
rc = ENOENT;
1a714: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED 1a718: e35c0006 cmp ip, #6 <== NOT EXECUTED
handle->dirty = false;
1a71c: e3a03000 mov r3, #0 <== NOT EXECUTED 1a720: 03a0c002 moveq ip, #2 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
1a724: e1a00006 mov r0, r6 <== NOT EXECUTED 1a728: e28d1014 add r1, sp, #20 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
rc, strerror (rc));
if (rc == ENXIO)
rc = ENOENT;
1a72c: e58dc008 str ip, [sp, #8] <== NOT EXECUTED 1a730: e5cd3064 strb r3, [sp, #100] ; 0x64 <== NOT EXECUTED
handle->bnum = 0;
1a734: e58d3068 str r3, [sp, #104] ; 0x68 <== NOT EXECUTED
handle->buffer = NULL;
1a738: e58d306c str r3, [sp, #108] ; 0x6c <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
1a73c: ebfffa57 bl 190a0 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
1a740: eaffffc6 b 1a660 <rtems_rfs_dir_lookup_ino+0x70> <== NOT EXECUTED
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
1a744: e59dc010 ldr ip, [sp, #16] 1a748: e35c0000 cmp ip, #0
1a74c: 1a000088 bne 1a974 <rtems_rfs_dir_lookup_ino+0x384>
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
1a750: e1a00006 mov r0, r6 1a754: e28d1014 add r1, sp, #20 1a758: e28d2070 add r2, sp, #112 ; 0x70 1a75c: ebfffb3b bl 19450 <rtems_rfs_block_map_next_block>
if ((rc > 0) && (rc != ENXIO))
1a760: e3500006 cmp r0, #6 1a764: 13500000 cmpne r0, #0
entry += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
1a768: e58d0008 str r0, [sp, #8]
if ((rc > 0) && (rc != ENXIO))
1a76c: da0000ad ble 1aa28 <rtems_rfs_dir_lookup_ino+0x438>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
1a770: e3a00301 mov r0, #67108864 ; 0x4000000 <== NOT EXECUTED 1a774: e3a01000 mov r1, #0 <== NOT EXECUTED 1a778: ebffe02c bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1a77c: e3500000 cmp r0, #0 <== NOT EXECUTED 1a780: 0a000008 beq 1a7a8 <rtems_rfs_dir_lookup_ino+0x1b8> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
1a784: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 1a788: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 1a78c: e59c4008 ldr r4, [ip, #8] <== NOT EXECUTED 1a790: eb001bf1 bl 2175c <strerror> <== NOT EXECUTED 1a794: e1a01004 mov r1, r4 <== NOT EXECUTED 1a798: e1a03000 mov r3, r0 <== NOT EXECUTED 1a79c: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 1a7a0: e59f0354 ldr r0, [pc, #852] ; 1aafc <rtems_rfs_dir_lookup_ino+0x50c><== NOT EXECUTED 1a7a4: eb00173e bl 204a4 <printf> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
1a7a8: e59dc008 ldr ip, [sp, #8] 1a7ac: e35c0000 cmp ip, #0
1a7b0: 1a0000a1 bne 1aa3c <rtems_rfs_dir_lookup_ino+0x44c>
1a7b4: e59d3070 ldr r3, [sp, #112] ; 0x70 1a7b8: e3530000 cmp r3, #0
1a7bc: 0a0000b9 beq 1aaa8 <rtems_rfs_dir_lookup_ino+0x4b8>
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
1a7c0: e3a00301 mov r0, #67108864 ; 0x4000000 1a7c4: e3a01000 mov r1, #0 1a7c8: ebffe018 bl 12830 <rtems_rfs_trace> 1a7cc: e3500000 cmp r0, #0
1a7d0: 1a00007b bne 1a9c4 <rtems_rfs_dir_lookup_ino+0x3d4>
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
1a7d4: e1a00006 mov r0, r6 1a7d8: e28d1064 add r1, sp, #100 ; 0x64 1a7dc: e59d2070 ldr r2, [sp, #112] ; 0x70 1a7e0: e3a03001 mov r3, #1 1a7e4: ebfffdbe bl 19ee4 <rtems_rfs_buffer_handle_request>
if (rc > 0)
1a7e8: e3500000 cmp r0, #0 1a7ec: e58d0010 str r0, [sp, #16]
1a7f0: ca00009b bgt 1aa64 <rtems_rfs_dir_lookup_ino+0x474>
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))
1a7f4: e5963008 ldr r3, [r6, #8] 1a7f8: e353000a cmp r3, #10
/*
* 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);
1a7fc: e59d306c ldr r3, [sp, #108] ; 0x6c 1a800: e593401c ldr r4, [r3, #28]
map.bpos.boff = 0;
1a804: e3a03000 mov r3, #0 1a808: e58d3028 str r3, [sp, #40] ; 0x28
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
1a80c: 1a000008 bne 1a834 <rtems_rfs_dir_lookup_ino+0x244>
1a810: eaffffcb b 1a744 <rtems_rfs_dir_lookup_ino+0x154> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
1a814: e59d3028 ldr r3, [sp, #40] ; 0x28
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))
1a818: e5962008 ldr r2, [r6, #8]
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
1a81c: e0853003 add r3, r5, r3
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))
1a820: e242200a sub r2, r2, #10 1a824: e1520003 cmp r2, r3
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
1a828: e58d3028 str r3, [sp, #40] ; 0x28
entry += elength;
1a82c: e0844005 add r4, r4, r5
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))
1a830: 9affffc3 bls 1a744 <rtems_rfs_dir_lookup_ino+0x154>
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
1a834: e5d41001 ldrb r1, [r4, #1]
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
1a838: e5d40009 ldrb r0, [r4, #9]
*ino = rtems_rfs_dir_entry_ino (entry);
1a83c: e5d4c000 ldrb ip, [r4]
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
1a840: e5d45008 ldrb r5, [r4, #8]
*ino = rtems_rfs_dir_entry_ino (entry);
1a844: e5d42003 ldrb r2, [r4, #3] 1a848: e1a01801 lsl r1, r1, #16 1a84c: e1811c0c orr r1, r1, ip, lsl #24
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
1a850: e1805405 orr r5, r0, r5, lsl #8
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);
1a854: e5d40005 ldrb r0, [r4, #5]
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
1a858: e1812002 orr r2, r1, r2
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);
1a85c: e5d41004 ldrb r1, [r4, #4]
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
1a860: e5d43002 ldrb r3, [r4, #2]
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);
1a864: e1a00800 lsl r0, r0, #16 1a868: e1800c01 orr r0, r0, r1, lsl #24 1a86c: e5d41007 ldrb r1, [r4, #7]
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
1a870: e1823403 orr r3, r2, r3, lsl #8
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);
1a874: e5d42006 ldrb r2, [r4, #6] 1a878: e1801001 orr r1, r0, r1
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1a87c: e1550008 cmp r5, r8
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);
1a880: e1811402 orr r1, r1, r2, lsl #8
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
1a884: e5873000 str r3, [r7]
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
1a888: 0affffad beq 1a744 <rtems_rfs_dir_lookup_ino+0x154>
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
1a88c: e355000a cmp r5, #10
1a890: da000030 ble 1a958 <rtems_rfs_dir_lookup_ino+0x368>
1a894: e596c01c ldr ip, [r6, #28] 1a898: e155000c cmp r5, ip
1a89c: 2a00002d bcs 1a958 <rtems_rfs_dir_lookup_ino+0x368>
1a8a0: e3530000 cmp r3, #0
1a8a4: 0a00002b beq 1a958 <rtems_rfs_dir_lookup_ino+0x368>
1a8a8: e5962014 ldr r2, [r6, #20] 1a8ac: e1530002 cmp r3, r2
1a8b0: 8a000028 bhi 1a958 <rtems_rfs_dir_lookup_ino+0x368>
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
1a8b4: e151000a cmp r1, sl
1a8b8: 1affffd5 bne 1a814 <rtems_rfs_dir_lookup_ino+0x224>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
1a8bc: e3a00302 mov r0, #134217728 ; 0x8000000 1a8c0: e3a01000 mov r1, #0 1a8c4: ebffdfd9 bl 12830 <rtems_rfs_trace> 1a8c8: e3500000 cmp r0, #0
1a8cc: 1a00002b bne 1a980 <rtems_rfs_dir_lookup_ino+0x390>
"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)
1a8d0: e284000a add r0, r4, #10 1a8d4: e1a0100b mov r1, fp 1a8d8: e1a02009 mov r2, r9 1a8dc: eb0015cf bl 20020 <memcmp> 1a8e0: e3500000 cmp r0, #0
1a8e4: 1affffca bne 1a814 <rtems_rfs_dir_lookup_ino+0x224>
{
*offset = rtems_rfs_block_map_pos (fs, &map);
1a8e8: e1a00006 mov r0, r6 1a8ec: e28d1024 add r1, sp, #36 ; 0x24 1a8f0: ebfff963 bl 18e84 <rtems_rfs_block_get_pos> 1a8f4: e59dc09c ldr ip, [sp, #156] ; 0x9c
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
1a8f8: 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);
1a8fc: e58c0000 str r0, [ip]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
1a900: e3a00201 mov r0, #268435456 ; 0x10000000 1a904: ebffdfc9 bl 12830 <rtems_rfs_trace> 1a908: e3500000 cmp r0, #0
1a90c: 0a000006 beq 1a92c <rtems_rfs_dir_lookup_ino+0x33c>
printf ("rtems-rfs: dir-lookup-ino: "
1a910: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 1a914: e59c1008 ldr r1, [ip, #8] <== NOT EXECUTED 1a918: e59dc09c ldr ip, [sp, #156] ; 0x9c <== NOT EXECUTED 1a91c: e59f01dc ldr r0, [pc, #476] ; 1ab00 <rtems_rfs_dir_lookup_ino+0x510><== NOT EXECUTED 1a920: e5972000 ldr r2, [r7] <== NOT EXECUTED 1a924: e59c3000 ldr r3, [ip] <== NOT EXECUTED 1a928: eb0016dd bl 204a4 <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);
1a92c: e28d1064 add r1, sp, #100 ; 0x64 1a930: e1a00006 mov r0, r6 1a934: ebfffcf1 bl 19d00 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
1a938: e3a03000 mov r3, #0
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
}
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
1a93c: e1a00006 mov r0, r6 1a940: e28d1014 add r1, sp, #20 1a944: e5cd3064 strb r3, [sp, #100] ; 0x64
handle->bnum = 0;
1a948: e58d3068 str r3, [sp, #104] ; 0x68
handle->buffer = NULL;
1a94c: e58d306c str r3, [sp, #108] ; 0x6c 1a950: ebfff9d2 bl 190a0 <rtems_rfs_block_map_close>
return rc;
1a954: eaffff41 b 1a660 <rtems_rfs_dir_lookup_ino+0x70>
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
1a958: e3a00301 mov r0, #67108864 ; 0x4000000 <== NOT EXECUTED 1a95c: e3a01000 mov r1, #0 <== NOT EXECUTED 1a960: ebffdfb2 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1a964: e3500000 cmp r0, #0 <== NOT EXECUTED 1a968: 1a00001b bne 1a9dc <rtems_rfs_dir_lookup_ino+0x3ec> <== NOT EXECUTED
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;
1a96c: e3a0c005 mov ip, #5 <== NOT EXECUTED 1a970: e58dc010 str ip, [sp, #16] <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
1a974: e59dc010 ldr ip, [sp, #16] 1a978: e58dc008 str ip, [sp, #8] 1a97c: eaffffea b 1a92c <rtems_rfs_dir_lookup_ino+0x33c>
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
1a980: e58d5000 str r5, [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));
1a984: e5d40001 ldrb r0, [r4, #1] <== NOT EXECUTED 1a988: e5d4c000 ldrb ip, [r4] <== NOT EXECUTED 1a98c: e5d42003 ldrb r2, [r4, #3] <== NOT EXECUTED 1a990: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED 1a994: e5d43002 ldrb r3, [r4, #2] <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
1a998: e59de00c ldr lr, [sp, #12] <== 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));
1a99c: e180cc0c orr ip, r0, ip, lsl #24 <== NOT EXECUTED 1a9a0: e18cc002 orr ip, ip, r2 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
1a9a4: e28d2024 add r2, sp, #36 ; 0x24 <== NOT EXECUTED
1a9a8: e18cc403 orr ip, ip, r3, lsl #8 <== NOT EXECUTED
1a9ac: e59e1008 ldr r1, [lr, #8] <== NOT EXECUTED
1a9b0: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
1a9b4: e59f0148 ldr r0, [pc, #328] ; 1ab04 <rtems_rfs_dir_lookup_ino+0x514><== NOT EXECUTED
1a9b8: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
1a9bc: eb0016b8 bl 204a4 <printf> <== NOT EXECUTED
1a9c0: eaffffc2 b 1a8d0 <rtems_rfs_dir_lookup_ino+0x2e0> <== NOT EXECUTED
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
1a9c4: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 1a9c8: e59d2024 ldr r2, [sp, #36] ; 0x24 <== NOT EXECUTED 1a9cc: e59c1008 ldr r1, [ip, #8] <== NOT EXECUTED 1a9d0: e59f0130 ldr r0, [pc, #304] ; 1ab08 <rtems_rfs_dir_lookup_ino+0x518><== NOT EXECUTED 1a9d4: eb0016b2 bl 204a4 <printf> <== NOT EXECUTED 1a9d8: eaffff7d b 1a7d4 <rtems_rfs_dir_lookup_ino+0x1e4> <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
1a9dc: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 1a9e0: e59c1008 ldr r1, [ip, #8] <== NOT EXECUTED 1a9e4: e59dc028 ldr ip, [sp, #40] ; 0x28 <== NOT EXECUTED 1a9e8: e5973000 ldr r3, [r7] <== NOT EXECUTED 1a9ec: e1a02005 mov r2, r5 <== NOT EXECUTED 1a9f0: e59f0114 ldr r0, [pc, #276] ; 1ab0c <rtems_rfs_dir_lookup_ino+0x51c><== NOT EXECUTED 1a9f4: e58dc000 str ip, [sp] <== NOT EXECUTED 1a9f8: eb0016a9 bl 204a4 <printf> <== NOT EXECUTED 1a9fc: eaffffda b 1a96c <rtems_rfs_dir_lookup_ino+0x37c> <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, inode, &map);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
1aa00: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 1aa04: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 1aa08: e59c4008 ldr r4, [ip, #8] <== NOT EXECUTED 1aa0c: eb001b52 bl 2175c <strerror> <== NOT EXECUTED 1aa10: e1a01004 mov r1, r4 <== NOT EXECUTED 1aa14: e1a03000 mov r3, r0 <== NOT EXECUTED 1aa18: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 1aa1c: e59f00ec ldr r0, [pc, #236] ; 1ab10 <rtems_rfs_dir_lookup_ino+0x520><== NOT EXECUTED 1aa20: eb00169f bl 204a4 <printf> <== NOT EXECUTED 1aa24: eaffff0d b 1a660 <rtems_rfs_dir_lookup_ino+0x70> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
1aa28: e59dc008 ldr ip, [sp, #8] 1aa2c: e35c0006 cmp ip, #6
1aa30: 1affff5c bne 1a7a8 <rtems_rfs_dir_lookup_ino+0x1b8>
rc = ENOENT;
1aa34: e3a0c002 mov ip, #2 1aa38: e58dc008 str ip, [sp, #8]
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
1aa3c: e59dc008 ldr ip, [sp, #8] 1aa40: e58dc010 str ip, [sp, #16] 1aa44: eaffffca b 1a974 <rtems_rfs_dir_lookup_ino+0x384>
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
1aa48: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 1aa4c: eb001b42 bl 2175c <strerror> <== NOT EXECUTED 1aa50: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 1aa54: e1a02000 mov r2, r0 <== NOT EXECUTED 1aa58: e59f00b4 ldr r0, [pc, #180] ; 1ab14 <rtems_rfs_dir_lookup_ino+0x524><== NOT EXECUTED 1aa5c: eb001690 bl 204a4 <printf> <== NOT EXECUTED 1aa60: eaffff28 b 1a708 <rtems_rfs_dir_lookup_ino+0x118> <== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
1aa64: e3a00301 mov r0, #67108864 ; 0x4000000 <== NOT EXECUTED 1aa68: e3a01000 mov r1, #0 <== NOT EXECUTED 1aa6c: ebffdf6f bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1aa70: e3500000 cmp r0, #0 <== NOT EXECUTED 1aa74: 0affffbe beq 1a974 <rtems_rfs_dir_lookup_ino+0x384> <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
1aa78: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 1aa7c: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED 1aa80: e59c5008 ldr r5, [ip, #8] <== NOT EXECUTED 1aa84: e59d4070 ldr r4, [sp, #112] ; 0x70 <== NOT EXECUTED 1aa88: eb001b33 bl 2175c <strerror> <== NOT EXECUTED 1aa8c: e1a01005 mov r1, r5 <== NOT EXECUTED 1aa90: e58d0000 str r0, [sp] <== NOT EXECUTED 1aa94: e1a02004 mov r2, r4 <== NOT EXECUTED 1aa98: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 1aa9c: e59f0074 ldr r0, [pc, #116] ; 1ab18 <rtems_rfs_dir_lookup_ino+0x528><== NOT EXECUTED 1aaa0: eb00167f bl 204a4 <printf> <== NOT EXECUTED 1aaa4: eaffffb2 b 1a974 <rtems_rfs_dir_lookup_ino+0x384> <== NOT EXECUTED
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
1aaa8: e3a00301 mov r0, #67108864 ; 0x4000000 <== NOT EXECUTED 1aaac: e3a01000 mov r1, #0 <== NOT EXECUTED 1aab0: ebffdf5e bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1aab4: e3500000 cmp r0, #0 <== NOT EXECUTED 1aab8: 1a000002 bne 1aac8 <rtems_rfs_dir_lookup_ino+0x4d8> <== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
1aabc: e3a0c005 mov ip, #5 <== NOT EXECUTED 1aac0: e58dc008 str ip, [sp, #8] <== NOT EXECUTED 1aac4: eaffff98 b 1a92c <rtems_rfs_dir_lookup_ino+0x33c> <== NOT EXECUTED
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",
1aac8: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 1aacc: e3a00005 mov r0, #5 <== NOT EXECUTED 1aad0: e59c4008 ldr r4, [ip, #8] <== NOT EXECUTED 1aad4: eb001b20 bl 2175c <strerror> <== NOT EXECUTED 1aad8: e1a01004 mov r1, r4 <== NOT EXECUTED 1aadc: e1a03000 mov r3, r0 <== NOT EXECUTED 1aae0: e3a02005 mov r2, #5 <== NOT EXECUTED 1aae4: e59f0030 ldr r0, [pc, #48] ; 1ab1c <rtems_rfs_dir_lookup_ino+0x52c><== NOT EXECUTED 1aae8: eb00166d bl 204a4 <printf> <== NOT EXECUTED 1aaec: eafffff2 b 1aabc <rtems_rfs_dir_lookup_ino+0x4cc> <== NOT EXECUTED
0001b3b8 <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)
{
1b3b8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1b3bc: e1a05000 mov r5, r0
1b3c0: e24dd06c sub sp, sp, #108 ; 0x6c
1b3c4: e1a0b001 mov fp, r1
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))
1b3c8: e3a00102 mov r0, #-2147483648 ; 0x80000000 1b3cc: e3a01000 mov r1, #0
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)
{
1b3d0: e98d000c stmib sp, {r2, r3}
1b3d4: e59d8094 ldr r8, [sp, #148] ; 0x94
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))
1b3d8: ebffdd14 bl 12830 <rtems_rfs_trace> 1b3dc: e3500000 cmp r0, #0
1b3e0: 1a000026 bne 1b480 <rtems_rfs_dir_read+0xc8>
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
rtems_rfs_inode_ino (dir), offset);
*length = 0;
1b3e4: e3a03000 mov r3, #0 1b3e8: e5883000 str r3, [r8]
rc = rtems_rfs_block_map_open (fs, dir, &map);
1b3ec: e1a00005 mov r0, r5 1b3f0: e1a0100b mov r1, fp 1b3f4: e28d200c add r2, sp, #12 1b3f8: ebfff6ce bl 18f38 <rtems_rfs_block_map_open>
if (rc > 0)
1b3fc: e2504000 subs r4, r0, #0
1b400: da000002 ble 1b410 <rtems_rfs_dir_read+0x58>
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
1b404: e1a00004 mov r0, r4
1b408: e28dd06c add sp, sp, #108 ; 0x6c
1b40c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
1b410: e5953008 ldr r3, [r5, #8]
1b414: e3a07000 mov r7, #0
1b418: e1a02003 mov r2, r3
1b41c: e1a06003 mov r6, r3
1b420: e99d0003 ldmib sp, {r0, r1}
1b424: e1a03007 mov r3, r7
1b428: eb004ad9 bl 2df94 <__moddi3>
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
1b42c: e1a02006 mov r2, r6 1b430: e1a03007 mov r3, r7 1b434: e0522000 subs r2, r2, r0 1b438: e0c33001 sbc r3, r3, r1 1b43c: e352000b cmp r2, #11 1b440: e2d30000 sbcs r0, r3, #0
1b444: ba000012 blt 1b494 <rtems_rfs_dir_read+0xdc>
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
1b448: e28de068 add lr, sp, #104 ; 0x68
1b44c: e1a00005 mov r0, r5
1b450: e28d100c add r1, sp, #12
1b454: e99d000c ldmib sp, {r2, r3}
1b458: e58de000 str lr, [sp]
1b45c: ebfff7dc bl 193d4 <rtems_rfs_block_map_seek>
if (rc > 0)
1b460: e2504000 subs r4, r0, #0
1b464: da000017 ble 1b4c8 <rtems_rfs_dir_read+0x110>
{
if (rc == ENXIO)
rc = ENOENT;
1b468: e3540006 cmp r4, #6 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
1b46c: e1a00005 mov r0, r5 <== NOT EXECUTED 1b470: e28d100c add r1, sp, #12 <== NOT EXECUTED
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
if (rc > 0)
{
if (rc == ENXIO)
rc = ENOENT;
1b474: 03a04002 moveq r4, #2 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
1b478: ebfff708 bl 190a0 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
1b47c: eaffffe0 b 1b404 <rtems_rfs_dir_read+0x4c> <== NOT EXECUTED
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
1b480: e59b1008 ldr r1, [fp, #8] <== NOT EXECUTED
1b484: e99d000c ldmib sp, {r2, r3} <== NOT EXECUTED
1b488: e59f028c ldr r0, [pc, #652] ; 1b71c <rtems_rfs_dir_read+0x364><== NOT EXECUTED
1b48c: eb001404 bl 204a4 <printf> <== NOT EXECUTED
1b490: eaffffd3 b 1b3e4 <rtems_rfs_dir_read+0x2c> <== NOT EXECUTED
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
1b494: e99d0003 ldmib sp, {r0, r1} <== NOT EXECUTED
1b498: e1a02006 mov r2, r6 <== NOT EXECUTED
1b49c: e1a03007 mov r3, r7 <== NOT EXECUTED
1b4a0: eb004980 bl 2daa8 <__divdi3> <== NOT EXECUTED
1b4a4: e3a02001 mov r2, #1 <== NOT EXECUTED
1b4a8: e0922000 adds r2, r2, r0 <== NOT EXECUTED
1b4ac: e3a03000 mov r3, #0 <== NOT EXECUTED
1b4b0: e0a33001 adc r3, r3, r1 <== NOT EXECUTED
1b4b4: e0810296 umull r0, r1, r6, r2 <== NOT EXECUTED
1b4b8: e02c1396 mla ip, r6, r3, r1 <== NOT EXECUTED
1b4bc: e98d0003 stmib sp, {r0, r1} <== NOT EXECUTED
1b4c0: e58dc008 str ip, [sp, #8] <== NOT EXECUTED
1b4c4: eaffffdf b 1b448 <rtems_rfs_dir_read+0x90> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
1b4c8: e3a03000 mov r3, #0 1b4cc: e5cd305c strb r3, [sp, #92] ; 0x5c
handle->bnum = 0;
1b4d0: e58d3060 str r3, [sp, #96] ; 0x60
handle->buffer = NULL;
1b4d4: e58d3064 str r3, [sp, #100] ; 0x64
uint8_t* entry;
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
1b4d8: e28d105c add r1, sp, #92 ; 0x5c 1b4dc: e59d2068 ldr r2, [sp, #104] ; 0x68 1b4e0: e3a03001 mov r3, #1 1b4e4: e1a00005 mov r0, r5 1b4e8: ebfffa7d bl 19ee4 <rtems_rfs_buffer_handle_request>
if (rc > 0)
1b4ec: e2504000 subs r4, r0, #0
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
1b4f0: e3a01000 mov r1, #0 1b4f4: e3a00102 mov r0, #-2147483648 ; 0x80000000
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
1b4f8: ca00002f bgt 1b5bc <rtems_rfs_dir_read+0x204>
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
1b4fc: e59d3064 ldr r3, [sp, #100] ; 0x64
entry += map.bpos.boff;
1b500: e59d7020 ldr r7, [sp, #32]
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
1b504: e593301c ldr r3, [r3, #28]
entry += map.bpos.boff;
1b508: e0836007 add r6, r3, r7
elength = rtems_rfs_dir_entry_length (entry);
1b50c: e5d6e009 ldrb lr, [r6, #9]
eino = rtems_rfs_dir_entry_ino (entry);
1b510: e5d6c001 ldrb ip, [r6, #1]
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
1b514: e5d62008 ldrb r2, [r6, #8]
eino = rtems_rfs_dir_entry_ino (entry);
1b518: e7d3a007 ldrb sl, [r3, r7]
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
1b51c: e18e2402 orr r2, lr, r2, lsl #8
eino = rtems_rfs_dir_entry_ino (entry);
1b520: e5d69003 ldrb r9, [r6, #3] 1b524: e1a0c80c lsl ip, ip, #16
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
1b528: e59fe1f0 ldr lr, [pc, #496] ; 1b720 <rtems_rfs_dir_read+0x368>
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
1b52c: e5d63002 ldrb r3, [r6, #2] 1b530: e18ccc0a orr ip, ip, sl, lsl #24 1b534: e18cc009 orr ip, ip, r9
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
1b538: e152000e cmp r2, lr
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
1b53c: e18cc403 orr ip, ip, r3, lsl #8
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
1b540: 1a000028 bne 1b5e8 <rtems_rfs_dir_read+0x230>
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
dirent->d_off, dirent->d_ino, dirent->d_name);
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
1b544: e5952008 ldr r2, [r5, #8] 1b548: e5983000 ldr r3, [r8] 1b54c: e0677002 rsb r7, r7, r2 1b550: e0833007 add r3, r3, r7 1b554: e5883000 str r3, [r8]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
1b558: ebffdcb4 bl 12830 <rtems_rfs_trace> 1b55c: e3500000 cmp r0, #0
1b560: 1a000009 bne 1b58c <rtems_rfs_dir_read+0x1d4>
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
1b564: e1a00005 mov r0, r5 1b568: e28d100c add r1, sp, #12 1b56c: e28d2068 add r2, sp, #104 ; 0x68 1b570: ebfff7b6 bl 19450 <rtems_rfs_block_map_next_block>
if (rc == ENXIO)
1b574: e3500006 cmp r0, #6
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);
1b578: e1a04000 mov r4, r0
if (rc == ENXIO)
1b57c: 0a00000d beq 1b5b8 <rtems_rfs_dir_read+0x200>
/*
* Look for an empty entry and if this is the last block that is the end of
* the directory.
*/
while (rc == 0)
1b580: e3500000 cmp r0, #0 <== NOT EXECUTED 1b584: 0affffd3 beq 1b4d8 <rtems_rfs_dir_read+0x120> <== NOT EXECUTED 1b588: ea00000b b 1b5bc <rtems_rfs_dir_read+0x204> <== NOT EXECUTED
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
1b58c: e99d0006 ldmib sp, {r1, r2} <== NOT EXECUTED
1b590: e5983000 ldr r3, [r8] <== NOT EXECUTED
1b594: e59f0188 ldr r0, [pc, #392] ; 1b724 <rtems_rfs_dir_read+0x36c><== NOT EXECUTED
1b598: eb0013c1 bl 204a4 <printf> <== NOT EXECUTED
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
1b59c: e1a00005 mov r0, r5 <== NOT EXECUTED 1b5a0: e28d100c add r1, sp, #12 <== NOT EXECUTED 1b5a4: e28d2068 add r2, sp, #104 ; 0x68 <== NOT EXECUTED 1b5a8: ebfff7a8 bl 19450 <rtems_rfs_block_map_next_block> <== NOT EXECUTED
if (rc == ENXIO)
1b5ac: e3500006 cmp r0, #6 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
1b5b0: e1a04000 mov r4, r0 <== NOT EXECUTED
if (rc == ENXIO)
1b5b4: 1afffff1 bne 1b580 <rtems_rfs_dir_read+0x1c8> <== NOT EXECUTED
rc = ENOENT;
1b5b8: e3a04002 mov r4, #2
*/
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);
1b5bc: e28d105c add r1, sp, #92 ; 0x5c 1b5c0: e1a00005 mov r0, r5 1b5c4: ebfff9cd bl 19d00 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
1b5c8: e3a03000 mov r3, #0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
1b5cc: e1a00005 mov r0, r5 1b5d0: e28d100c add r1, sp, #12 1b5d4: e5cd305c strb r3, [sp, #92] ; 0x5c
handle->bnum = 0;
1b5d8: e58d3060 str r3, [sp, #96] ; 0x60
handle->buffer = NULL;
1b5dc: e58d3064 str r3, [sp, #100] ; 0x64 1b5e0: ebfff6ae bl 190a0 <rtems_rfs_block_map_close>
return rc;
1b5e4: eaffff86 b 1b404 <rtems_rfs_dir_read+0x4c>
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
1b5e8: e352000a cmp r2, #10 1b5ec: e1a0a002 mov sl, r2 1b5f0: e1a0900c mov r9, ip
1b5f4: da000008 ble 1b61c <rtems_rfs_dir_read+0x264>
1b5f8: e595101c ldr r1, [r5, #28] 1b5fc: e35c0000 cmp ip, #0 1b600: 11520001 cmpne r2, r1 1b604: 33a01000 movcc r1, #0 1b608: 23a01001 movcs r1, #1
1b60c: 2a000002 bcs 1b61c <rtems_rfs_dir_read+0x264>
1b610: e5953014 ldr r3, [r5, #20] 1b614: e153000c cmp r3, ip
1b618: 2a00000e bcs 1b658 <rtems_rfs_dir_read+0x2a0>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
1b61c: e3a00102 mov r0, #-2147483648 ; 0x80000000 <== NOT EXECUTED 1b620: e3a01000 mov r1, #0 <== NOT EXECUTED 1b624: ebffdc81 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1b628: e3500000 cmp r0, #0 <== NOT EXECUTED
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;
1b62c: 03a04005 moveq r4, #5 <== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
1b630: 0affffe1 beq 1b5bc <rtems_rfs_dir_read+0x204> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
1b634: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED 1b638: e59b1008 ldr r1, [fp, #8] <== NOT EXECUTED 1b63c: e1a0200a mov r2, sl <== NOT EXECUTED 1b640: e1a03009 mov r3, r9 <== NOT EXECUTED 1b644: e59f00dc ldr r0, [pc, #220] ; 1b728 <rtems_rfs_dir_read+0x370><== NOT EXECUTED 1b648: e58dc000 str ip, [sp] <== NOT EXECUTED
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04" PRIx32 "\n",
rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
rc = EIO;
1b64c: e3a04005 mov r4, #5 <== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: "
1b650: eb001393 bl 204a4 <printf> <== NOT EXECUTED 1b654: eaffffd8 b 1b5bc <rtems_rfs_dir_read+0x204> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
1b658: e3a09e11 mov r9, #272 ; 0x110 1b65c: e1a02009 mov r2, r9 1b660: e59d0090 ldr r0, [sp, #144] ; 0x90 1b664: eb00131d bl 202e0 <memset>
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
*length += elength;
1b668: e5983000 ldr r3, [r8]
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
1b66c: e99d0003 ldmib sp, {r0, r1}
1b670: e59dc090 ldr ip, [sp, #144] ; 0x90
dirent->d_reclen = sizeof (struct dirent);
*length += elength;
1b674: e08a3003 add r3, sl, r3
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
1b678: e98c0003 stmib ip, {r0, r1}
dirent->d_reclen = sizeof (struct dirent);
1b67c: e1cc90bc strh r9, [ip, #12]
*length += elength;
1b680: e5883000 str r3, [r8]
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
1b684: e5952008 ldr r2, [r5, #8] 1b688: e0672002 rsb r2, r7, r2 1b68c: e06a2002 rsb r2, sl, r2
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
1b690: e352000a cmp r2, #10
*length += remaining;
1b694: d0823003 addle r3, r2, r3
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
1b698: e59dc090 ldr ip, [sp, #144] ; 0x90
*length += elength;
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
*length += remaining;
1b69c: d5883000 strle r3, [r8]
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
1b6a0: e24a800a sub r8, sl, #10 1b6a4: e35800ff cmp r8, #255 ; 0xff 1b6a8: a3a080ff movge r8, #255 ; 0xff
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
1b6ac: e28c7010 add r7, ip, #16 1b6b0: e286100a add r1, r6, #10 1b6b4: e1a02008 mov r2, r8 1b6b8: e1a00007 mov r0, r7 1b6bc: eb001284 bl 200d4 <memcpy>
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
1b6c0: e5d61001 ldrb r1, [r6, #1] 1b6c4: e5d60000 ldrb r0, [r6] 1b6c8: e5d63003 ldrb r3, [r6, #3] 1b6cc: e1a01801 lsl r1, r1, #16 1b6d0: e5d62002 ldrb r2, [r6, #2] 1b6d4: e1811c00 orr r1, r1, r0, lsl #24 1b6d8: e59dc090 ldr ip, [sp, #144] ; 0x90 1b6dc: e1813003 orr r3, r1, r3 1b6e0: e1833402 orr r3, r3, r2, lsl #8 1b6e4: e58c3000 str r3, [ip]
dirent->d_namlen = elength;
1b6e8: e1cc80be strh r8, [ip, #14]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
1b6ec: e3a00102 mov r0, #-2147483648 ; 0x80000000 1b6f0: e3a01000 mov r1, #0 1b6f4: ebffdc4d bl 12830 <rtems_rfs_trace> 1b6f8: e3500000 cmp r0, #0
1b6fc: 0affffae beq 1b5bc <rtems_rfs_dir_read+0x204>
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
1b700: e59dc090 ldr ip, [sp, #144] ; 0x90 <== NOT EXECUTED
1b704: e59f0020 ldr r0, [pc, #32] ; 1b72c <rtems_rfs_dir_read+0x374><== NOT EXECUTED
1b708: e99c0006 ldmib ip, {r1, r2} <== NOT EXECUTED
1b70c: e59c3000 ldr r3, [ip] <== NOT EXECUTED
1b710: e58d7000 str r7, [sp] <== NOT EXECUTED
1b714: eb001362 bl 204a4 <printf> <== NOT EXECUTED
1b718: eaffffa7 b 1b5bc <rtems_rfs_dir_read+0x204> <== NOT EXECUTED
0001bcac <rtems_rfs_file_close>:
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
1bcac: e92d41f0 push {r4, r5, r6, r7, r8, lr}
1bcb0: e1a06000 mov r6, r0
1bcb4: e1a04001 mov r4, r1
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
1bcb8: e3a00000 mov r0, #0 1bcbc: e3a01010 mov r1, #16 1bcc0: ebffdada bl 12830 <rtems_rfs_trace> 1bcc4: e3500000 cmp r0, #0
1bcc8: 1a00007d bne 1bec4 <rtems_rfs_file_close+0x218>
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
handle->shared->inode.ino);
if (handle->shared->references > 0)
1bccc: e594101c ldr r1, [r4, #28] 1bcd0: e5913008 ldr r3, [r1, #8] 1bcd4: e3530000 cmp r3, #0
handle->shared->references--;
1bcd8: c2433001 subgt r3, r3, #1 1bcdc: c5813008 strgt r3, [r1, #8]
if (handle->shared->references == 0)
1bce0: e3530000 cmp r3, #0
1bce4: 1a00006b bne 1be98 <rtems_rfs_file_close+0x1ec>
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
1bce8: e5913018 ldr r3, [r1, #24] 1bcec: e3530000 cmp r3, #0
1bcf0: 0a00009d beq 1bf6c <rtems_rfs_file_close+0x2c0>
if (rrc == 0)
{
/*
* @todo This could be clever and only update if different.
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
1bcf4: e591208c ldr r2, [r1, #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);
1bcf8: e1a00c22 lsr r0, r2, #24 1bcfc: e5c30010 strb r0, [r3, #16] 1bd00: e5913018 ldr r3, [r1, #24] 1bd04: e1a00822 lsr r0, r2, #16 1bd08: e5c30011 strb r0, [r3, #17] 1bd0c: e5913018 ldr r3, [r1, #24] 1bd10: e1a00422 lsr r0, r2, #8 1bd14: e5c30012 strb r0, [r3, #18] 1bd18: e5913018 ldr r3, [r1, #24] 1bd1c: e5c32013 strb r2, [r3, #19]
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
1bd20: e594201c ldr r2, [r4, #28] 1bd24: e5923090 ldr r3, [r2, #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);
1bd28: e592c018 ldr ip, [r2, #24]
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1bd2c: e3a00001 mov r0, #1
*/
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);
1bd30: e1a0ec23 lsr lr, r3, #24
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1bd34: e5c1001c strb r0, [r1, #28]
*/
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);
1bd38: e5cce014 strb lr, [ip, #20] 1bd3c: e5921018 ldr r1, [r2, #24] 1bd40: e1a0c823 lsr ip, r3, #16 1bd44: e5c1c015 strb ip, [r1, #21] 1bd48: e5921018 ldr r1, [r2, #24] 1bd4c: e1a0c423 lsr ip, r3, #8 1bd50: e5c1c016 strb ip, [r1, #22] 1bd54: e5921018 ldr r1, [r2, #24] 1bd58: e5c13017 strb r3, [r1, #23]
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
1bd5c: e594301c ldr r3, [r4, #28] 1bd60: e5931094 ldr r1, [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);
1bd64: e593c018 ldr ip, [r3, #24] 1bd68: e1a0ec21 lsr lr, r1, #24
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1bd6c: e5c2001c strb r0, [r2, #28]
*/
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);
1bd70: e5cce018 strb lr, [ip, #24] 1bd74: e5932018 ldr r2, [r3, #24] 1bd78: e1a0c821 lsr ip, r1, #16 1bd7c: e5c2c019 strb ip, [r2, #25] 1bd80: e5932018 ldr r2, [r3, #24] 1bd84: e1a0c421 lsr ip, r1, #8 1bd88: e5c2c01a strb ip, [r2, #26] 1bd8c: e5932018 ldr r2, [r3, #24] 1bd90: e5c2101b strb r1, [r2, #27]
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
1bd94: e594101c ldr r1, [r4, #28] 1bd98: e5912084 ldr r2, [r1, #132] ; 0x84 1bd9c: e591c03c ldr ip, [r1, #60] ; 0x3c 1bda0: e152000c cmp r2, ip
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1bda4: e5c3001c strb r0, [r3, #28] 1bda8: e5913088 ldr r3, [r1, #136] ; 0x88
1bdac: 0a000069 beq 1bf58 <rtems_rfs_file_close+0x2ac>
*/
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);
1bdb0: e5813040 str r3, [r1, #64] ; 0x40 <== NOT EXECUTED
map->dirty = true;
1bdb4: e3a03001 mov r3, #1 <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map* map,
rtems_rfs_block_size* size)
{
rtems_rfs_block_copy_size (&map->size, size);
1bdb8: e581203c str r2, [r1, #60] ; 0x3c <== NOT EXECUTED
map->dirty = true;
1bdbc: e5c13034 strb r3, [r1, #52] ; 0x34 <== NOT EXECUTED 1bdc0: e3a05000 mov r5, #0 <== NOT EXECUTED
&handle->shared->map.size))
rtems_rfs_block_map_set_size (&handle->shared->map,
&handle->shared->size);
}
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
1bdc4: e1a00006 mov r0, r6 1bdc8: e2811034 add r1, r1, #52 ; 0x34 1bdcc: ebfff4b3 bl 190a0 <rtems_rfs_block_map_close>
if (rc > 0)
1bdd0: e2507000 subs r7, r0, #0
1bdd4: da000006 ble 1bdf4 <rtems_rfs_file_close+0x148>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
1bdd8: e3a00000 mov r0, #0 <== NOT EXECUTED 1bddc: e3a01010 mov r1, #16 <== NOT EXECUTED 1bde0: ebffda92 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1bde4: e3500000 cmp r0, #0 <== NOT EXECUTED 1bde8: 1a000050 bne 1bf30 <rtems_rfs_file_close+0x284> <== NOT EXECUTED
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
1bdec: e3550000 cmp r5, #0 <== NOT EXECUTED 1bdf0: 01a05007 moveq r5, r7 <== NOT EXECUTED
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
1bdf4: e594101c ldr r1, [r4, #28] 1bdf8: e1a00006 mov r0, r6 1bdfc: e281100c add r1, r1, #12 1be00: ebffd4aa bl 110b0 <rtems_rfs_inode_close>
if (rc > 0)
1be04: e2507000 subs r7, r0, #0
1be08: da000006 ble 1be28 <rtems_rfs_file_close+0x17c>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
1be0c: e3a00000 mov r0, #0 <== NOT EXECUTED 1be10: e3a01010 mov r1, #16 <== NOT EXECUTED 1be14: ebffda85 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1be18: e3500000 cmp r0, #0 <== NOT EXECUTED 1be1c: 1a000039 bne 1bf08 <rtems_rfs_file_close+0x25c> <== NOT EXECUTED
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
1be20: e3550000 cmp r5, #0 <== NOT EXECUTED 1be24: 0a00002b beq 1bed8 <rtems_rfs_file_close+0x22c> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
1be28: e594001c ldr r0, [r4, #28] 1be2c: ebffec0e bl 16e6c <_Chain_Extract>
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
1be30: e594001c ldr r0, [r4, #28] 1be34: ebffacff bl 7238 <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);
1be38: e1a00006 mov r0, r6 1be3c: e2841004 add r1, r4, #4 1be40: ebfff7ae bl 19d00 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
1be44: e3a03000 mov r3, #0
rc = rtems_rfs_buffer_handle_close (fs, &handle->buffer);
if ((rrc == 0) && (rc > 0))
rrc = rc;
if (rrc > 0)
1be48: e1550003 cmp r5, r3 1be4c: e5c43004 strb r3, [r4, #4]
handle->bnum = 0;
1be50: e5843008 str r3, [r4, #8]
handle->buffer = NULL;
1be54: e584300c str r3, [r4, #12]
1be58: da000015 ble 1beb4 <rtems_rfs_file_close+0x208>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
1be5c: e3a00000 mov r0, #0 <== NOT EXECUTED 1be60: e3a01010 mov r1, #16 <== NOT EXECUTED 1be64: ebffda71 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1be68: e3500000 cmp r0, #0 <== NOT EXECUTED 1be6c: 0a000010 beq 1beb4 <rtems_rfs_file_close+0x208> <== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
1be70: e1a00005 mov r0, r5 <== NOT EXECUTED 1be74: eb001638 bl 2175c <strerror> <== NOT EXECUTED 1be78: e1a01005 mov r1, r5 <== NOT EXECUTED 1be7c: e1a02000 mov r2, r0 <== NOT EXECUTED 1be80: e59f0104 ldr r0, [pc, #260] ; 1bf8c <rtems_rfs_file_close+0x2e0><== NOT EXECUTED 1be84: eb001186 bl 204a4 <printf> <== NOT EXECUTED
}
free (handle);
1be88: e1a00004 mov r0, r4 <== NOT EXECUTED 1be8c: ebfface9 bl 7238 <free> <== NOT EXECUTED
return rrc;
}
1be90: e1a00005 mov r0, r5 <== NOT EXECUTED
1be94: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
1be98: e3a05000 mov r5, #0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
1be9c: e1a00006 mov r0, r6 <== NOT EXECUTED 1bea0: e2841004 add r1, r4, #4 <== NOT EXECUTED 1bea4: ebfff795 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
1bea8: e5c45004 strb r5, [r4, #4] <== NOT EXECUTED
handle->bnum = 0;
1beac: e5845008 str r5, [r4, #8] <== NOT EXECUTED
handle->buffer = NULL;
1beb0: e584500c str r5, [r4, #12] <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
}
free (handle);
1beb4: e1a00004 mov r0, r4 1beb8: ebffacde bl 7238 <free>
return rrc;
}
1bebc: e1a00005 mov r0, r5
1bec0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
handle->shared->inode.ino);
1bec4: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
1bec8: e59f00c0 ldr r0, [pc, #192] ; 1bf90 <rtems_rfs_file_close+0x2e4><== NOT EXECUTED 1becc: e5931014 ldr r1, [r3, #20] <== NOT EXECUTED 1bed0: eb001173 bl 204a4 <printf> <== NOT EXECUTED 1bed4: eaffff7c b 1bccc <rtems_rfs_file_close+0x20> <== NOT EXECUTED 1bed8: e594001c ldr r0, [r4, #28] <== NOT EXECUTED 1bedc: ebffebe2 bl 16e6c <_Chain_Extract> <== NOT EXECUTED
if (rrc == 0)
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
1bee0: e594001c ldr r0, [r4, #28] <== NOT EXECUTED 1bee4: ebffacd3 bl 7238 <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);
1bee8: e1a00006 mov r0, r6 <== NOT EXECUTED 1beec: e2841004 add r1, r4, #4 <== NOT EXECUTED 1bef0: ebfff782 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
1bef4: e5c45004 strb r5, [r4, #4] <== NOT EXECUTED
handle->bnum = 0;
1bef8: e5845008 str r5, [r4, #8] <== NOT EXECUTED
handle->buffer = NULL;
1befc: e584500c str r5, [r4, #12] <== NOT EXECUTED 1bf00: e1a05007 mov r5, r7 <== NOT EXECUTED 1bf04: eaffffd4 b 1be5c <rtems_rfs_file_close+0x1b0> <== 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",
handle->shared->inode.ino, rc, strerror (rc));
1bf08: 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",
1bf0c: e1a00007 mov r0, r7 <== NOT EXECUTED 1bf10: e5938014 ldr r8, [r3, #20] <== NOT EXECUTED 1bf14: eb001610 bl 2175c <strerror> <== NOT EXECUTED 1bf18: e1a01008 mov r1, r8 <== NOT EXECUTED 1bf1c: e1a03000 mov r3, r0 <== NOT EXECUTED 1bf20: e1a02007 mov r2, r7 <== NOT EXECUTED 1bf24: e59f0068 ldr r0, [pc, #104] ; 1bf94 <rtems_rfs_file_close+0x2e8><== NOT EXECUTED 1bf28: eb00115d bl 204a4 <printf> <== NOT EXECUTED 1bf2c: eaffffbb b 1be20 <rtems_rfs_file_close+0x174> <== 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",
handle->shared->inode.ino, rc, strerror (rc));
1bf30: 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",
1bf34: e1a00007 mov r0, r7 <== NOT EXECUTED 1bf38: e5938014 ldr r8, [r3, #20] <== NOT EXECUTED 1bf3c: eb001606 bl 2175c <strerror> <== NOT EXECUTED 1bf40: e1a01008 mov r1, r8 <== NOT EXECUTED 1bf44: e1a03000 mov r3, r0 <== NOT EXECUTED 1bf48: e1a02007 mov r2, r7 <== NOT EXECUTED 1bf4c: e59f0044 ldr r0, [pc, #68] ; 1bf98 <rtems_rfs_file_close+0x2ec><== NOT EXECUTED 1bf50: eb001153 bl 204a4 <printf> <== NOT EXECUTED 1bf54: eaffffa4 b 1bdec <rtems_rfs_file_close+0x140> <== NOT EXECUTED
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
1bf58: e5910040 ldr r0, [r1, #64] ; 0x40 1bf5c: e1530000 cmp r3, r0 1bf60: 03a05000 moveq r5, #0
1bf64: 1affff91 bne 1bdb0 <rtems_rfs_file_close+0x104>
1bf68: eaffff95 b 1bdc4 <rtems_rfs_file_close+0x118>
handle->shared->references--;
if (handle->shared->references == 0)
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
1bf6c: e281100c add r1, r1, #12 1bf70: e1a00006 mov r0, r6 1bf74: ebffd3a9 bl 10e20 <rtems_rfs_inode_load>
if (rrc == 0)
1bf78: e2505000 subs r5, r0, #0 1bf7c: e594101c ldr r1, [r4, #28]
1bf80: 1affff8f bne 1bdc4 <rtems_rfs_file_close+0x118>
1bf84: e5913018 ldr r3, [r1, #24] 1bf88: eaffff59 b 1bcf4 <rtems_rfs_file_close+0x48>
0001c804 <rtems_rfs_file_get_shared>:
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
1c804: e5903074 ldr r3, [r0, #116] ; 0x74
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 ));
1c808: e2800078 add r0, r0, #120 ; 0x78
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
1c80c: e1530000 cmp r3, r0
1c810: 0a000009 beq 1c83c <rtems_rfs_file_get_shared+0x38>
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
1c814: e5932014 ldr r2, [r3, #20] 1c818: e1520001 cmp r2, r1
1c81c: 1a000003 bne 1c830 <rtems_rfs_file_get_shared+0x2c>
1c820: ea000009 b 1c84c <rtems_rfs_file_get_shared+0x48>
1c824: e5932014 ldr r2, [r3, #20] <== NOT EXECUTED 1c828: e1520001 cmp r2, r1 <== NOT EXECUTED 1c82c: 0a000004 beq 1c844 <rtems_rfs_file_get_shared+0x40> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
1c830: e5933000 ldr r3, [r3] <== NOT EXECUTED
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
1c834: e1530000 cmp r3, r0 <== NOT EXECUTED 1c838: 1afffff9 bne 1c824 <rtems_rfs_file_get_shared+0x20> <== NOT EXECUTED
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
return shared;
node = rtems_chain_next (node);
}
return NULL;
1c83c: e3a00000 mov r0, #0 1c840: e12fff1e bx lr
1c844: e1a00003 mov r0, r3 <== NOT EXECUTED
}
1c848: e12fff1e bx lr <== NOT EXECUTED
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
1c84c: e1a00003 mov r0, r3 1c850: e12fff1e bx lr
0001c1b4 <rtems_rfs_file_io_end>:
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
1c1b4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
1c1b8: e1a04000 mov r4, r0
1c1bc: e24dd008 sub sp, sp, #8
1c1c0: e1a07001 mov r7, r1
bool atime;
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1c1c4: e3a00000 mov r0, #0 1c1c8: e3a01020 mov r1, #32
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
1c1cc: e20250ff and r5, r2, #255 ; 0xff
bool atime;
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1c1d0: ebffd996 bl 12830 <rtems_rfs_trace> 1c1d4: e3500000 cmp r0, #0
1c1d8: 0a000006 beq 1c1f8 <rtems_rfs_file_io_end+0x44>
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
1c1dc: e59f31f8 ldr r3, [pc, #504] ; 1c3dc <rtems_rfs_file_io_end+0x228><== NOT EXECUTED 1c1e0: e3550000 cmp r5, #0 <== NOT EXECUTED 1c1e4: e59f11f4 ldr r1, [pc, #500] ; 1c3e0 <rtems_rfs_file_io_end+0x22c><== NOT EXECUTED 1c1e8: e59f01f4 ldr r0, [pc, #500] ; 1c3e4 <rtems_rfs_file_io_end+0x230><== NOT EXECUTED 1c1ec: 11a01003 movne r1, r3 <== NOT EXECUTED 1c1f0: e1a02007 mov r2, r7 <== NOT EXECUTED 1c1f4: eb0010aa bl 204a4 <printf> <== NOT EXECUTED
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
1c1f8: e594600c ldr r6, [r4, #12] 1c1fc: e3560000 cmp r6, #0
1c200: 0a000017 beq 1c264 <rtems_rfs_file_io_end+0xb0>
{
if (!read)
1c204: e3550000 cmp r5, #0
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
1c208: 03a03001 moveq r3, #1 1c20c: 05c43004 strbeq r3, [r4, #4]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
1c210: e594301c ldr r3, [r4, #28] 1c214: e2841004 add r1, r4, #4 1c218: e5930098 ldr r0, [r3, #152] ; 0x98 1c21c: ebfff6b7 bl 19d00 <rtems_rfs_buffer_handle_release>
rtems_rfs_file_buffer (handle));
if (rc > 0)
1c220: e2506000 subs r6, r0, #0
1c224: da00000e ble 1c264 <rtems_rfs_file_io_end+0xb0>
{
printf (
1c228: e59f31ac ldr r3, [pc, #428] ; 1c3dc <rtems_rfs_file_io_end+0x228><== NOT EXECUTED 1c22c: e59f21ac ldr r2, [pc, #428] ; 1c3e0 <rtems_rfs_file_io_end+0x22c><== NOT EXECUTED 1c230: e3550000 cmp r5, #0 <== NOT EXECUTED 1c234: 01a05002 moveq r5, r2 <== NOT EXECUTED 1c238: 11a05003 movne r5, r3 <== NOT EXECUTED 1c23c: eb001546 bl 2175c <strerror> <== NOT EXECUTED 1c240: e1a01005 mov r1, r5 <== NOT EXECUTED 1c244: e58d0000 str r0, [sp] <== NOT EXECUTED 1c248: e1a02007 mov r2, r7 <== NOT EXECUTED 1c24c: e1a03006 mov r3, r6 <== NOT EXECUTED 1c250: e59f0190 ldr r0, [pc, #400] ; 1c3e8 <rtems_rfs_file_io_end+0x234><== NOT EXECUTED 1c254: eb001092 bl 204a4 <printf> <== NOT EXECUTED
handle->shared->size.offset =
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
1c258: e1a00006 mov r0, r6
1c25c: e28dd008 add sp, sp, #8
1c260: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
1c264: e594301c ldr r3, [r4, #28] 1c268: e5932098 ldr r2, [r3, #152] ; 0x98
* 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;
1c26c: e5941014 ldr r1, [r4, #20]
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
1c270: e5922008 ldr r2, [r2, #8]
* 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;
1c274: e0877001 add r7, r7, r1
if (handle->bpos.boff >=
1c278: e1570002 cmp r7, r2
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
1c27c: 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;
1c280: e5847014 str r7, [r4, #20]
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
1c284: 20627007 rsbcs r7, r2, r7
handle->bpos.boff += size;
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
1c288: 22812001 addcs r2, r1, #1 1c28c: 25842010 strcs r2, [r4, #16]
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
1c290: 25847014 strcs r7, [r4, #20]
}
length = false;
mtime = false;
if (!read &&
1c294: e3550000 cmp r5, #0
1c298: 1a00000f bne 1c2dc <rtems_rfs_file_io_end+0x128>
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
1c29c: e5942010 ldr r2, [r4, #16]
}
length = false;
mtime = false;
if (!read &&
1c2a0: e3520000 cmp r2, #0
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
1c2a4: e593103c ldr r1, [r3, #60] ; 0x3c
}
length = false;
mtime = false;
if (!read &&
1c2a8: 0a000006 beq 1c2c8 <rtems_rfs_file_io_end+0x114>
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
1c2ac: e3510000 cmp r1, #0
1c2b0: 1a000004 bne 1c2c8 <rtems_rfs_file_io_end+0x114>
1c2b4: e5942014 ldr r2, [r4, #20]
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
map->dirty = true;
1c2b8: e3a07001 mov r7, #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;
1c2bc: e5832040 str r2, [r3, #64] ; 0x40
map->dirty = true;
1c2c0: e5c37034 strb r7, [r3, #52] ; 0x34 1c2c4: ea000005 b 1c2e0 <rtems_rfs_file_io_end+0x12c> 1c2c8: e1520001 cmp r2, r1
1c2cc: 2afffff8 bcs 1c2b4 <rtems_rfs_file_io_end+0x100>
1c2d0: e2411001 sub r1, r1, #1 1c2d4: e1520001 cmp r2, r1
1c2d8: 0a00003a beq 1c3c8 <rtems_rfs_file_io_end+0x214>
handle->bpos.bno++;
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
}
length = false;
mtime = false;
1c2dc: e3a07000 mov r7, #0
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
1c2e0: e5943000 ldr r3, [r4] 1c2e4: e3130001 tst r3, #1 1c2e8: 13a08000 movne r8, #0 1c2ec: 03a08001 moveq r8, #1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
1c2f0: e3130002 tst r3, #2 1c2f4: 0207a0ff andeq sl, r7, #255 ; 0xff 1c2f8: 13a0a000 movne sl, #0
length = rtems_rfs_file_update_length (handle) && length;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1c2fc: 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;
1c300: e3130004 tst r3, #4
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1c304: 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;
1c308: 13a07000 movne r7, #0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1c30c: ebffd947 bl 12830 <rtems_rfs_trace> 1c310: e3500000 cmp r0, #0
1c314: 1a000011 bne 1c360 <rtems_rfs_file_io_end+0x1ac>
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
handle->bpos.bno, handle->bpos.boff,
atime ? 'A' : '-', mtime ? 'M' : '-', length ? 'L' : '-');
if (atime || mtime)
1c318: e3580000 cmp r8, #0
1c31c: 1a000001 bne 1c328 <rtems_rfs_file_io_end+0x174>
1c320: e35a0000 cmp sl, #0 <== NOT EXECUTED 1c324: 0a000006 beq 1c344 <rtems_rfs_file_io_end+0x190> <== NOT EXECUTED
{
time_t now = time (NULL);
1c328: e3a00000 mov r0, #0 1c32c: eb002097 bl 24590 <time>
if (read && atime)
1c330: e3550000 cmp r5, #0
1c334: 0a000019 beq 1c3a0 <rtems_rfs_file_io_end+0x1ec>
1c338: e3580000 cmp r8, #0
handle->shared->atime = now;
1c33c: 1594301c ldrne r3, [r4, #28] 1c340: 1583008c strne r0, [r3, #140] ; 0x8c
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
1c344: e3570000 cmp r7, #0
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
1c348: 1594301c ldrne r3, [r4, #28]
handle->shared->size.offset =
1c34c: 1283103c addne r1, r3, #60 ; 0x3c
1c350: 18910006 ldmne r1, {r1, r2}
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
1c354: 15831084 strne r1, [r3, #132] ; 0x84
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
1c358: 15832088 strne r2, [r3, #136] ; 0x88 1c35c: eaffffbd b 1c258 <rtems_rfs_file_io_end+0xa4>
atime = rtems_rfs_file_update_atime (handle);
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
length = rtems_rfs_file_update_length (handle) && length;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
1c360: e35a0000 cmp sl, #0 <== NOT EXECUTED
1c364: 03a0e02d moveq lr, #45 ; 0x2d <== NOT EXECUTED
1c368: 13a0e04d movne lr, #77 ; 0x4d <== NOT EXECUTED
1c36c: e3570000 cmp r7, #0 <== NOT EXECUTED
1c370: 03a0c02d moveq ip, #45 ; 0x2d <== NOT EXECUTED
1c374: 13a0c04c movne ip, #76 ; 0x4c <== NOT EXECUTED
1c378: e2841010 add r1, r4, #16 <== NOT EXECUTED
1c37c: e3580000 cmp r8, #0 <== NOT EXECUTED
1c380: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
1c384: 03a0302d moveq r3, #45 ; 0x2d <== NOT EXECUTED
1c388: 13a03041 movne r3, #65 ; 0x41 <== NOT EXECUTED
1c38c: e59f0058 ldr r0, [pc, #88] ; 1c3ec <rtems_rfs_file_io_end+0x238><== NOT EXECUTED
1c390: e58de000 str lr, [sp] <== NOT EXECUTED
1c394: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
1c398: eb001041 bl 204a4 <printf> <== NOT EXECUTED
1c39c: eaffffdd b 1c318 <rtems_rfs_file_io_end+0x164> <== NOT EXECUTED
if (atime || mtime)
{
time_t now = time (NULL);
if (read && atime)
handle->shared->atime = now;
if (!read && mtime)
1c3a0: e35a0000 cmp sl, #0
handle->shared->mtime = now;
1c3a4: 1594301c ldrne r3, [r4, #28] 1c3a8: 15830090 strne r0, [r3, #144] ; 0x90
} if (length)
1c3ac: e3570000 cmp r7, #0
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
1c3b0: 1594301c ldrne r3, [r4, #28]
handle->shared->size.offset =
1c3b4: 1283103c addne r1, r3, #60 ; 0x3c
1c3b8: 18910006 ldmne r1, {r1, r2}
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
1c3bc: 15831084 strne r1, [r3, #132] ; 0x84
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
1c3c0: 15832088 strne r2, [r3, #136] ; 0x88 1c3c4: eaffffa3 b 1c258 <rtems_rfs_file_io_end+0xa4>
length = false;
mtime = false;
if (!read &&
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
1c3c8: e5942014 ldr r2, [r4, #20] 1c3cc: e5931040 ldr r1, [r3, #64] ; 0x40 1c3d0: e1520001 cmp r2, r1
1c3d4: 9affffc0 bls 1c2dc <rtems_rfs_file_io_end+0x128>
1c3d8: eaffffb6 b 1c2b8 <rtems_rfs_file_io_end+0x104>
0001c3f0 <rtems_rfs_file_io_release>:
int
rtems_rfs_file_io_release (rtems_rfs_file_handle* handle)
{
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
1c3f0: e590300c ldr r3, [r0, #12] 1c3f4: e3530000 cmp r3, #0
1c3f8: 0a000003 beq 1c40c <rtems_rfs_file_io_release+0x1c>
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
1c3fc: e590301c ldr r3, [r0, #28] <== NOT EXECUTED 1c400: e2801004 add r1, r0, #4 <== NOT EXECUTED 1c404: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 1c408: eafff63c b 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
return rc;
}
1c40c: e1a00003 mov r0, r3 1c410: e12fff1e bx lr
0001bf9c <rtems_rfs_file_io_start>:
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
1bf9c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
1bfa0: e1a04000 mov r4, r0
1bfa4: e24dd004 sub sp, sp, #4
1bfa8: e1a06001 mov r6, r1
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1bfac: e3a00000 mov r0, #0 1bfb0: e3a01020 mov r1, #32
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
1bfb4: e20250ff and r5, r2, #255 ; 0xff
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1bfb8: ebffda1c bl 12830 <rtems_rfs_trace> 1bfbc: e3500000 cmp r0, #0
1bfc0: 0a000007 beq 1bfe4 <rtems_rfs_file_io_start+0x48>
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
1bfc4: e59f31c8 ldr r3, [pc, #456] ; 1c194 <rtems_rfs_file_io_start+0x1f8><== NOT EXECUTED
1bfc8: e3550000 cmp r5, #0 <== NOT EXECUTED
1bfcc: e2842010 add r2, r4, #16 <== NOT EXECUTED
1bfd0: e59f11c0 ldr r1, [pc, #448] ; 1c198 <rtems_rfs_file_io_start+0x1fc><== NOT EXECUTED
1bfd4: e59f01c0 ldr r0, [pc, #448] ; 1c19c <rtems_rfs_file_io_start+0x200><== NOT EXECUTED
1bfd8: 11a01003 movne r1, r3 <== NOT EXECUTED
1bfdc: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
1bfe0: eb00112f bl 204a4 <printf> <== NOT EXECUTED
read ? "read" : "write", handle->bpos.bno, handle->bpos.boff);
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
1bfe4: e594700c ldr r7, [r4, #12] 1bfe8: e3570000 cmp r7, #0
1bfec: 0a000021 beq 1c078 <rtems_rfs_file_io_start+0xdc>
block, request_read);
if (rc > 0)
return rc;
}
if (read
1bff0: e3550000 cmp r5, #0
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
1bff4: e594301c ldr r3, [r4, #28]
block, request_read);
if (rc > 0)
return rc;
}
if (read
1bff8: 1a000010 bne 1c040 <rtems_rfs_file_io_start+0xa4>
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
size = rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
else
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
1bffc: e5933098 ldr r3, [r3, #152] ; 0x98 1c000: e5935008 ldr r5, [r3, #8]
*available = size - rtems_rfs_file_block_offset (handle);
1c004: e5943014 ldr r3, [r4, #20] 1c008: e0633005 rsb r3, r3, r5 1c00c: e5863000 str r3, [r6]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1c010: e3a00000 mov r0, #0 1c014: e3a01020 mov r1, #32 1c018: ebffda04 bl 12830 <rtems_rfs_trace> 1c01c: e3500000 cmp r0, #0
1c020: 0a000004 beq 1c038 <rtems_rfs_file_io_start+0x9c>
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
1c024: e59f0174 ldr r0, [pc, #372] ; 1c1a0 <rtems_rfs_file_io_start+0x204><== NOT EXECUTED 1c028: e5961000 ldr r1, [r6] <== NOT EXECUTED 1c02c: e1a02005 mov r2, r5 <== NOT EXECUTED 1c030: eb00111b bl 204a4 <printf> <== NOT EXECUTED
*available, size);
return 0;
1c034: e3a00000 mov r0, #0 <== NOT EXECUTED
}
1c038: e28dd004 add sp, sp, #4
1c03c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
if (rc > 0)
return rc;
}
if (read
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
1c040: e5932044 ldr r2, [r3, #68] ; 0x44 1c044: e3520000 cmp r2, #0 1c048: e593103c ldr r1, [r3, #60] ; 0x3c
1c04c: 1a000005 bne 1c068 <rtems_rfs_file_io_start+0xcc>
1c050: e3510000 cmp r1, #0
1c054: 1a000003 bne 1c068 <rtems_rfs_file_io_start+0xcc>
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
1c058: e5935040 ldr r5, [r3, #64] ; 0x40 1c05c: e3550000 cmp r5, #0
1c060: 1affffe7 bne 1c004 <rtems_rfs_file_io_start+0x68>
1c064: eaffffe4 b 1bffc <rtems_rfs_file_io_start+0x60>
if (rc > 0)
return rc;
}
if (read
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
1c068: e2411001 sub r1, r1, #1 1c06c: e1520001 cmp r2, r1
1c070: 1affffe1 bne 1bffc <rtems_rfs_file_io_start+0x60>
1c074: eafffff7 b 1c058 <rtems_rfs_file_io_start+0xbc>
bool request_read;
int rc;
request_read = read;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
1c078: e594101c ldr r1, [r4, #28] 1c07c: e2842010 add r2, r4, #16 1c080: e5910098 ldr r0, [r1, #152] ; 0x98 1c084: e1a0300d mov r3, sp 1c088: e2811034 add r1, r1, #52 ; 0x34 1c08c: ebfff476 bl 1926c <rtems_rfs_block_map_find>
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
1c090: e3500000 cmp r0, #0
1c094: da000005 ble 1c0b0 <rtems_rfs_file_io_start+0x114>
{
/*
* Has the read reached the EOF ?
*/
if (read && (rc == ENXIO))
1c098: e3550000 cmp r5, #0
1c09c: 0a000027 beq 1c140 <rtems_rfs_file_io_start+0x1a4>
1c0a0: e3500006 cmp r0, #6 <== NOT EXECUTED
{
*available = 0;
1c0a4: 05867000 streq r7, [r6] <== NOT EXECUTED
return 0;
1c0a8: 01a00007 moveq r0, r7 <== NOT EXECUTED 1c0ac: eaffffe1 b 1c038 <rtems_rfs_file_io_start+0x9c> <== NOT EXECUTED
/*
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
1c0b0: e3550000 cmp r5, #0
1c0b4: 1a00000a bne 1c0e4 <rtems_rfs_file_io_start+0x148>
1c0b8: e5943014 ldr r3, [r4, #20] 1c0bc: e3530000 cmp r3, #0
1c0c0: 1a000007 bne 1c0e4 <rtems_rfs_file_io_start+0x148>
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
1c0c4: e594301c ldr r3, [r4, #28] 1c0c8: 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) ||
1c0cc: e5962000 ldr r2, [r6] 1c0d0: e5933008 ldr r3, [r3, #8] 1c0d4: e1520003 cmp r2, r3 1c0d8: 21a07005 movcs r7, r5 1c0dc: 21a08005 movcs r8, r5
1c0e0: 2a000001 bcs 1c0ec <rtems_rfs_file_io_start+0x150>
1c0e4: e3a07001 mov r7, #1
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
request_read = true;
1c0e8: e1a08007 mov r8, r7
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1c0ec: e3a00000 mov r0, #0 1c0f0: e3a01020 mov r1, #32 1c0f4: ebffd9cd bl 12830 <rtems_rfs_trace> 1c0f8: e3500000 cmp r0, #0
1c0fc: 0a000006 beq 1c11c <rtems_rfs_file_io_start+0x180>
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
1c100: e59f309c ldr r3, [pc, #156] ; 1c1a4 <rtems_rfs_file_io_start+0x208><== NOT EXECUTED 1c104: e3580000 cmp r8, #0 <== NOT EXECUTED 1c108: e59f2098 ldr r2, [pc, #152] ; 1c1a8 <rtems_rfs_file_io_start+0x20c><== NOT EXECUTED 1c10c: e59f0098 ldr r0, [pc, #152] ; 1c1ac <rtems_rfs_file_io_start+0x210><== NOT EXECUTED 1c110: e59d1000 ldr r1, [sp] <== NOT EXECUTED 1c114: 01a02003 moveq r2, r3 <== NOT EXECUTED 1c118: eb0010e1 bl 204a4 <printf> <== NOT EXECUTED
block, request_read ? "yes" : "no");
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
1c11c: e594301c ldr r3, [r4, #28] 1c120: e2841004 add r1, r4, #4 1c124: e5930098 ldr r0, [r3, #152] ; 0x98 1c128: e59d2000 ldr r2, [sp] 1c12c: e1a03007 mov r3, r7 1c130: ebfff76b bl 19ee4 <rtems_rfs_buffer_handle_request>
rtems_rfs_file_buffer (handle),
block, request_read);
if (rc > 0)
1c134: e3500000 cmp r0, #0
1c138: caffffbe bgt 1c038 <rtems_rfs_file_io_start+0x9c>
1c13c: eaffffab b 1bff0 <rtems_rfs_file_io_start+0x54>
{
*available = 0;
return 0;
}
if (rc != ENXIO)
1c140: e3500006 cmp r0, #6
1c144: 1affffbb bne 1c038 <rtems_rfs_file_io_start+0x9c>
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1c148: e3a00000 mov r0, #0 1c14c: e3a01020 mov r1, #32 1c150: ebffd9b6 bl 12830 <rtems_rfs_trace> 1c154: e3500000 cmp r0, #0
1c158: 1a00000a bne 1c188 <rtems_rfs_file_io_start+0x1ec>
printf ("rtems-rfs: file-io: start: grow\n");
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
1c15c: e594101c ldr r1, [r4, #28] 1c160: e3a02001 mov r2, #1 1c164: e5910098 ldr r0, [r1, #152] ; 0x98 1c168: e1a0300d mov r3, sp 1c16c: e2811034 add r1, r1, #52 ; 0x34 1c170: ebfff4c3 bl 19484 <rtems_rfs_block_map_grow>
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
1c174: e3500000 cmp r0, #0 1c178: d3a07000 movle r7, #0
return rc;
request_read = false;
1c17c: d1a08007 movle r8, r7
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)
1c180: caffffac bgt 1c038 <rtems_rfs_file_io_start+0x9c>
1c184: eaffffd8 b 1c0ec <rtems_rfs_file_io_start+0x150>
if (rc != ENXIO)
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: grow\n");
1c188: e59f0020 ldr r0, [pc, #32] ; 1c1b0 <rtems_rfs_file_io_start+0x214><== NOT EXECUTED 1c18c: eb00115c bl 20704 <puts> <== NOT EXECUTED 1c190: eafffff1 b 1c15c <rtems_rfs_file_io_start+0x1c0> <== NOT EXECUTED
0001b980 <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)
{
1b980: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1b984: e1a08000 mov r8, r0
1b988: e24dd004 sub sp, sp, #4
1b98c: e1a05001 mov r5, r1
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
1b990: e3a00000 mov r0, #0 1b994: 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)
{
1b998: e1a0b002 mov fp, r2 1b99c: e1a07003 mov r7, r3
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
1b9a0: ebffdba2 bl 12830 <rtems_rfs_trace> 1b9a4: e3500000 cmp r0, #0
1b9a8: 1a00002c bne 1ba60 <rtems_rfs_file_open+0xe0>
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
*file = NULL;
1b9ac: e3a0a000 mov sl, #0 1b9b0: e587a000 str sl, [r7]
/* * 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));
1b9b4: e3a00020 mov r0, #32 1b9b8: ebffaf9d bl 7834 <malloc>
if (!handle)
1b9bc: e2506000 subs r6, r0, #0
return ENOMEM;
1b9c0: 03a0a00c moveq sl, #12
* 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));
if (!handle)
1b9c4: 0a000022 beq 1ba54 <rtems_rfs_file_open+0xd4>
return ENOMEM;
memset (handle, 0, sizeof (rtems_rfs_file_handle));
1b9c8: e1a09006 mov r9, r6 1b9cc: e489a004 str sl, [r9], #4 1b9d0: e2893008 add r3, r9, #8 1b9d4: e586a004 str sl, [r6, #4] 1b9d8: e483a004 str sl, [r3], #4 1b9dc: e483a004 str sl, [r3], #4 1b9e0: e483a004 str sl, [r3], #4 1b9e4: e483a004 str sl, [r3], #4 1b9e8: e583a000 str sl, [r3]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
1b9ec: e5984074 ldr r4, [r8, #116] ; 0x74
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 ));
1b9f0: e2882078 add r2, r8, #120 ; 0x78
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
1b9f4: e1540002 cmp r4, r2
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
1b9f8: e5c6a004 strb sl, [r6, #4]
handle->bnum = 0;
1b9fc: e586a008 str sl, [r6, #8]
handle->buffer = NULL;
1ba00: e586a00c str sl, [r6, #12]
1ba04: 1a000003 bne 1ba18 <rtems_rfs_file_open+0x98>
1ba08: ea000020 b 1ba90 <rtems_rfs_file_open+0x110>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
1ba0c: e5944000 ldr r4, [r4] <== NOT EXECUTED 1ba10: e1540002 cmp r4, r2 <== NOT EXECUTED 1ba14: 0a00001d beq 1ba90 <rtems_rfs_file_open+0x110> <== NOT EXECUTED
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
1ba18: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 1ba1c: e1550003 cmp r5, r3 <== NOT EXECUTED 1ba20: 1afffff9 bne 1ba0c <rtems_rfs_file_open+0x8c> <== NOT EXECUTED
* the reference count and return the pointer to the data.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
if (shared)
{
shared->references++;
1ba24: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 1ba28: e2833001 add r3, r3, #1 <== NOT EXECUTED 1ba2c: e5843008 str r3, [r4, #8] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
1ba30: e3a00000 mov r0, #0 <== NOT EXECUTED 1ba34: e3a01008 mov r1, #8 <== NOT EXECUTED 1ba38: ebffdb7c bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1ba3c: e3500000 cmp r0, #0 <== NOT EXECUTED 1ba40: 1a00000a bne 1ba70 <rtems_rfs_file_open+0xf0> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
}
handle->flags = oflag;
1ba44: e586b000 str fp, [r6]
handle->shared = shared;
1ba48: e586401c str r4, [r6, #28]
*file = handle;
1ba4c: e5876000 str r6, [r7]
return 0;
1ba50: e3a0a000 mov sl, #0
}
1ba54: e1a0000a mov r0, sl
1ba58: e28dd004 add sp, sp, #4
1ba5c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
1ba60: e1a01005 mov r1, r5 <== NOT EXECUTED 1ba64: e59f022c ldr r0, [pc, #556] ; 1bc98 <rtems_rfs_file_open+0x318><== NOT EXECUTED 1ba68: eb00128d bl 204a4 <printf> <== NOT EXECUTED 1ba6c: eaffffce b 1b9ac <rtems_rfs_file_open+0x2c> <== NOT EXECUTED
shared = rtems_rfs_file_get_shared (fs, ino);
if (shared)
{
shared->references++;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
1ba70: e1a01005 mov r1, r5 <== NOT EXECUTED 1ba74: e59f0220 ldr r0, [pc, #544] ; 1bc9c <rtems_rfs_file_open+0x31c><== NOT EXECUTED 1ba78: eb001289 bl 204a4 <printf> <== NOT EXECUTED
handle->flags = oflag;
handle->shared = shared;
*file = handle;
return 0;
1ba7c: e3a0a000 mov sl, #0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
}
handle->flags = oflag;
1ba80: e586b000 str fp, [r6] <== NOT EXECUTED
handle->shared = shared;
1ba84: e586401c str r4, [r6, #28] <== NOT EXECUTED
*file = handle;
1ba88: e5876000 str r6, [r7] <== NOT EXECUTED 1ba8c: eafffff0 b 1ba54 <rtems_rfs_file_open+0xd4> <== 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));
1ba90: e3a0009c mov r0, #156 ; 0x9c 1ba94: ebffaf66 bl 7834 <malloc>
if (!shared)
1ba98: e2504000 subs r4, r0, #0
1ba9c: 0a000037 beq 1bb80 <rtems_rfs_file_open+0x200>
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
1baa0: e284300c add r3, r4, #12
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
1baa4: e3a01000 mov r1, #0 1baa8: e3a0209c mov r2, #156 ; 0x9c
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
1baac: e58d3000 str r3, [sp]
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
1bab0: eb00120a bl 202e0 <memset>
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
1bab4: e1a00008 mov r0, r8 1bab8: e1a01005 mov r1, r5 1babc: e59d2000 ldr r2, [sp] 1bac0: e3a03001 mov r3, #1 1bac4: ebffd4ff bl 10ec8 <rtems_rfs_inode_open>
if (rc > 0)
1bac8: e250a000 subs sl, r0, #0
1bacc: da000016 ble 1bb2c <rtems_rfs_file_open+0x1ac>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
1bad0: e3a00000 mov r0, #0 <== NOT EXECUTED 1bad4: e3a01008 mov r1, #8 <== NOT EXECUTED 1bad8: ebffdb54 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1badc: e3500000 cmp r0, #0 <== NOT EXECUTED 1bae0: 0a000005 beq 1bafc <rtems_rfs_file_open+0x17c> <== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
1bae4: e1a0000a mov r0, sl <== NOT EXECUTED 1bae8: eb00171b bl 2175c <strerror> <== NOT EXECUTED 1baec: e1a0100a mov r1, sl <== NOT EXECUTED 1baf0: e1a02000 mov r2, r0 <== NOT EXECUTED 1baf4: e59f01a4 ldr r0, [pc, #420] ; 1bca0 <rtems_rfs_file_open+0x320><== NOT EXECUTED 1baf8: eb001269 bl 204a4 <printf> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
free (shared);
1bafc: e1a00004 mov r0, r4 <== NOT EXECUTED 1bb00: ebffadcc bl 7238 <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);
1bb04: e1a00008 mov r0, r8 <== NOT EXECUTED 1bb08: e1a01009 mov r1, r9 <== NOT EXECUTED 1bb0c: ebfff87b bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
1bb10: e3a03000 mov r3, #0 <== NOT EXECUTED 1bb14: e5c63004 strb r3, [r6, #4] <== NOT EXECUTED
handle->bnum = 0;
1bb18: e5863008 str r3, [r6, #8] <== NOT EXECUTED
handle->buffer = NULL;
1bb1c: e586300c str r3, [r6, #12] <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
1bb20: e1a00006 mov r0, r6 <== NOT EXECUTED 1bb24: ebffadc3 bl 7238 <free> <== NOT EXECUTED
return rc;
1bb28: eaffffc9 b 1ba54 <rtems_rfs_file_open+0xd4> <== 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);
1bb2c: e1a00008 mov r0, r8 1bb30: e59d1000 ldr r1, [sp] 1bb34: e2842034 add r2, r4, #52 ; 0x34 1bb38: ebfff4fe bl 18f38 <rtems_rfs_block_map_open>
if (rc > 0)
1bb3c: e250a000 subs sl, r0, #0
1bb40: da000018 ble 1bba8 <rtems_rfs_file_open+0x228>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
1bb44: e3a00000 mov r0, #0 <== NOT EXECUTED 1bb48: e3a01008 mov r1, #8 <== NOT EXECUTED 1bb4c: ebffdb37 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1bb50: e3500000 cmp r0, #0 <== NOT EXECUTED 1bb54: 0a000005 beq 1bb70 <rtems_rfs_file_open+0x1f0> <== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
1bb58: e1a0000a mov r0, sl <== NOT EXECUTED 1bb5c: eb0016fe bl 2175c <strerror> <== NOT EXECUTED 1bb60: e1a0100a mov r1, sl <== NOT EXECUTED 1bb64: e1a02000 mov r2, r0 <== NOT EXECUTED 1bb68: e59f0134 ldr r0, [pc, #308] ; 1bca4 <rtems_rfs_file_open+0x324><== NOT EXECUTED 1bb6c: eb00124c bl 204a4 <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
1bb70: e59d1000 ldr r1, [sp] <== NOT EXECUTED 1bb74: e1a00008 mov r0, r8 <== NOT EXECUTED 1bb78: ebffd54c bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED 1bb7c: eaffffde b 1bafc <rtems_rfs_file_open+0x17c> <== 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);
1bb80: e1a01009 mov r1, r9 <== NOT EXECUTED 1bb84: e1a00008 mov r0, r8 <== NOT EXECUTED 1bb88: ebfff85c bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
1bb8c: e5c64004 strb r4, [r6, #4] <== NOT EXECUTED
handle->bnum = 0;
1bb90: e5864008 str r4, [r6, #8] <== NOT EXECUTED
handle->buffer = NULL;
1bb94: e586400c str r4, [r6, #12] <== NOT EXECUTED
*/
shared = malloc (sizeof (rtems_rfs_file_shared));
if (!shared)
{
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
1bb98: e1a00006 mov r0, r6 <== NOT EXECUTED 1bb9c: ebffada5 bl 7238 <free> <== NOT EXECUTED
return ENOMEM;
1bba0: e3a0a00c mov sl, #12 <== NOT EXECUTED 1bba4: eaffffaa b 1ba54 <rtems_rfs_file_open+0xd4> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return rc;
}
shared->references = 1;
1bba8: e3a03001 mov r3, #1 1bbac: e5843008 str r3, [r4, #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);
1bbb0: e5943018 ldr r3, [r4, #24] 1bbb4: e5d3000d ldrb r0, [r3, #13] 1bbb8: e5d3c00c ldrb ip, [r3, #12] 1bbbc: e5d3200f ldrb r2, [r3, #15] 1bbc0: e1a00800 lsl r0, r0, #16 1bbc4: e5d3100e ldrb r1, [r3, #14] 1bbc8: e1800c0c orr r0, r0, ip, lsl #24 1bbcc: e1802002 orr r2, r0, r2 1bbd0: e1822401 orr r2, r2, r1, lsl #8
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
1bbd4: e5842084 str r2, [r4, #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);
1bbd8: e5d3100a ldrb r1, [r3, #10] 1bbdc: e5d3200b ldrb r2, [r3, #11]
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
1bbe0: e1822401 orr r2, r2, r1, lsl #8 1bbe4: e5842088 str r2, [r4, #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);
1bbe8: e5d30011 ldrb r0, [r3, #17] 1bbec: e5d3c010 ldrb ip, [r3, #16] 1bbf0: e5d32013 ldrb r2, [r3, #19] 1bbf4: e1a00800 lsl r0, r0, #16 1bbf8: e5d31012 ldrb r1, [r3, #18] 1bbfc: e1800c0c orr r0, r0, ip, lsl #24 1bc00: e1802002 orr r2, r0, r2 1bc04: e1822401 orr r2, r2, r1, lsl #8
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
1bc08: e584208c str r2, [r4, #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);
1bc0c: e5d30015 ldrb r0, [r3, #21] 1bc10: e5d3c014 ldrb ip, [r3, #20] 1bc14: e5d32017 ldrb r2, [r3, #23] 1bc18: e1a00800 lsl r0, r0, #16 1bc1c: e5d31016 ldrb r1, [r3, #22] 1bc20: e1800c0c orr r0, r0, ip, lsl #24 1bc24: e1802002 orr r2, r0, r2 1bc28: e1822401 orr r2, r2, r1, lsl #8
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
1bc2c: e5842090 str r2, [r4, #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);
1bc30: e5d30019 ldrb r0, [r3, #25] 1bc34: e5d3c018 ldrb ip, [r3, #24] 1bc38: e5d3101b ldrb r1, [r3, #27] 1bc3c: e1a00800 lsl r0, r0, #16 1bc40: e5d3201a ldrb r2, [r3, #26] 1bc44: e1803c0c orr r3, r0, ip, lsl #24 1bc48: e1833001 orr r3, r3, r1 1bc4c: e1833402 orr r3, r3, r2, lsl #8
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
1bc50: e5843094 str r3, [r4, #148] ; 0x94 1bc54: e2880074 add r0, r8, #116 ; 0x74 1bc58: e1a01004 mov r1, r4
shared->fs = fs;
1bc5c: e5848098 str r8, [r4, #152] ; 0x98 1bc60: ebffc289 bl c68c <_Chain_Append>
rtems_chain_append (&fs->file_shares, &shared->link);
rtems_rfs_inode_unload (fs, &shared->inode, false);
1bc64: e59d1000 ldr r1, [sp] 1bc68: e3a02000 mov r2, #0 1bc6c: e1a00008 mov r0, r8 1bc70: ebffd4d2 bl 10fc0 <rtems_rfs_inode_unload>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
1bc74: e3a00000 mov r0, #0 1bc78: e3a01008 mov r1, #8 1bc7c: ebffdaeb bl 12830 <rtems_rfs_trace> 1bc80: e3500000 cmp r0, #0
1bc84: 0affff6e beq 1ba44 <rtems_rfs_file_open+0xc4>
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
1bc88: e1a01005 mov r1, r5 <== NOT EXECUTED 1bc8c: e59f0014 ldr r0, [pc, #20] ; 1bca8 <rtems_rfs_file_open+0x328><== NOT EXECUTED 1bc90: eb001203 bl 204a4 <printf> <== NOT EXECUTED 1bc94: eaffff6a b 1ba44 <rtems_rfs_file_open+0xc4> <== NOT EXECUTED
0001c414 <rtems_rfs_file_seek>:
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
1c414: e92d41f0 push {r4, r5, r6, r7, r8, lr}
1c418: e1a06001 mov r6, r1
1c41c: e24dd004 sub sp, sp, #4
1c420: e1a04000 mov r4, r0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1c424: e3a01020 mov r1, #32 1c428: e3a00000 mov r0, #0
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
1c42c: e1a07002 mov r7, r2 1c430: e1a05003 mov r5, r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1c434: ebffd8fd bl 12830 <rtems_rfs_trace> 1c438: e3500000 cmp r0, #0
1c43c: 1a000021 bne 1c4c8 <rtems_rfs_file_seek+0xb4> * 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),
1c440: e594101c ldr r1, [r4, #28] 1c444: e5910098 ldr r0, [r1, #152] ; 0x98 1c448: e2811084 add r1, r1, #132 ; 0x84 1c44c: ebfff2a9 bl 18ef8 <rtems_rfs_block_get_size> 1c450: e1510007 cmp r1, r7 1c454: 01500006 cmpeq r0, r6
1c458: 3a000013 bcc 1c4ac <rtems_rfs_file_seek+0x98>
handle->shared))
{
rtems_rfs_file_set_bpos (handle, pos);
1c45c: e594301c ldr r3, [r4, #28] 1c460: e2848010 add r8, r4, #16 1c464: e5930098 ldr r0, [r3, #152] ; 0x98 1c468: e1a01006 mov r1, r6 1c46c: e1a03008 mov r3, r8 1c470: e1a02007 mov r2, r7 1c474: ebfff26f bl 18e38 <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))
1c478: e594300c ldr r3, [r4, #12] 1c47c: e3530000 cmp r3, #0
1c480: 0a00000d beq 1c4bc <rtems_rfs_file_seek+0xa8>
{
rtems_rfs_buffer_block block;
int rc;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
1c484: e594101c ldr r1, [r4, #28] 1c488: e1a02008 mov r2, r8 1c48c: e5910098 ldr r0, [r1, #152] ; 0x98 1c490: e1a0300d mov r3, sp 1c494: e2811034 add r1, r1, #52 ; 0x34 1c498: ebfff373 bl 1926c <rtems_rfs_block_map_find>
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
1c49c: e3500000 cmp r0, #0
1c4a0: da00000d ble 1c4dc <rtems_rfs_file_seek+0xc8>
return rc;
}
*new_pos = pos;
return 0;
}
1c4a4: e28dd004 add sp, sp, #4
1c4a8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
{
/*
* 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);
1c4ac: e1a00004 mov r0, r4 1c4b0: ebffffce bl 1c3f0 <rtems_rfs_file_io_release>
if (rc > 0)
1c4b4: e3500000 cmp r0, #0
1c4b8: cafffff9 bgt 1c4a4 <rtems_rfs_file_seek+0x90>
return rc;
}
*new_pos = pos;
1c4bc: e88500c0 stm r5, {r6, r7}
return 0;
1c4c0: e3a00000 mov r0, #0 1c4c4: eafffff6 b 1c4a4 <rtems_rfs_file_seek+0x90>
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
1c4c8: e1a01006 mov r1, r6 <== NOT EXECUTED 1c4cc: e1a02007 mov r2, r7 <== NOT EXECUTED 1c4d0: e59f0030 ldr r0, [pc, #48] ; 1c508 <rtems_rfs_file_seek+0xf4><== NOT EXECUTED 1c4d4: eb000ff2 bl 204a4 <printf> <== NOT EXECUTED 1c4d8: eaffffd8 b 1c440 <rtems_rfs_file_seek+0x2c> <== NOT EXECUTED
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
return rc;
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
1c4dc: e5942008 ldr r2, [r4, #8] 1c4e0: e59d3000 ldr r3, [sp] 1c4e4: e1520003 cmp r2, r3
1c4e8: 0afffff3 beq 1c4bc <rtems_rfs_file_seek+0xa8>
{
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
1c4ec: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 1c4f0: e2841004 add r1, r4, #4 <== NOT EXECUTED 1c4f4: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 1c4f8: ebfff600 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
if (rc > 0)
1c4fc: e3500000 cmp r0, #0 <== NOT EXECUTED 1c500: caffffe7 bgt 1c4a4 <rtems_rfs_file_seek+0x90> <== NOT EXECUTED 1c504: eaffffec b 1c4bc <rtems_rfs_file_seek+0xa8> <== NOT EXECUTED
0001c50c <rtems_rfs_file_set_size>:
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
1c50c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1c510: e24dd018 sub sp, sp, #24
1c514: e1a04000 mov r4, r0
1c518: e88d0006 stm sp, {r1, r2}
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1c51c: e3a00000 mov r0, #0 1c520: e3a01020 mov r1, #32
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
1c524: e594601c ldr r6, [r4, #28]
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
1c528: ebffd8c0 bl 12830 <rtems_rfs_trace> 1c52c: e3500000 cmp r0, #0
1c530: 1a000093 bne 1c784 <rtems_rfs_file_set_size+0x278>
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
size = rtems_rfs_file_size (handle);
1c534: e594101c ldr r1, [r4, #28] 1c538: e5910098 ldr r0, [r1, #152] ; 0x98 1c53c: e2811084 add r1, r1, #132 ; 0x84 1c540: ebfff26c bl 18ef8 <rtems_rfs_block_get_size>
/* * If the file is same size do nothing else grow or shrink it ? * * If the file does not change size do not update the times. */ if (size != new_size)
1c544: e89d1800 ldm sp, {fp, ip}
1c548: e15c0001 cmp ip, r1
1c54c: 015b0000 cmpeq fp, r0
1c550: 0a000089 beq 1c77c <rtems_rfs_file_set_size+0x270>
{
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
1c554: e19bc00c orrs ip, fp, ip
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
1c558: e286a034 add sl, r6, #52 ; 0x34
if (size != new_size)
{
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
1c55c: 0a00008c beq 1c794 <rtems_rfs_file_set_size+0x288>
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
1c560: e89d1800 ldm sp, {fp, ip}
1c564: e151000c cmp r1, ip
1c568: 0150000b cmpeq r0, fp
1c56c: 2a000055 bcs 1c6c8 <rtems_rfs_file_set_size+0x1bc>
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
1c570: e594801c ldr r8, [r4, #28]
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
1c574: e05bb000 subs fp, fp, r0 1c578: e0ccc001 sbc ip, ip, r1
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
1c57c: e5983098 ldr r3, [r8, #152] ; 0x98
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
1c580: e88d1800 stm sp, {fp, ip}
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
while (count)
1c584: e19bc00c orrs ip, fp, ip
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
1c588: e1a07008 mov r7, r8 1c58c: e5935008 ldr r5, [r3, #8]
read_block = false;
while (count)
1c590: 13a09000 movne r9, #0
* Have we reached the EOF ?
*/
if (rc != ENXIO)
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
1c594: 13a08001 movne r8, #1
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
while (count)
1c598: 1a000017 bne 1c5fc <rtems_rfs_file_set_size+0xf0>
1c59c: ea000083 b 1c7b0 <rtems_rfs_file_set_size+0x2a4> <== NOT EXECUTED
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
1c5a0: e594200c ldr r2, [r4, #12]
memset (dst + bpos.boff, 0, length - bpos.boff);
1c5a4: e59d300c ldr r3, [sp, #12] 1c5a8: e592001c ldr r0, [r2, #28] 1c5ac: e3a01000 mov r1, #0 1c5b0: e0632005 rsb r2, r3, r5 1c5b4: e0800003 add r0, r0, r3 1c5b8: eb000f48 bl 202e0 <memset>
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
1c5bc: e594301c ldr r3, [r4, #28]
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
memset (dst + bpos.boff, 0, length - bpos.boff);
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
1c5c0: e5c48004 strb r8, [r4, #4]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
1c5c4: e5930098 ldr r0, [r3, #152] ; 0x98 1c5c8: e1a01007 mov r1, r7 1c5cc: ebfff5cb bl 19d00 <rtems_rfs_buffer_handle_release>
rtems_rfs_file_buffer (handle));
if (rc > 0)
1c5d0: e2503000 subs r3, r0, #0
1c5d4: ca000038 bgt 1c6bc <rtems_rfs_file_set_size+0x1b0>
return rc;
count -= length - bpos.boff;
1c5d8: e59d300c ldr r3, [sp, #12]
1c5dc: e89d1800 ldm sp, {fp, ip}
1c5e0: e0633005 rsb r3, r3, r5
1c5e4: e05bb003 subs fp, fp, r3
1c5e8: e2ccc000 sbc ip, ip, #0
1c5ec: e88d1800 stm sp, {fp, ip}
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
while (count)
1c5f0: e19bc00c orrs ip, fp, ip
1c5f4: 0a00006c beq 1c7ac <rtems_rfs_file_set_size+0x2a0>
1c5f8: e594701c ldr r7, [r4, #28]
/*
* Get the block position for the current end of the file as seen by
* the map. If not found and the EOF grow the map then fill the block
* with 0.
*/
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
1c5fc: e286203c add r2, r6, #60 ; 0x3c
1c600: e892000c ldm r2, {r2, r3}
1c604: e3530000 cmp r3, #0
1c608: e58d2008 str r2, [sp, #8]
1c60c: e58d300c str r3, [sp, #12]
1c610: 12422001 subne r2, r2, #1
1c614: e3a03000 mov r3, #0
1c618: 158d2008 strne r2, [sp, #8]
1c61c: e58d3010 str r3, [sp, #16]
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
1c620: e5970098 ldr r0, [r7, #152] ; 0x98 1c624: e28d3014 add r3, sp, #20 1c628: e1a0100a mov r1, sl 1c62c: e28d2008 add r2, sp, #8 1c630: ebfff30d bl 1926c <rtems_rfs_block_map_find>
map, &bpos, &block);
if (rc > 0)
1c634: e2503000 subs r3, r0, #0
1c638: da000009 ble 1c664 <rtems_rfs_file_set_size+0x158>
{
/*
* Have we reached the EOF ?
*/
if (rc != ENXIO)
1c63c: e3530006 cmp r3, #6
1c640: 1a00001d bne 1c6bc <rtems_rfs_file_set_size+0x1b0>
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
1c644: e594301c ldr r3, [r4, #28] 1c648: e1a0100a mov r1, sl 1c64c: e5930098 ldr r0, [r3, #152] ; 0x98 1c650: e3a02001 mov r2, #1 1c654: e28d3014 add r3, sp, #20 1c658: ebfff389 bl 19484 <rtems_rfs_block_map_grow>
map, 1, &block);
if (rc > 0)
1c65c: e2503000 subs r3, r0, #0
1c660: ca000015 bgt 1c6bc <rtems_rfs_file_set_size+0x1b0>
return rc;
}
if (count < (length - bpos.boff))
1c664: e59d100c ldr r1, [sp, #12]
1c668: e89d1800 ldm sp, {fp, ip}
1c66c: e0610005 rsb r0, r1, r5
1c670: e3a03000 mov r3, #0
1c674: e1a02000 mov r2, r0
1c678: e15c0003 cmp ip, r3
1c67c: 015b0002 cmpeq fp, r2
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
1c680: e594201c ldr r2, [r4, #28]
return rc;
}
if (count < (length - bpos.boff))
{
length = count + bpos.boff;
1c684: 3081500b addcc r5, r1, fp
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
1c688: 23a03000 movcs r3, #0
map->dirty = true;
1c68c: 33a09001 movcc r9, #1
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
1c690: e2847004 add r7, r4, #4
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
1c694: 25863040 strcs r3, [r6, #64] ; 0x40 1c698: 35865040 strcc r5, [r6, #64] ; 0x40
map->dirty = true;
1c69c: e1a03009 mov r3, r9 1c6a0: e5920098 ldr r0, [r2, #152] ; 0x98 1c6a4: e5c68034 strb r8, [r6, #52] ; 0x34 1c6a8: e1a01007 mov r1, r7 1c6ac: e59d2014 ldr r2, [sp, #20] 1c6b0: ebfff60b bl 19ee4 <rtems_rfs_buffer_handle_request>
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
1c6b4: e2503000 subs r3, r0, #0
1c6b8: daffffb8 ble 1c5a0 <rtems_rfs_file_set_size+0x94>
if (rtems_rfs_file_update_mtime (handle))
handle->shared->mtime = time (NULL);
}
return 0;
}
1c6bc: e1a00003 mov r0, r3
1c6c0: e28dd018 add sp, sp, #24
1c6c4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
1c6c8: e594701c ldr r7, [r4, #28] 1c6cc: e597a098 ldr sl, [r7, #152] ; 0x98
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
1c6d0: e89d1800 ldm sp, {fp, ip}
1c6d4: e59a8008 ldr r8, [sl, #8]
1c6d8: e3e00000 mvn r0, #0
1c6dc: e090000b adds r0, r0, fp
1c6e0: e3e01000 mvn r1, #0
1c6e4: e0a1100c adc r1, r1, ip
1c6e8: e1a02008 mov r2, r8
1c6ec: e3a03000 mov r3, #0
1c6f0: eb004735 bl 2e3cc <__udivdi3>
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
1c6f4: e596503c ldr r5, [r6, #60] ; 0x3c
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
1c6f8: e1e02000 mvn r2, r0
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
if (blocks)
1c6fc: e0922005 adds r2, r2, r5
1c700: 1a000036 bne 1c7e0 <rtems_rfs_file_set_size+0x2d4>
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
1c704: e1a02008 mov r2, r8
1c708: e3a03000 mov r3, #0
1c70c: e89d0003 ldm sp, {r0, r1}
1c710: eb004851 bl 2e85c <__umoddi3>
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
1c714: e5943010 ldr r3, [r4, #16] 1c718: e3a02001 mov r2, #1 1c71c: e3530000 cmp r3, #0
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
1c720: e5860040 str r0, [r6, #64] ; 0x40
map->dirty = true;
1c724: e5c62034 strb r2, [r6, #52] ; 0x34
1c728: 0a000023 beq 1c7bc <rtems_rfs_file_set_size+0x2b0>
1c72c: e3550000 cmp r5, #0
1c730: 1a000021 bne 1c7bc <rtems_rfs_file_set_size+0x2b0>
rtems_rfs_block_map_size (map)))
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
1c734: e3a03000 mov r3, #0 1c738: e3500000 cmp r0, #0 1c73c: e5843018 str r3, [r4, #24] 1c740: 12453001 subne r3, r5, #1 1c744: e5845010 str r5, [r4, #16] 1c748: e5840014 str r0, [r4, #20] 1c74c: 15843010 strne r3, [r4, #16] 1c750: e1a08007 mov r8, r7
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
1c754: e5944000 ldr r4, [r4] 1c758: e2144002 ands r4, r4, #2
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
1c75c: e5885084 str r5, [r8, #132] ; 0x84
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
1c760: e5880088 str r0, [r8, #136] ; 0x88
if (rtems_rfs_file_update_mtime (handle))
1c764: 1a000004 bne 1c77c <rtems_rfs_file_set_size+0x270>
handle->shared->mtime = time (NULL);
1c768: e1a00004 mov r0, r4 1c76c: eb001f87 bl 24590 <time>
}
return 0;
1c770: e1a03004 mov r3, r4
handle->shared->size.count = rtems_rfs_block_map_count (map);
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
handle->shared->mtime = time (NULL);
1c774: e5880090 str r0, [r8, #144] ; 0x90 1c778: eaffffcf b 1c6bc <rtems_rfs_file_set_size+0x1b0>
}
return 0;
1c77c: e3a03000 mov r3, #0 1c780: eaffffcd b 1c6bc <rtems_rfs_file_set_size+0x1b0>
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
1c784: e89d0006 ldm sp, {r1, r2} <== NOT EXECUTED
1c788: e59f0070 ldr r0, [pc, #112] ; 1c800 <rtems_rfs_file_set_size+0x2f4><== NOT EXECUTED
1c78c: eb000f44 bl 204a4 <printf> <== NOT EXECUTED
1c790: eaffff67 b 1c534 <rtems_rfs_file_set_size+0x28> <== NOT EXECUTED
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
{
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
1c794: e594301c ldr r3, [r4, #28] 1c798: e1a0100a mov r1, sl 1c79c: e5930098 ldr r0, [r3, #152] ; 0x98 1c7a0: ebfff4f1 bl 19b6c <rtems_rfs_block_map_free_all>
if (rc > 0)
1c7a4: e2503000 subs r3, r0, #0
1c7a8: caffffc3 bgt 1c6bc <rtems_rfs_file_set_size+0x1b0>
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
while (count)
1c7ac: e594801c ldr r8, [r4, #28] 1c7b0: e596503c ldr r5, [r6, #60] ; 0x3c 1c7b4: e5960040 ldr r0, [r6, #64] ; 0x40 1c7b8: eaffffe5 b 1c754 <rtems_rfs_file_set_size+0x248>
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
1c7bc: e1530005 cmp r3, r5
1c7c0: 2affffdb bcs 1c734 <rtems_rfs_file_set_size+0x228>
1c7c4: e2452001 sub r2, r5, #1 1c7c8: e1530002 cmp r3, r2
1c7cc: 1affffdf bne 1c750 <rtems_rfs_file_set_size+0x244>
1c7d0: e5943014 ldr r3, [r4, #20] 1c7d4: e1500003 cmp r0, r3
1c7d8: 3affffd5 bcc 1c734 <rtems_rfs_file_set_size+0x228>
1c7dc: eaffffdb b 1c750 <rtems_rfs_file_set_size+0x244>
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
if (blocks)
{
int rc;
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
1c7e0: e1a0000a mov r0, sl 1c7e4: e2871034 add r1, r7, #52 ; 0x34 1c7e8: ebfff423 bl 1987c <rtems_rfs_block_map_shrink>
rtems_rfs_file_map (handle),
blocks);
if (rc > 0)
1c7ec: e2503000 subs r3, r0, #0
1c7f0: caffffb1 bgt 1c6bc <rtems_rfs_file_set_size+0x1b0>
1c7f4: e596503c ldr r5, [r6, #60] ; 0x3c 1c7f8: e594701c ldr r7, [r4, #28] 1c7fc: eaffffc0 b 1c704 <rtems_rfs_file_set_size+0x1f8>
0000f868 <rtems_rfs_format>:
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
f868: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
f86c: e5d13015 ldrb r3, [r1, #21]
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
f870: e24dd0e4 sub sp, sp, #228 ; 0xe4
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
f874: e3530000 cmp r3, #0
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
f878: e1a0a001 mov sl, r1
f87c: e58d0008 str r0, [sp, #8]
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
f880: 1a0000e6 bne fc20 <rtems_rfs_format+0x3b8>
printf ("rtems-rfs: format: %s\n", name);
memset (&fs, 0, sizeof (rtems_rfs_file_system));
f884: e3a01000 mov r1, #0
f888: e3a02084 mov r2, #132 ; 0x84
f88c: e28d000c add r0, sp, #12
f890: eb004292 bl 202e0 <memset>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
f894: e28de0e4 add lr, sp, #228 ; 0xe4
f898: e28d1054 add r1, sp, #84 ; 0x54
f89c: e1a0300e mov r3, lr
f8a0: e1a0c00e mov ip, lr
f8a4: e1a0200e mov r2, lr
f8a8: e52e1094 str r1, [lr, #-148]! ; 0x94
f8ac: e28d1064 add r1, sp, #100 ; 0x64
f8b0: e52c1084 str r1, [ip, #-132]! ; 0x84
f8b4: e28d1074 add r1, sp, #116 ; 0x74
f8b8: e5221074 str r1, [r2, #-116]! ; 0x74
f8bc: e28d1084 add r1, sp, #132 ; 0x84
f8c0: e5231064 str r1, [r3, #-100]! ; 0x64
head->previous = NULL; tail->previous = head;
f8c4: e58d3088 str r3, [sp, #136] ; 0x88
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;
f8c8: e3a03005 mov r3, #5
f8cc: e58d304c str r3, [sp, #76] ; 0x4c
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
f8d0: e59d0008 ldr r0, [sp, #8]
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;
f8d4: e3a03002 mov r3, #2
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
f8d8: e28d100c add r1, sp, #12
f8dc: e58de058 str lr, [sp, #88] ; 0x58
f8e0: e58dc068 str ip, [sp, #104] ; 0x68
f8e4: e58d2078 str r2, [sp, #120] ; 0x78
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;
f8e8: e58d300c str r3, [sp, #12]
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
f8ec: eb002a23 bl 1a180 <rtems_rfs_buffer_open>
if (rc > 0)
f8f0: e2504000 subs r4, r0, #0
f8f4: ca0002f4 bgt 104cc <rtems_rfs_format+0xc64>
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
f8f8: e59d301c ldr r3, [sp, #28]
f8fc: e5935020 ldr r5, [r3, #32]
f900: e3550000 cmp r5, #0
f904: 0a0002fe beq 10504 <rtems_rfs_format+0xc9c>
static bool
rtems_rfs_check_config (rtems_rfs_file_system* fs,
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
f908: e59a4000 ldr r4, [sl]
if (!fs->block_size)
f90c: e3540000 cmp r4, #0
static bool
rtems_rfs_check_config (rtems_rfs_file_system* fs,
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
f910: e58d4014 str r4, [sp, #20]
if (!fs->block_size)
f914: 0a0000c5 beq fc30 <rtems_rfs_format+0x3c8>
if (fs->block_size > (4 * 1024))
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
f918: e1a00004 mov r0, r4
f91c: e1a01005 mov r1, r5
f920: eb0075b4 bl 2cff8 <__umodsi3>
f924: e3500000 cmp r0, #0
f928: 1a0000e2 bne fcb8 <rtems_rfs_format+0x450>
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
f92c: e59a3004 ldr r3, [sl, #4]
if (!fs->group_blocks)
f930: e3530000 cmp r3, #0
{
/*
* 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);
f934: 01a04184 lsleq r4, r4, #3
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
f938: e58d3034 str r3, [sp, #52] ; 0x34
{
/*
* 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);
f93c: 058d4034 streq r4, [sp, #52] ; 0x34
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
if (!fs->group_blocks)
f940: 1a000048 bne fa68 <rtems_rfs_format+0x200>
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
f944: e28d000c add r0, sp, #12
f948: eb0033c5 bl 1c864 <rtems_rfs_fs_media_size>
f94c: e59d4014 ldr r4, [sp, #20]
f950: e3a03000 mov r3, #0
f954: e1a02004 mov r2, r4
f958: eb007a9b bl 2e3cc <__udivdi3>
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
f95c: e3500000 cmp r0, #0
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
f960: e1a05000 mov r5, r0
f964: e58d0010 str r0, [sp, #16]
* 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));
f968: e1a06184 lsl r6, r4, #3
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
f96c: 03a01001 moveq r1, #1
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
f970: 0a000003 beq f984 <rtems_rfs_format+0x11c>
return 1;
return ((dividend - 1) / divisor) + 1;
f974: e1a01006 mov r1, r6
f978: e2450001 sub r0, r5, #1
f97c: ebffc849 bl 1aa8 <__aeabi_uidiv>
f980: e2801001 add r1, r0, #1
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
f984: e59a0008 ldr r0, [sl, #8]
if (!fs->group_inodes)
f988: e3500000 cmp r0, #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),
f98c: e58d1030 str r1, [sp, #48] ; 0x30
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
if (!fs->group_inodes)
f990: 0a00011e beq fe10 <rtems_rfs_format+0x5a8>
f994: e59f3c44 ldr r3, [pc, #3140] ; 105e0 <rtems_rfs_format+0xd78><== NOT EXECUTED
f998: e1a051a4 lsr r5, r4, #3 <== NOT EXECUTED
f99c: e0852593 umull r2, r5, r3, r5 <== NOT EXECUTED
}
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
f9a0: e58d503c str r5, [sp, #60] ; 0x3c <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
f9a4: e2400001 sub r0, r0, #1
f9a8: e1a01005 mov r1, r5
f9ac: ebffc83d bl 1aa8 <__aeabi_uidiv>
f9b0: e2800001 add r0, r0, #1
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
fs->inodes_per_block) * fs->inodes_per_block;
f9b4: e0050590 mul r5, r0, r5
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;
f9b8: e59a3010 ldr r3, [sl, #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);
f9bc: e1560005 cmp r6, r5
f9c0: 958d6038 strls r6, [sp, #56] ; 0x38
f9c4: 858d5038 strhi r5, [sp, #56] ; 0x38
fs->max_name_length = config->max_name_length;
if (!fs->max_name_length)
f9c8: 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;
f9cc: e58d3028 str r3, [sp, #40] ; 0x28
if (!fs->max_name_length)
{
fs->max_name_length = 512;
f9d0: 03a03c02 moveq r3, #512 ; 0x200
f9d4: 058d3028 streq r3, [sp, #40] ; 0x28
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
f9d8: e5da3015 ldrb r3, [sl, #21]
f9dc: e3530000 cmp r3, #0
f9e0: 1a0000ba bne fcd0 <rtems_rfs_format+0x468>
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
f9e4: e1a01004 mov r1, r4
f9e8: e28d000c add r0, sp, #12
f9ec: eb002a8b bl 1a420 <rtems_rfs_buffer_setblksize>
if (rc > 0)
f9f0: e2504000 subs r4, r0, #0
f9f4: ca00022a bgt 102a4 <rtems_rfs_format+0xa3c>
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
f9f8: e3a08000 mov r8, #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);
f9fc: e28d000c add r0, sp, #12
fa00: e28d10d0 add r1, sp, #208 ; 0xd0
fa04: e1a02008 mov r2, r8
fa08: e1a03008 mov r3, r8
fa0c: e5cd80d0 strb r8, [sp, #208] ; 0xd0
handle->bnum = 0;
fa10: e58d80d4 str r8, [sp, #212] ; 0xd4
handle->buffer = NULL;
fa14: e58d80d8 str r8, [sp, #216] ; 0xd8
fa18: eb002931 bl 19ee4 <rtems_rfs_buffer_handle_request>
if (rc > 0)
fa1c: e2504000 subs r4, r0, #0
fa20: da000016 ble fa80 <rtems_rfs_format+0x218>
*/
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);
fa24: e28d10d0 add r1, sp, #208 ; 0xd0 <== NOT EXECUTED
fa28: e28d000c add r0, sp, #12 <== NOT EXECUTED
fa2c: eb0028b3 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
fa30: e1a00004 mov r0, r4 <== NOT EXECUTED
handle->dirty = false;
fa34: e5cd80d0 strb r8, [sp, #208] ; 0xd0 <== NOT EXECUTED
handle->bnum = 0;
fa38: e58d80d4 str r8, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->buffer = NULL;
fa3c: e58d80d8 str r8, [sp, #216] ; 0xd8 <== NOT EXECUTED
fa40: eb004745 bl 2175c <strerror> <== NOT EXECUTED
fa44: e1a01004 mov r1, r4 <== NOT EXECUTED
fa48: e1a02000 mov r2, r0 <== NOT EXECUTED
fa4c: e59f0b90 ldr r0, [pc, #2960] ; 105e4 <rtems_rfs_format+0xd7c><== NOT EXECUTED
fa50: eb004293 bl 204a4 <printf> <== NOT EXECUTED
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
fa54: e59f0b8c ldr r0, [pc, #2956] ; 105e8 <rtems_rfs_format+0xd80><== NOT EXECUTED
fa58: eb004329 bl 20704 <puts> <== NOT EXECUTED
return -1;
fa5c: e3e00000 mvn r0, #0 <== NOT EXECUTED
rc, strerror (rc));
return -1;
}
return 0;
}
fa60: e28dd0e4 add sp, sp, #228 ; 0xe4
fa64: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* block.
*/
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
fa68: e1530184 cmp r3, r4, lsl #3 <== NOT EXECUTED
fa6c: 9affffb4 bls f944 <rtems_rfs_format+0xdc> <== NOT EXECUTED
{
printf ("group block count is higher than bits in block\n");
fa70: e59f0b74 ldr r0, [pc, #2932] ; 105ec <rtems_rfs_format+0xd84><== NOT EXECUTED
fa74: eb004322 bl 20704 <puts> <== NOT EXECUTED
/*
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
fa78: e3e00000 mvn r0, #0 <== NOT EXECUTED
fa7c: eafffff7 b fa60 <rtems_rfs_format+0x1f8> <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
fa80: e59d30d8 ldr r3, [sp, #216] ; 0xd8
fa84: e593401c ldr r4, [r3, #28]
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
fa88: e3a010ff mov r1, #255 ; 0xff
fa8c: e59d2014 ldr r2, [sp, #20]
fa90: e1a00004 mov r0, r4
fa94: eb004211 bl 202e0 <memset>
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
fa98: e3a03028 mov r3, #40 ; 0x28
fa9c: e5c43000 strb r3, [r4]
faa0: e3a03009 mov r3, #9
faa4: e5c43001 strb r3, [r4, #1]
faa8: e3a05001 mov r5, #1
faac: e3a03020 mov r3, #32
fab0: e5c43002 strb r3, [r4, #2]
fab4: e5c45003 strb r5, [r4, #3]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
fab8: e5c48004 strb r8, [r4, #4]
fabc: e5c48005 strb r8, [r4, #5]
fac0: e5c48006 strb r8, [r4, #6]
fac4: e5c48007 strb r8, [r4, #7]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
fac8: e59d3010 ldr r3, [sp, #16]
facc: e1a00c23 lsr r0, r3, #24
fad0: e1a01823 lsr r1, r3, #16
fad4: e1a02423 lsr r2, r3, #8
fad8: e5c4000c strb r0, [r4, #12]
fadc: e5c4100d strb r1, [r4, #13]
fae0: e5c4200e strb r2, [r4, #14]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
fae4: e5dd2017 ldrb r2, [sp, #23]
fae8: e5c42008 strb r2, [r4, #8]
faec: e1dd21b6 ldrh r2, [sp, #22]
faf0: e5c42009 strb r2, [r4, #9]
faf4: e59d2014 ldr r2, [sp, #20]
faf8: e1a02422 lsr r2, r2, #8
fafc: e5c4200a strb r2, [r4, #10]
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
fb00: e5c4300f strb r3, [r4, #15]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
fb04: e59d3014 ldr r3, [sp, #20]
fb08: e5c4300b strb r3, [r4, #11]
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
fb0c: e5dd3027 ldrb r3, [sp, #39] ; 0x27
fb10: e5c43010 strb r3, [r4, #16]
fb14: e1dd32b6 ldrh r3, [sp, #38] ; 0x26
fb18: e5c43011 strb r3, [r4, #17]
fb1c: e59d3024 ldr r3, [sp, #36] ; 0x24
fb20: e1a03423 lsr r3, r3, #8
fb24: e5c43012 strb r3, [r4, #18]
fb28: e59d3024 ldr r3, [sp, #36] ; 0x24
fb2c: e5c43013 strb r3, [r4, #19]
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
fb30: e5dd302b ldrb r3, [sp, #43] ; 0x2b
fb34: e5c43014 strb r3, [r4, #20]
fb38: e1dd32ba ldrh r3, [sp, #42] ; 0x2a
fb3c: e5c43015 strb r3, [r4, #21]
fb40: e59d3028 ldr r3, [sp, #40] ; 0x28
fb44: e1a03423 lsr r3, r3, #8
fb48: e5c43016 strb r3, [r4, #22]
fb4c: e59d3028 ldr r3, [sp, #40] ; 0x28
fb50: e5c43017 strb r3, [r4, #23]
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
fb54: e5dd3033 ldrb r3, [sp, #51] ; 0x33
fb58: e5c43018 strb r3, [r4, #24]
fb5c: e1dd33b2 ldrh r3, [sp, #50] ; 0x32
fb60: e5c43019 strb r3, [r4, #25]
fb64: e59d3030 ldr r3, [sp, #48] ; 0x30
fb68: e1a03423 lsr r3, r3, #8
fb6c: e5c4301a strb r3, [r4, #26]
fb70: e59d3030 ldr r3, [sp, #48] ; 0x30
fb74: e5c4301b strb r3, [r4, #27]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
fb78: e5dd3037 ldrb r3, [sp, #55] ; 0x37
fb7c: e5c4301c strb r3, [r4, #28]
fb80: e1dd33b6 ldrh r3, [sp, #54] ; 0x36
fb84: e5c4301d strb r3, [r4, #29]
fb88: e59d3034 ldr r3, [sp, #52] ; 0x34
fb8c: e1a03423 lsr r3, r3, #8
fb90: e5c4301e strb r3, [r4, #30]
fb94: e59d3034 ldr r3, [sp, #52] ; 0x34
fb98: e5c4301f strb r3, [r4, #31]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
fb9c: e5dd303b ldrb r3, [sp, #59] ; 0x3b
fba0: e5c43020 strb r3, [r4, #32]
fba4: e1dd33ba ldrh r3, [sp, #58] ; 0x3a
fba8: e5c43021 strb r3, [r4, #33] ; 0x21
fbac: e59d3038 ldr r3, [sp, #56] ; 0x38
fbb0: e1a03423 lsr r3, r3, #8
fbb4: e5c43022 strb r3, [r4, #34] ; 0x22
fbb8: e59d3038 ldr r3, [sp, #56] ; 0x38
fbbc: e5c43023 strb r3, [r4, #35] ; 0x23
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
fbc0: e3a03038 mov r3, #56 ; 0x38
fbc4: e5c48024 strb r8, [r4, #36] ; 0x24
fbc8: e5c48025 strb r8, [r4, #37] ; 0x25
fbcc: e5c48026 strb r8, [r4, #38] ; 0x26
fbd0: e5c43027 strb r3, [r4, #39] ; 0x27
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
fbd4: e28d000c add r0, sp, #12
fbd8: e28d10d0 add r1, sp, #208 ; 0xd0
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);
fbdc: e5cd50d0 strb r5, [sp, #208] ; 0xd0
rc = rtems_rfs_buffer_handle_release (fs, &handle);
fbe0: eb002846 bl 19d00 <rtems_rfs_buffer_handle_release>
if (rc > 0)
fbe4: e2504000 subs r4, r0, #0
fbe8: da0000bb ble fedc <rtems_rfs_format+0x674>
*/
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);
fbec: e28d10d0 add r1, sp, #208 ; 0xd0 <== NOT EXECUTED
fbf0: e28d000c add r0, sp, #12 <== NOT EXECUTED
fbf4: eb002841 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
fbf8: e1a00004 mov r0, r4 <== NOT EXECUTED
handle->dirty = false;
fbfc: e5cd80d0 strb r8, [sp, #208] ; 0xd0 <== NOT EXECUTED
handle->bnum = 0;
fc00: e58d80d4 str r8, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->buffer = NULL;
fc04: e58d80d8 str r8, [sp, #216] ; 0xd8 <== NOT EXECUTED
fc08: eb0046d3 bl 2175c <strerror> <== NOT EXECUTED
fc0c: e1a01004 mov r1, r4 <== NOT EXECUTED
fc10: e1a02000 mov r2, r0 <== NOT EXECUTED
fc14: e59f09d4 ldr r0, [pc, #2516] ; 105f0 <rtems_rfs_format+0xd88><== NOT EXECUTED
fc18: eb004221 bl 204a4 <printf> <== NOT EXECUTED
fc1c: eaffff8c b fa54 <rtems_rfs_format+0x1ec> <== NOT EXECUTED
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
printf ("rtems-rfs: format: %s\n", name);
fc20: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED
fc24: e59f09c8 ldr r0, [pc, #2504] ; 105f4 <rtems_rfs_format+0xd8c><== NOT EXECUTED
fc28: eb00421d bl 204a4 <printf> <== NOT EXECUTED
fc2c: eaffff14 b f884 <rtems_rfs_format+0x1c> <== NOT EXECUTED
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
if (!fs->block_size)
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
fc30: e28d000c add r0, sp, #12
fc34: eb00330a bl 1c864 <rtems_rfs_fs_media_size>
if (total_size >= GIGS (1))
fc38: e59f29b8 ldr r2, [pc, #2488] ; 105f8 <rtems_rfs_format+0xd90>
fc3c: e3a03000 mov r3, #0
fc40: e1530001 cmp r3, r1
fc44: 01520000 cmpeq r2, r0
fc48: 259d4014 ldrcs r4, [sp, #20]
fc4c: 2a00000e bcs fc8c <rtems_rfs_format+0x424>
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
fc50: e3a02601 mov r2, #1048576 ; 0x100000 <== NOT EXECUTED
fc54: e0922000 adds r2, r2, r0 <== NOT EXECUTED
fc58: e3a03000 mov r3, #0 <== NOT EXECUTED
fc5c: e0a33001 adc r3, r3, r1 <== NOT EXECUTED
fc60: e1a01a22 lsr r1, r2, #20 <== NOT EXECUTED
fc64: e1811603 orr r1, r1, r3, lsl #12 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
fc68: 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--)
fc6c: e3a0301f mov r3, #31 <== NOT EXECUTED
fc70: ea000001 b fc7c <rtems_rfs_format+0x414> <== NOT EXECUTED
fc74: e2533001 subs r3, r3, #1 <== NOT EXECUTED
fc78: 0a0001d3 beq 103cc <rtems_rfs_format+0xb64> <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
fc7c: e1a04312 lsl r4, r2, r3 <== NOT EXECUTED
fc80: e1140001 tst r4, r1 <== NOT EXECUTED
fc84: 0afffffa beq fc74 <rtems_rfs_format+0x40c> <== NOT EXECUTED
break;
fs->block_size = 1 << b;
fc88: e58d4014 str r4, [sp, #20] <== NOT EXECUTED
}
if (fs->block_size < 512)
fc8c: e3540c02 cmp r4, #512 ; 0x200
fc90: 2a000070 bcs fe58 <rtems_rfs_format+0x5f0>
fs->block_size = 512;
fc94: e3a04c02 mov r4, #512 ; 0x200
fc98: e58d4014 str r4, [sp, #20]
fc9c: e59d301c ldr r3, [sp, #28]
fca0: e5935020 ldr r5, [r3, #32]
if (fs->block_size > (4 * 1024))
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
fca4: e1a00004 mov r0, r4
fca8: e1a01005 mov r1, r5
fcac: eb0074d1 bl 2cff8 <__umodsi3>
fcb0: e3500000 cmp r0, #0
fcb4: 0affff1c beq f92c <rtems_rfs_format+0xc4>
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
fcb8: e59f093c ldr r0, [pc, #2364] ; 105fc <rtems_rfs_format+0xd94><== NOT EXECUTED
fcbc: e1a01004 mov r1, r4 <== NOT EXECUTED
fcc0: e1a02005 mov r2, r5 <== NOT EXECUTED
fcc4: eb0041f6 bl 204a4 <printf> <== NOT EXECUTED
/*
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
fcc8: e3e00000 mvn r0, #0 <== NOT EXECUTED
fccc: eaffff63 b fa60 <rtems_rfs_format+0x1f8> <== NOT EXECUTED
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
fcd0: e28d000c add r0, sp, #12 <== NOT EXECUTED
fcd4: eb0032e2 bl 1c864 <rtems_rfs_fs_media_size> <== NOT EXECUTED
fcd8: e1a02001 mov r2, r1 <== NOT EXECUTED
fcdc: e1a01000 mov r1, r0 <== NOT EXECUTED
fce0: e59f0918 ldr r0, [pc, #2328] ; 10600 <rtems_rfs_format+0xd98><== NOT EXECUTED
fce4: eb0041ee bl 204a4 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
fce8: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED
fcec: e59f0910 ldr r0, [pc, #2320] ; 10604 <rtems_rfs_format+0xd9c><== NOT EXECUTED
fcf0: e593101c ldr r1, [r3, #28] <== NOT EXECUTED
fcf4: eb0041ea bl 204a4 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
fcf8: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED
fcfc: e59f0904 ldr r0, [pc, #2308] ; 10608 <rtems_rfs_format+0xda0><== NOT EXECUTED
fd00: e5931020 ldr r1, [r3, #32] <== NOT EXECUTED
fd04: eb0041e6 bl 204a4 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
fd08: e28d000c add r0, sp, #12 <== NOT EXECUTED
fd0c: eb0032d0 bl 1c854 <rtems_rfs_fs_size> <== NOT EXECUTED
fd10: e1a02001 mov r2, r1 <== NOT EXECUTED
fd14: e1a01000 mov r1, r0 <== NOT EXECUTED
fd18: e59f08ec ldr r0, [pc, #2284] ; 1060c <rtems_rfs_format+0xda4><== NOT EXECUTED
fd1c: eb0041e0 bl 204a4 <printf> <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
fd20: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
fd24: e59f08e4 ldr r0, [pc, #2276] ; 10610 <rtems_rfs_format+0xda8><== NOT EXECUTED
fd28: eb0041dd bl 204a4 <printf> <== NOT EXECUTED
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
fd2c: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED
fd30: e59f08dc ldr r0, [pc, #2268] ; 10614 <rtems_rfs_format+0xdac><== NOT EXECUTED
fd34: eb0041da bl 204a4 <printf> <== NOT EXECUTED
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
fd38: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED
fd3c: e59f08d4 ldr r0, [pc, #2260] ; 10618 <rtems_rfs_format+0xdb0><== NOT EXECUTED
fd40: e1a01181 lsl r1, r1, #3 <== NOT EXECUTED
fd44: eb0041d6 bl 204a4 <printf> <== NOT EXECUTED
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
fd48: e59f08cc ldr r0, [pc, #2252] ; 1061c <rtems_rfs_format+0xdb4><== NOT EXECUTED
fd4c: e3a01038 mov r1, #56 ; 0x38 <== NOT EXECUTED
fd50: eb0041d3 bl 204a4 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
fs.group_inodes * fs.group_count,
fd54: e59d3038 ldr r3, [sp, #56] ; 0x38 <== 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",
fd58: e59d4030 ldr r4, [sp, #48] ; 0x30 <== NOT EXECUTED
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
fd5c: e0638183 rsb r8, r3, r3, lsl #3 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
fd60: e1b08188 lsls r8, r8, #3 <== 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",
fd64: e0040493 mul r4, r3, r4 <== NOT EXECUTED
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
fd68: e59d7014 ldr r7, [sp, #20] <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
fd6c: 03a00e7d moveq r0, #2000 ; 0x7d0 <== NOT EXECUTED
fd70: 1a000046 bne fe90 <rtems_rfs_format+0x628> <== 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))
fd74: e59d5010 ldr r5, [sp, #16] <== 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));
fd78: e1a06187 lsl r6, r7, #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))
fd7c: e2455001 sub r5, r5, #1 <== NOT EXECUTED
bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
return ((blocks + 1) * 100 * 10) / bits_per_block;
fd80: e1550006 cmp r5, r6 <== NOT EXECUTED
fd84: 31a01005 movcc r1, r5 <== NOT EXECUTED
fd88: 21a01006 movcs r1, r6 <== NOT EXECUTED
fd8c: eb007447 bl 2ceb0 <__aeabi_idiv> <== 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",
fd90: e59f9888 ldr r9, [pc, #2184] ; 10620 <rtems_rfs_format+0xdb8><== NOT EXECUTED
fd94: e0c93990 smull r3, r9, r0, r9 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
fd98: e3580000 cmp r8, #0 <== 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",
fd9c: e1a00fc0 asr r0, r0, #31 <== NOT EXECUTED
fda0: e0609149 rsb r9, r0, r9, asr #2 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
fda4: 03a00e7d moveq r0, #2000 ; 0x7d0 <== NOT EXECUTED
fda8: 1a000030 bne fe70 <rtems_rfs_format+0x608> <== NOT EXECUTED
/*
* 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))
bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
return ((blocks + 1) * 100 * 10) / bits_per_block;
fdac: e1560005 cmp r6, r5 <== NOT EXECUTED
fdb0: 31a01006 movcc r1, r6 <== NOT EXECUTED
fdb4: 21a01005 movcs r1, r5 <== NOT EXECUTED
fdb8: eb00743c bl 2ceb0 <__aeabi_idiv> <== 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",
fdbc: e59f285c ldr r2, [pc, #2140] ; 10620 <rtems_rfs_format+0xdb8><== NOT EXECUTED
fdc0: e0c23290 smull r3, r2, r0, r2 <== NOT EXECUTED
fdc4: e1a03fc0 asr r3, r0, #31 <== NOT EXECUTED
fdc8: e0633142 rsb r3, r3, r2, asr #2 <== NOT EXECUTED
fdcc: e0833103 add r3, r3, r3, lsl #2 <== NOT EXECUTED
fdd0: e0403083 sub r3, r0, r3, lsl #1 <== NOT EXECUTED
fdd4: e1a02009 mov r2, r9 <== NOT EXECUTED
fdd8: e1a01004 mov r1, r4 <== NOT EXECUTED
fddc: e59f0840 ldr r0, [pc, #2112] ; 10624 <rtems_rfs_format+0xdbc><== NOT EXECUTED
fde0: eb0041af bl 204a4 <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);
fde4: e59d1030 ldr r1, [sp, #48] ; 0x30 <== NOT EXECUTED
fde8: e59f0838 ldr r0, [pc, #2104] ; 10628 <rtems_rfs_format+0xdc0><== NOT EXECUTED
fdec: eb0041ac bl 204a4 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
fdf0: e59d1034 ldr r1, [sp, #52] ; 0x34 <== NOT EXECUTED
fdf4: e59f0830 ldr r0, [pc, #2096] ; 1062c <rtems_rfs_format+0xdc4><== NOT EXECUTED
fdf8: eb0041a9 bl 204a4 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
fdfc: e59f082c ldr r0, [pc, #2092] ; 10630 <rtems_rfs_format+0xdc8><== NOT EXECUTED
fe00: e59d1038 ldr r1, [sp, #56] ; 0x38 <== NOT EXECUTED
fe04: eb0041a6 bl 204a4 <printf> <== NOT EXECUTED
fe08: e59d4014 ldr r4, [sp, #20] <== NOT EXECUTED
fe0c: eafffef4 b f9e4 <rtems_rfs_format+0x17c> <== NOT EXECUTED
int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
/*
* The number of inodes per group is set as a percentage.
*/
if (config->inode_overhead)
fe10: e59a200c ldr r2, [sl, #12]
fe14: e3520000 cmp r2, #0
fe18: 03a02001 moveq r2, #1
static int
rtems_rfs_inodes_from_percent (rtems_rfs_file_system* fs,
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
fe1c: e2455001 sub r5, r5, #1
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
fe20: e0020295 mul r2, r5, r2
fe24: e59f3808 ldr r3, [pc, #2056] ; 10634 <rtems_rfs_format+0xdcc>
fe28: e0830392 umull r0, r3, r2, r3
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
fe2c: e1b032a3 lsrs r3, r3, #5
fe30: 03a00001 moveq r0, #1
fe34: 1a00001d bne feb0 <rtems_rfs_format+0x648>
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
fe38: e59f37a0 ldr r3, [pc, #1952] ; 105e0 <rtems_rfs_format+0xd78>
fe3c: e1a051a4 lsr r5, r4, #3
fe40: e0852593 umull r2, r5, r3, r5
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
fe44: e0100095 muls r0, r5, r0
}
/*
* 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;
fe48: e58d503c str r5, [sp, #60] ; 0x3c
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
fe4c: 03a00001 moveq r0, #1
fe50: 0afffed7 beq f9b4 <rtems_rfs_format+0x14c>
fe54: eafffed2 b f9a4 <rtems_rfs_format+0x13c>
}
if (fs->block_size < 512)
fs->block_size = 512;
if (fs->block_size > (4 * 1024))
fe58: e3540a01 cmp r4, #4096 ; 0x1000 <== NOT EXECUTED
fs->block_size = (4 * 1024);
fe5c: 83a04a01 movhi r4, #4096 ; 0x1000 <== NOT EXECUTED
fe60: 858d4014 strhi r4, [sp, #20] <== NOT EXECUTED
fe64: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED
fe68: e5935020 ldr r5, [r3, #32] <== NOT EXECUTED
fe6c: eafffea9 b f918 <rtems_rfs_format+0xb0> <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
fe70: e2480001 sub r0, r8, #1 <== NOT EXECUTED
fe74: e1a01007 mov r1, r7 <== NOT EXECUTED
fe78: ebffc70a bl 1aa8 <__aeabi_uidiv> <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
fe7c: e2800002 add r0, r0, #2 <== NOT EXECUTED
fe80: e0603280 rsb r3, r0, r0, lsl #5 <== NOT EXECUTED
fe84: e0800103 add r0, r0, r3, lsl #2 <== NOT EXECUTED
fe88: e1a00180 lsl r0, r0, #3 <== NOT EXECUTED
fe8c: eaffffc6 b fdac <rtems_rfs_format+0x544> <== NOT EXECUTED
return 1;
return ((dividend - 1) / divisor) + 1;
fe90: e2480001 sub r0, r8, #1 <== NOT EXECUTED
fe94: e1a01007 mov r1, r7 <== NOT EXECUTED
fe98: ebffc702 bl 1aa8 <__aeabi_uidiv> <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
fe9c: e2800002 add r0, r0, #2 <== NOT EXECUTED
fea0: e0603280 rsb r3, r0, r0, lsl #5 <== NOT EXECUTED
fea4: e0800103 add r0, r0, r3, lsl #2 <== NOT EXECUTED
fea8: e1a00180 lsl r0, r0, #3 <== NOT EXECUTED
feac: eaffffb0 b fd74 <rtems_rfs_format+0x50c> <== NOT EXECUTED
return 1;
return ((dividend - 1) / divisor) + 1;
feb0: e2430001 sub r0, r3, #1
feb4: ebffc6fb bl 1aa8 <__aeabi_uidiv>
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
feb8: e59f3720 ldr r3, [pc, #1824] ; 105e0 <rtems_rfs_format+0xd78>
febc: e1a051a4 lsr r5, r4, #3
fec0: e0852593 umull r2, r5, r3, r5
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
fec4: e2800001 add r0, r0, #1
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
fec8: e0100095 muls r0, r5, r0
}
/*
* 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;
fecc: e58d503c str r5, [sp, #60] ; 0x3c
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
fed0: 03a00001 moveq r0, #1
fed4: 0afffeb6 beq f9b4 <rtems_rfs_format+0x14c>
fed8: eafffeb1 b f9a4 <rtems_rfs_format+0x13c>
*/
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);
fedc: e28d000c add r0, sp, #12
fee0: e28d10d0 add r1, sp, #208 ; 0xd0
fee4: eb002785 bl 19d00 <rtems_rfs_buffer_handle_release>
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
fee8: e59d3030 ldr r3, [sp, #48] ; 0x30
feec: e3530000 cmp r3, #0
handle->dirty = false;
fef0: e5cd80d0 strb r8, [sp, #208] ; 0xd0
handle->bnum = 0;
fef4: e58d80d4 str r8, [sp, #212] ; 0xd4
handle->buffer = NULL;
fef8: e58d80d8 str r8, [sp, #216] ; 0xd8
fefc: da000088 ble 10124 <rtems_rfs_format+0x8bc>
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
ff00: e59d3010 ldr r3, [sp, #16]
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
ff04: e5da0014 ldrb r0, [sl, #20]
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
ff08: e3530000 cmp r3, #0
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
ff0c: e58d0004 str r0, [sp, #4]
ff10: e5da6015 ldrb r6, [sl, #21]
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
ff14: e59d4034 ldr r4, [sp, #52] ; 0x34
if (group_base > rtems_rfs_fs_blocks (fs))
ff18: 11a07008 movne r7, r8
ff1c: 0a000197 beq 10580 <rtems_rfs_format+0xd18>
/*
* 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))
ff20: e0842005 add r2, r4, r5
ff24: e1530002 cmp r3, r2
group_size = rtems_rfs_fs_blocks (fs) - group_base;
ff28: 30654003 rsbcc r4, r5, r3
if (verbose)
ff2c: e3560000 cmp r6, #0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ff30: 05cd60d0 strbeq r6, [sp, #208] ; 0xd0
handle->bnum = 0;
ff34: 058d60d4 streq r6, [sp, #212] ; 0xd4
handle->buffer = NULL;
ff38: 058d60d8 streq r6, [sp, #216] ; 0xd8
ff3c: 1a000032 bne 1000c <rtems_rfs_format+0x7a4>
printf (", blocks");
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
ff40: e28d00b8 add r0, sp, #184 ; 0xb8
ff44: e28d100c add r1, sp, #12
ff48: e28d20d0 add r2, sp, #208 ; 0xd0
ff4c: e1a03004 mov r3, r4
ff50: e58d5000 str r5, [sp]
ff54: eb0022f4 bl 18b2c <rtems_rfs_bitmap_open>
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
ff58: e2509000 subs r9, r0, #0
ff5c: da00000f ble ffa0 <rtems_rfs_format+0x738>
*/
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);
ff60: e28d10d0 add r1, sp, #208 ; 0xd0 <== NOT EXECUTED
ff64: e28d000c add r0, sp, #12 <== NOT EXECUTED
ff68: eb002764 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
ff6c: e3a03000 mov r3, #0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
ff70: e1a00009 mov r0, r9 <== NOT EXECUTED
ff74: e5cd30d0 strb r3, [sp, #208] ; 0xd0 <== NOT EXECUTED
handle->bnum = 0;
ff78: e58d30d4 str r3, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->buffer = NULL;
ff7c: e58d30d8 str r3, [sp, #216] ; 0xd8 <== NOT EXECUTED
ff80: eb0045f5 bl 2175c <strerror> <== NOT EXECUTED
ff84: e1a01007 mov r1, r7 <== NOT EXECUTED
ff88: e1a03000 mov r3, r0 <== NOT EXECUTED
ff8c: e1a02009 mov r2, r9 <== NOT EXECUTED
ff90: e59f06a0 ldr r0, [pc, #1696] ; 10638 <rtems_rfs_format+0xdd0><== NOT EXECUTED
ff94: eb004142 bl 204a4 <printf> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
ff98: e3e00000 mvn r0, #0 <== NOT EXECUTED
ff9c: eafffeaf b fa60 <rtems_rfs_format+0x1f8> <== 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));
ffa0: e59d30d8 ldr r3, [sp, #216] ; 0xd8
ffa4: e3a010ff mov r1, #255 ; 0xff
ffa8: e59d2014 ldr r2, [sp, #20]
ffac: e593001c ldr r0, [r3, #28]
ffb0: eb0040ca bl 202e0 <memset>
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
ffb4: e28d00b8 add r0, sp, #184 ; 0xb8
ffb8: eb002249 bl 188e4 <rtems_rfs_bitmap_map_clear_all>
if (rc > 0)
ffbc: e2509000 subs r9, r0, #0
ffc0: da00001e ble 10040 <rtems_rfs_format+0x7d8>
{
rtems_rfs_bitmap_close (&bitmap);
ffc4: e28d00b8 add r0, sp, #184 ; 0xb8 <== NOT EXECUTED
ffc8: eb0022eb bl 18b7c <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);
ffcc: e28d10d0 add r1, sp, #208 ; 0xd0 <== NOT EXECUTED
ffd0: e28d000c add r0, sp, #12 <== NOT EXECUTED
ffd4: eb002749 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
ffd8: e3a03000 mov r3, #0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
ffdc: e1a00009 mov r0, r9 <== NOT EXECUTED
ffe0: e5cd30d0 strb r3, [sp, #208] ; 0xd0 <== NOT EXECUTED
handle->bnum = 0;
ffe4: e58d30d4 str r3, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->buffer = NULL;
ffe8: e58d30d8 str r3, [sp, #216] ; 0xd8 <== NOT EXECUTED
ffec: eb0045da bl 2175c <strerror> <== NOT EXECUTED
fff0: e1a01007 mov r1, r7 <== NOT EXECUTED
fff4: e1a03000 mov r3, r0 <== NOT EXECUTED
fff8: e1a02009 mov r2, r9 <== NOT EXECUTED
fffc: e59f0638 ldr r0, [pc, #1592] ; 1063c <rtems_rfs_format+0xdd4><== NOT EXECUTED
10000: eb004127 bl 204a4 <printf> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
10004: e3e00000 mvn r0, #0 <== NOT EXECUTED 10008: eafffe94 b fa60 <rtems_rfs_format+0x1f8> <== NOT EXECUTED
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
1000c: e1a02005 mov r2, r5 <== NOT EXECUTED 10010: e1a03004 mov r3, r4 <== NOT EXECUTED 10014: e1a01007 mov r1, r7 <== NOT EXECUTED 10018: e59f0620 ldr r0, [pc, #1568] ; 10640 <rtems_rfs_format+0xdd8><== NOT EXECUTED 1001c: eb004120 bl 204a4 <printf> <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
10020: e3a03000 mov r3, #0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
10024: e3a02000 mov r2, #0 <== NOT EXECUTED
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
10028: e59f0614 ldr r0, [pc, #1556] ; 10644 <rtems_rfs_format+0xddc><== NOT EXECUTED 1002c: e5cd20d0 strb r2, [sp, #208] ; 0xd0 <== NOT EXECUTED
handle->bnum = 0;
10030: e58d30d4 str r3, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->buffer = NULL;
10034: e58d30d8 str r3, [sp, #216] ; 0xd8 <== NOT EXECUTED 10038: eb004119 bl 204a4 <printf> <== NOT EXECUTED 1003c: eaffffbf b ff40 <rtems_rfs_format+0x6d8> <== NOT EXECUTED
}
/*
* Forced allocation of the block bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
10040: e3a01000 mov r1, #0 10044: e28d00b8 add r0, sp, #184 ; 0xb8 10048: eb00219f bl 186cc <rtems_rfs_bitmap_map_set>
/*
* Forced allocation of the inode bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
1004c: e3a01001 mov r1, #1 10050: e28d00b8 add r0, sp, #184 ; 0xb8 10054: eb00219c bl 186cc <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);
10058: e59d0038 ldr r0, [sp, #56] ; 0x38
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
1005c: e3500000 cmp r0, #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);
10060: e59d103c ldr r1, [sp, #60] ; 0x3c
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
10064: 1a000028 bne 1010c <rtems_rfs_format+0x8a4>
return 1;
10068: e3a09001 mov r9, #1 <== NOT EXECUTED
1006c: e3a0b000 mov fp, #0
/*
* 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);
10070: e28b1002 add r1, fp, #2 10074: e28d00b8 add r0, sp, #184 ; 0xb8
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++)
10078: e28bb001 add fp, fp, #1
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
1007c: eb002192 bl 186cc <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++)
10080: e159000b cmp r9, fp
10084: cafffff9 bgt 10070 <rtems_rfs_format+0x808>
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
/*
* Close the block bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
10088: e28d00b8 add r0, sp, #184 ; 0xb8 1008c: eb0022ba bl 18b7c <rtems_rfs_bitmap_close>
if (rc > 0)
10090: e250b000 subs fp, r0, #0
10094: ca000042 bgt 101a4 <rtems_rfs_format+0x93c>
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);
10098: e3a00001 mov r0, #1
if (verbose)
1009c: e3560000 cmp r6, #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);
100a0: e5cd00d0 strb r0, [sp, #208] ; 0xd0
if (verbose)
100a4: 1a000069 bne 10250 <rtems_rfs_format+0x9e8>
printf (", inodes");
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
100a8: e1a03004 mov r3, r4 100ac: e2888002 add r8, r8, #2 100b0: e28d00b8 add r0, sp, #184 ; 0xb8 100b4: e28d100c add r1, sp, #12 100b8: e28d20d0 add r2, sp, #208 ; 0xd0 100bc: e58d8000 str r8, [sp] 100c0: eb002299 bl 18b2c <rtems_rfs_bitmap_open>
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
100c4: e2504000 subs r4, r0, #0
100c8: da000045 ble 101e4 <rtems_rfs_format+0x97c>
*/
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);
100cc: e28d10d0 add r1, sp, #208 ; 0xd0 <== NOT EXECUTED 100d0: e28d000c add r0, sp, #12 <== NOT EXECUTED 100d4: eb002709 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
100d8: e3a03000 mov r3, #0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
100dc: e1a00004 mov r0, r4 <== NOT EXECUTED 100e0: e5cd30d0 strb r3, [sp, #208] ; 0xd0 <== NOT EXECUTED
handle->bnum = 0;
100e4: e58d30d4 str r3, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->buffer = NULL;
100e8: e58d30d8 str r3, [sp, #216] ; 0xd8 <== NOT EXECUTED 100ec: eb00459a bl 2175c <strerror> <== NOT EXECUTED 100f0: e1a01007 mov r1, r7 <== NOT EXECUTED 100f4: e1a03000 mov r3, r0 <== NOT EXECUTED 100f8: e1a02004 mov r2, r4 <== NOT EXECUTED 100fc: e59f0544 ldr r0, [pc, #1348] ; 10648 <rtems_rfs_format+0xde0><== NOT EXECUTED 10100: eb0040e7 bl 204a4 <printf> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
10104: e3e00000 mvn r0, #0 <== NOT EXECUTED 10108: eafffe54 b fa60 <rtems_rfs_format+0x1f8> <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
1010c: e2400001 sub r0, r0, #1 10110: ebffc664 bl 1aa8 <__aeabi_uidiv> 10114: e2809001 add r9, r0, #1
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++)
10118: e3590000 cmp r9, #0
1011c: caffffd2 bgt 1006c <rtems_rfs_format+0x804>
10120: eaffffd8 b 10088 <rtems_rfs_format+0x820> <== NOT EXECUTED
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
if (config->verbose)
10124: e5da3015 ldrb r3, [sl, #21] 10128: e3530000 cmp r3, #0
1012c: 1a000059 bne 10298 <rtems_rfs_format+0xa30>
printf ("\n");
rc = rtems_rfs_buffer_close (&fs);
10130: e28d000c add r0, sp, #12 10134: eb0028f7 bl 1a518 <rtems_rfs_buffer_close>
if (rc > 0)
10138: e2504000 subs r4, r0, #0
1013c: ca0000e9 bgt 104e8 <rtems_rfs_format+0xc80>
int rc;
/*
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL,
10140: e3a01000 mov r1, #0 10144: e28dc0dc add ip, sp, #220 ; 0xdc 10148: e59d0008 ldr r0, [sp, #8] 1014c: e3a02006 mov r2, #6 10150: e1a03001 mov r3, r1 10154: e58dc000 str ip, [sp] 10158: eb0031c6 bl 1c878 <rtems_rfs_fs_open>
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
1015c: e3500000 cmp r0, #0
10160: ba000113 blt 105b4 <rtems_rfs_format+0xd4c>
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
10164: e59d00dc ldr r0, [sp, #220] ; 0xdc 10168: e3a01001 mov r1, #1 1016c: e28d20e0 add r2, sp, #224 ; 0xe0 10170: eb00031d bl 10dec <rtems_rfs_inode_alloc>
if (rc > 0)
10174: e2505000 subs r5, r0, #0
10178: ca000037 bgt 1025c <rtems_rfs_format+0x9f4>
rc, strerror (rc));
rtems_rfs_fs_close (fs);
return rc;
}
if (ino != RTEMS_RFS_ROOT_INO)
1017c: e59d40e0 ldr r4, [sp, #224] ; 0xe0 10180: e3540001 cmp r4, #1
10184: 0a00004d beq 102c0 <rtems_rfs_format+0xa58>
{
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
10188: e1a01004 mov r1, r4 <== NOT EXECUTED 1018c: e59f04b8 ldr r0, [pc, #1208] ; 1064c <rtems_rfs_format+0xde4><== NOT EXECUTED 10190: eb0040c3 bl 204a4 <printf> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
10194: e59d00dc ldr r0, [sp, #220] ; 0xdc <== NOT EXECUTED 10198: eb0033ae bl 1d058 <rtems_rfs_fs_close> <== NOT EXECUTED
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
rc, strerror (rc));
return -1;
}
return 0;
1019c: e3a00000 mov r0, #0 <== NOT EXECUTED 101a0: eafffe2e b fa60 <rtems_rfs_format+0x1f8> <== 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);
101a4: e28d10d0 add r1, sp, #208 ; 0xd0 <== NOT EXECUTED 101a8: e28d000c add r0, sp, #12 <== NOT EXECUTED 101ac: eb0026d3 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
101b0: e3a03000 mov r3, #0 <== NOT EXECUTED
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
101b4: e1a0000b mov r0, fp <== NOT EXECUTED 101b8: e5cd30d0 strb r3, [sp, #208] ; 0xd0 <== NOT EXECUTED
handle->bnum = 0;
101bc: e58d30d4 str r3, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->buffer = NULL;
101c0: e58d30d8 str r3, [sp, #216] ; 0xd8 <== NOT EXECUTED 101c4: eb004564 bl 2175c <strerror> <== NOT EXECUTED 101c8: e1a01007 mov r1, r7 <== NOT EXECUTED 101cc: e1a03000 mov r3, r0 <== NOT EXECUTED 101d0: e1a0200b mov r2, fp <== NOT EXECUTED 101d4: e59f0474 ldr r0, [pc, #1140] ; 10650 <rtems_rfs_format+0xde8><== NOT EXECUTED 101d8: eb0040b1 bl 204a4 <printf> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
101dc: e3e00000 mvn r0, #0 <== NOT EXECUTED 101e0: eafffe1e b fa60 <rtems_rfs_format+0x1f8> <== 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));
101e4: e59d30d8 ldr r3, [sp, #216] ; 0xd8 101e8: e3a01000 mov r1, #0 101ec: e59d2014 ldr r2, [sp, #20] 101f0: e593001c ldr r0, [r3, #28] 101f4: eb004039 bl 202e0 <memset>
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
101f8: e28d00b8 add r0, sp, #184 ; 0xb8 101fc: eb0021b8 bl 188e4 <rtems_rfs_bitmap_map_clear_all>
if (rc > 0)
10200: e2504000 subs r4, r0, #0
{
rtems_rfs_bitmap_close (&bitmap);
10204: e28d00b8 add r0, sp, #184 ; 0xb8
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
if (rc > 0)
10208: da00003f ble 1030c <rtems_rfs_format+0xaa4>
{
rtems_rfs_bitmap_close (&bitmap);
1020c: eb00225a bl 18b7c <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);
10210: e28d10d0 add r1, sp, #208 ; 0xd0 <== NOT EXECUTED 10214: e28d000c add r0, sp, #12 <== NOT EXECUTED 10218: eb0026b8 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
1021c: e3a03000 mov r3, #0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
10220: e1a00004 mov r0, r4 <== NOT EXECUTED 10224: e5cd30d0 strb r3, [sp, #208] ; 0xd0 <== NOT EXECUTED
handle->bnum = 0;
10228: e58d30d4 str r3, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->buffer = NULL;
1022c: e58d30d8 str r3, [sp, #216] ; 0xd8 <== NOT EXECUTED 10230: eb004549 bl 2175c <strerror> <== NOT EXECUTED 10234: e1a01007 mov r1, r7 <== NOT EXECUTED 10238: e1a03000 mov r3, r0 <== NOT EXECUTED 1023c: e1a02004 mov r2, r4 <== NOT EXECUTED 10240: e59f040c ldr r0, [pc, #1036] ; 10654 <rtems_rfs_format+0xdec><== NOT EXECUTED 10244: eb004096 bl 204a4 <printf> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
10248: e3e00000 mvn r0, #0 <== NOT EXECUTED 1024c: eafffe03 b fa60 <rtems_rfs_format+0x1f8> <== NOT EXECUTED
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
printf (", inodes");
10250: e59f0400 ldr r0, [pc, #1024] ; 10658 <rtems_rfs_format+0xdf0><== NOT EXECUTED 10254: eb004092 bl 204a4 <printf> <== NOT EXECUTED 10258: eaffff92 b 100a8 <rtems_rfs_format+0x840> <== NOT EXECUTED
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
if (rc > 0)
{
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
1025c: eb00453e bl 2175c <strerror> <== NOT EXECUTED 10260: e1a01005 mov r1, r5 <== NOT EXECUTED 10264: e1a02000 mov r2, r0 <== NOT EXECUTED 10268: e59f03ec ldr r0, [pc, #1004] ; 1065c <rtems_rfs_format+0xdf4><== NOT EXECUTED 1026c: eb00408c bl 204a4 <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
10270: e59d00dc ldr r0, [sp, #220] ; 0xdc <== NOT EXECUTED 10274: eb003377 bl 1d058 <rtems_rfs_fs_close> <== NOT EXECUTED
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
10278: e1a00005 mov r0, r5 <== NOT EXECUTED 1027c: eb004536 bl 2175c <strerror> <== NOT EXECUTED 10280: e1a01005 mov r1, r5 <== NOT EXECUTED 10284: e1a02000 mov r2, r0 <== NOT EXECUTED 10288: e59f03d0 ldr r0, [pc, #976] ; 10660 <rtems_rfs_format+0xdf8><== NOT EXECUTED 1028c: eb004084 bl 204a4 <printf> <== NOT EXECUTED
rc, strerror (rc));
return -1;
10290: e3e00000 mvn r0, #0 <== NOT EXECUTED 10294: eafffdf1 b fa60 <rtems_rfs_format+0x1f8> <== NOT EXECUTED
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
if (config->verbose)
printf ("\n");
10298: e3a0000a mov r0, #10 <== NOT EXECUTED 1029c: eb0040ea bl 2064c <putchar> <== NOT EXECUTED 102a0: eaffffa2 b 10130 <rtems_rfs_format+0x8c8> <== NOT EXECUTED
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
if (rc > 0)
{
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
102a4: eb00452c bl 2175c <strerror> <== NOT EXECUTED 102a8: e1a01004 mov r1, r4 <== NOT EXECUTED 102ac: e1a02000 mov r2, r0 <== NOT EXECUTED 102b0: e59f03ac ldr r0, [pc, #940] ; 10664 <rtems_rfs_format+0xdfc><== NOT EXECUTED 102b4: eb00407a bl 204a4 <printf> <== NOT EXECUTED
rc, strerror (rc));
return -1;
102b8: e3e00000 mvn r0, #0 <== NOT EXECUTED 102bc: eafffde7 b fa60 <rtems_rfs_format+0x1f8> <== NOT EXECUTED
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
102c0: e59d00dc ldr r0, [sp, #220] ; 0xdc 102c4: e1a01004 mov r1, r4 102c8: e28d2090 add r2, sp, #144 ; 0x90 102cc: e1a03004 mov r3, r4 102d0: eb0002fc bl 10ec8 <rtems_rfs_inode_open>
if (rc > 0)
102d4: e2505000 subs r5, r0, #0
102d8: da00004e ble 10418 <rtems_rfs_format+0xbb0>
{
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
102dc: eb00451e bl 2175c <strerror> <== NOT EXECUTED 102e0: e1a01005 mov r1, r5 <== NOT EXECUTED 102e4: e1a02000 mov r2, r0 <== NOT EXECUTED 102e8: e59f0378 ldr r0, [pc, #888] ; 10668 <rtems_rfs_format+0xe00><== NOT EXECUTED 102ec: eb00406c bl 204a4 <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_group_bitmap_free (fs, true, ino);
102f0: e59d00dc ldr r0, [sp, #220] ; 0xdc <== NOT EXECUTED 102f4: e1a01004 mov r1, r4 <== NOT EXECUTED 102f8: e59d20e0 ldr r2, [sp, #224] ; 0xe0 <== NOT EXECUTED 102fc: eb000215 bl 10b58 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
10300: e59d00dc ldr r0, [sp, #220] ; 0xdc <== NOT EXECUTED 10304: eb003353 bl 1d058 <rtems_rfs_fs_close> <== NOT EXECUTED 10308: eaffffda b 10278 <rtems_rfs_format+0xa10> <== NOT EXECUTED
}
/*
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
1030c: eb00221a bl 18b7c <rtems_rfs_bitmap_close>
if (rc > 0)
10310: e2504000 subs r4, r0, #0
10314: ca00002f bgt 103d8 <rtems_rfs_format+0xb70>
rtems_rfs_buffer_mark_dirty (&handle);
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
10318: e59d2004 ldr r2, [sp, #4]
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);
1031c: e3a03001 mov r3, #1
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
10320: e3520000 cmp r2, #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);
10324: e5cd30d0 strb r3, [sp, #208] ; 0xd0
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
10328: 0a00007a beq 10518 <rtems_rfs_format+0xcb0>
{
for (b = 0; b < blocks; b++)
1032c: e3590000 cmp r9, #0 <== NOT EXECUTED 10330: da000078 ble 10518 <rtems_rfs_format+0xcb0> <== NOT EXECUTED 10334: e2855002 add r5, r5, #2 <== NOT EXECUTED
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
10338: e0859009 add r9, r5, r9 <== NOT EXECUTED 1033c: ea000008 b 10364 <rtems_rfs_format+0xafc> <== 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));
10340: e59d30d8 ldr r3, [sp, #216] ; 0xd8 <== NOT EXECUTED 10344: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 10348: e593001c ldr r0, [r3, #28] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
1034c: e2855001 add r5, r5, #1 <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
10350: eb003fe2 bl 202e0 <memset> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
10354: e3a00001 mov r0, #1 <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
10358: e1550009 cmp r5, r9 <== NOT EXECUTED
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
rtems_rfs_buffer_mark_dirty (&handle);
1035c: e5cd00d0 strb r0, [sp, #208] ; 0xd0 <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
10360: 0a00006c beq 10518 <rtems_rfs_format+0xcb0> <== NOT EXECUTED
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
10364: e28d10d0 add r1, sp, #208 ; 0xd0 <== NOT EXECUTED 10368: e1a02005 mov r2, r5 <== NOT EXECUTED 1036c: e3a03000 mov r3, #0 <== NOT EXECUTED 10370: e28d000c add r0, sp, #12 <== NOT EXECUTED 10374: eb0026da bl 19ee4 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
10378: e3500000 cmp r0, #0 <== 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));
1037c: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
10380: daffffee ble 10340 <rtems_rfs_format+0xad8> <== NOT EXECUTED 10384: e1a04000 mov r4, r0 <== 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);
10388: e28d10d0 add r1, sp, #208 ; 0xd0 <== NOT EXECUTED 1038c: e28d000c add r0, sp, #12 <== NOT EXECUTED 10390: eb00265a bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
10394: e3a03000 mov r3, #0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
10398: e1a00004 mov r0, r4 <== NOT EXECUTED 1039c: e5cd30d0 strb r3, [sp, #208] ; 0xd0 <== NOT EXECUTED
handle->bnum = 0;
103a0: e58d30d4 str r3, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->buffer = NULL;
103a4: e58d30d8 str r3, [sp, #216] ; 0xd8 <== NOT EXECUTED 103a8: eb0044eb bl 2175c <strerror> <== NOT EXECUTED 103ac: e1a01007 mov r1, r7 <== NOT EXECUTED 103b0: e58d0000 str r0, [sp] <== NOT EXECUTED 103b4: e1a02005 mov r2, r5 <== NOT EXECUTED 103b8: e59f02ac ldr r0, [pc, #684] ; 1066c <rtems_rfs_format+0xe04><== NOT EXECUTED 103bc: e1a03004 mov r3, r4 <== NOT EXECUTED 103c0: eb004037 bl 204a4 <printf> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
103c4: e3e00000 mvn r0, #0 <== NOT EXECUTED 103c8: eafffda4 b fa60 <rtems_rfs_format+0x1f8> <== NOT EXECUTED
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
int b;
for (b = 31; b > 0; b--)
103cc: e3a04001 mov r4, #1 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
103d0: e58d4014 str r4, [sp, #20] <== NOT EXECUTED 103d4: eafffe2c b fc8c <rtems_rfs_format+0x424> <== 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);
103d8: e28d10d0 add r1, sp, #208 ; 0xd0 <== NOT EXECUTED 103dc: e28d000c add r0, sp, #12 <== NOT EXECUTED 103e0: eb002646 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
103e4: e3a03000 mov r3, #0 <== NOT EXECUTED
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
103e8: e1a00004 mov r0, r4 <== NOT EXECUTED 103ec: e5cd30d0 strb r3, [sp, #208] ; 0xd0 <== NOT EXECUTED
handle->bnum = 0;
103f0: e58d30d4 str r3, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->buffer = NULL;
103f4: e58d30d8 str r3, [sp, #216] ; 0xd8 <== NOT EXECUTED 103f8: eb0044d7 bl 2175c <strerror> <== NOT EXECUTED 103fc: e1a01007 mov r1, r7 <== NOT EXECUTED 10400: e1a03000 mov r3, r0 <== NOT EXECUTED 10404: e1a02004 mov r2, r4 <== NOT EXECUTED 10408: e59f0260 ldr r0, [pc, #608] ; 10670 <rtems_rfs_format+0xe08><== NOT EXECUTED 1040c: eb004024 bl 204a4 <printf> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
10410: e3e00000 mvn r0, #0 <== NOT EXECUTED 10414: eafffd91 b fa60 <rtems_rfs_format+0x1f8> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, true, ino);
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
10418: e3a0c000 mov ip, #0 1041c: e1a0100c mov r1, ip 10420: e28d0090 add r0, sp, #144 ; 0x90 10424: e59f2248 ldr r2, [pc, #584] ; 10674 <rtems_rfs_format+0xe0c> 10428: e1a0300c mov r3, ip 1042c: e58dc000 str ip, [sp] 10430: eb0003a8 bl 112d8 <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)
10434: e2504000 subs r4, r0, #0
10438: da000004 ble 10450 <rtems_rfs_format+0xbe8>
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
1043c: eb0044c6 bl 2175c <strerror> <== NOT EXECUTED 10440: e1a01004 mov r1, r4 <== NOT EXECUTED 10444: e1a02000 mov r2, r0 <== NOT EXECUTED 10448: e59f0228 ldr r0, [pc, #552] ; 10678 <rtems_rfs_format+0xe10><== NOT EXECUTED 1044c: eb004014 bl 204a4 <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
10450: e59dc0e0 ldr ip, [sp, #224] ; 0xe0 10454: e59d00dc ldr r0, [sp, #220] ; 0xdc 10458: e28d1090 add r1, sp, #144 ; 0x90 1045c: e59f2218 ldr r2, [pc, #536] ; 1067c <rtems_rfs_format+0xe14> 10460: e3a03001 mov r3, #1 10464: e58dc000 str ip, [sp] 10468: eb0029ac bl 1ab20 <rtems_rfs_dir_add_entry>
if (rc > 0)
1046c: e2504000 subs r4, r0, #0
10470: da000004 ble 10488 <rtems_rfs_format+0xc20>
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
10474: eb0044b8 bl 2175c <strerror> <== NOT EXECUTED 10478: e1a01004 mov r1, r4 <== NOT EXECUTED 1047c: e1a02000 mov r2, r0 <== NOT EXECUTED 10480: e59f01f8 ldr r0, [pc, #504] ; 10680 <rtems_rfs_format+0xe18><== NOT EXECUTED 10484: eb004006 bl 204a4 <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
10488: e59d00dc ldr r0, [sp, #220] ; 0xdc 1048c: e28d1090 add r1, sp, #144 ; 0x90 10490: eb000306 bl 110b0 <rtems_rfs_inode_close>
if (rc > 0)
10494: e2504000 subs r4, r0, #0
10498: da000004 ble 104b0 <rtems_rfs_format+0xc48>
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
1049c: eb0044ae bl 2175c <strerror> <== NOT EXECUTED 104a0: e1a01004 mov r1, r4 <== NOT EXECUTED 104a4: e1a02000 mov r2, r0 <== NOT EXECUTED 104a8: e59f01d4 ldr r0, [pc, #468] ; 10684 <rtems_rfs_format+0xe1c><== NOT EXECUTED 104ac: eb003ffc bl 204a4 <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
104b0: e59d00dc ldr r0, [sp, #220] ; 0xdc 104b4: eb0032e7 bl 1d058 <rtems_rfs_fs_close>
if (rc < 0)
104b8: e2505000 subs r5, r0, #0
104bc: ba000031 blt 10588 <rtems_rfs_format+0xd20>
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
rc, strerror (rc));
return -1;
}
return 0;
104c0: 01a00005 moveq r0, r5
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
104c4: 0afffd65 beq fa60 <rtems_rfs_format+0x1f8>
104c8: eaffff6a b 10278 <rtems_rfs_format+0xa10> <== NOT EXECUTED
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
if (rc > 0)
{
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
104cc: eb0044a2 bl 2175c <strerror> <== NOT EXECUTED 104d0: e1a01004 mov r1, r4 <== NOT EXECUTED 104d4: e1a02000 mov r2, r0 <== NOT EXECUTED 104d8: e59f01a8 ldr r0, [pc, #424] ; 10688 <rtems_rfs_format+0xe20><== NOT EXECUTED 104dc: eb003ff0 bl 204a4 <printf> <== NOT EXECUTED
rc, strerror (rc));
return -1;
104e0: e3e00000 mvn r0, #0 <== NOT EXECUTED 104e4: eafffd5d b fa60 <rtems_rfs_format+0x1f8> <== NOT EXECUTED
printf ("\n");
rc = rtems_rfs_buffer_close (&fs);
if (rc > 0)
{
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
104e8: eb00449b bl 2175c <strerror> <== NOT EXECUTED 104ec: e1a01004 mov r1, r4 <== NOT EXECUTED 104f0: e1a02000 mov r2, r0 <== NOT EXECUTED 104f4: e59f0190 ldr r0, [pc, #400] ; 1068c <rtems_rfs_format+0xe24><== NOT EXECUTED 104f8: eb003fe9 bl 204a4 <printf> <== NOT EXECUTED
rc, strerror (rc));
return -1;
104fc: e3e00000 mvn r0, #0 <== NOT EXECUTED 10500: eafffd56 b fa60 <rtems_rfs_format+0x1f8> <== NOT EXECUTED
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
10504: e59f0184 ldr r0, [pc, #388] ; 10690 <rtems_rfs_format+0xe28><== NOT EXECUTED 10508: e1a01005 mov r1, r5 <== NOT EXECUTED 1050c: eb003fe4 bl 204a4 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
return -1;
10510: e3e00000 mvn r0, #0 <== NOT EXECUTED 10514: eafffd51 b fa60 <rtems_rfs_format+0x1f8> <== 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);
10518: e28d000c add r0, sp, #12 1051c: e28d10d0 add r1, sp, #208 ; 0xd0 10520: eb0025f6 bl 19d00 <rtems_rfs_buffer_handle_release>
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
10524: e59d3030 ldr r3, [sp, #48] ; 0x30 10528: e2877001 add r7, r7, #1 1052c: e1530007 cmp r3, r7
handle->dirty = false;
10530: e3a02000 mov r2, #0
handle->bnum = 0;
10534: e3a03000 mov r3, #0
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
10538: e5cd20d0 strb r2, [sp, #208] ; 0xd0
handle->bnum = 0;
1053c: e58d30d4 str r3, [sp, #212] ; 0xd4
handle->buffer = NULL;
10540: e58d30d8 str r3, [sp, #216] ; 0xd8
10544: dafffef6 ble 10124 <rtems_rfs_format+0x8bc>
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
10548: e59d4034 ldr r4, [sp, #52] ; 0x34 <== NOT EXECUTED 1054c: e0080794 mul r8, r4, r7 <== NOT EXECUTED
if (group_base > rtems_rfs_fs_blocks (fs))
10550: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
10554: e2885001 add r5, r8, #1 <== NOT EXECUTED
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
10558: e5da0014 ldrb r0, [sl, #20] <== NOT EXECUTED
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
1055c: e1550003 cmp r5, r3 <== NOT EXECUTED
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
10560: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 10564: e5da6015 ldrb r6, [sl, #21] <== NOT EXECUTED
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
10568: 9afffe6c bls ff20 <rtems_rfs_format+0x6b8> <== NOT EXECUTED
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
1056c: e59f0120 ldr r0, [pc, #288] ; 10694 <rtems_rfs_format+0xe2c><== NOT EXECUTED 10570: e1a01007 mov r1, r7 <== NOT EXECUTED 10574: eb003fca bl 204a4 <printf> <== NOT EXECUTED
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
10578: e3e00000 mvn r0, #0 <== NOT EXECUTED 1057c: eafffd37 b fa60 <rtems_rfs_format+0x1f8> <== NOT EXECUTED
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
10580: e1a07003 mov r7, r3 <== NOT EXECUTED 10584: eafffff8 b 1056c <rtems_rfs_format+0xd04> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
if (rc < 0)
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
errno, strerror (errno));
10588: eb003c01 bl 1f594 <__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",
1058c: e5904000 ldr r4, [r0] <== NOT EXECUTED
errno, strerror (errno));
10590: eb003bff bl 1f594 <__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",
10594: e5900000 ldr r0, [r0] <== NOT EXECUTED 10598: eb00446f bl 2175c <strerror> <== NOT EXECUTED 1059c: e1a01004 mov r1, r4 <== NOT EXECUTED 105a0: e1a02000 mov r2, r0 <== NOT EXECUTED 105a4: e59f00ec ldr r0, [pc, #236] ; 10698 <rtems_rfs_format+0xe30><== NOT EXECUTED 105a8: eb003fbd bl 204a4 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
rc, strerror (rc));
return -1;
}
return 0;
105ac: e3a00000 mov r0, #0 <== NOT EXECUTED 105b0: eafffd2a b fa60 <rtems_rfs_format+0x1f8> <== NOT EXECUTED
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",
errno, strerror (errno));
105b4: eb003bf6 bl 1f594 <__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",
105b8: e5904000 ldr r4, [r0] <== NOT EXECUTED
errno, strerror (errno));
105bc: eb003bf4 bl 1f594 <__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",
105c0: e5900000 ldr r0, [r0] <== NOT EXECUTED 105c4: eb004464 bl 2175c <strerror> <== NOT EXECUTED 105c8: e1a01004 mov r1, r4 <== NOT EXECUTED 105cc: e1a02000 mov r2, r0 <== NOT EXECUTED 105d0: e59f00c4 ldr r0, [pc, #196] ; 1069c <rtems_rfs_format+0xe34><== NOT EXECUTED 105d4: eb003fb2 bl 204a4 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
rc, strerror (rc));
return -1;
}
return 0;
105d8: e3a00000 mov r0, #0 <== NOT EXECUTED 105dc: eafffd1f b fa60 <rtems_rfs_format+0x1f8> <== NOT EXECUTED
0001d058 <rtems_rfs_fs_close>:
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
1d058: e92d4070 push {r4, r5, r6, lr}
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
1d05c: e3a01000 mov r1, #0
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
1d060: e1a04000 mov r4, r0
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
1d064: e3a00002 mov r0, #2 1d068: ebffd5f0 bl 12830 <rtems_rfs_trace> 1d06c: e3500000 cmp r0, #0
1d070: 1a000013 bne 1d0c4 <rtems_rfs_fs_close+0x6c>
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
1d074: e5943024 ldr r3, [r4, #36] ; 0x24 1d078: e3530000 cmp r3, #0
1d07c: da00000a ble 1d0ac <rtems_rfs_fs_close+0x54>
1d080: e3a05000 mov r5, #0 1d084: e1a06005 mov r6, r5
rtems_rfs_group_close (fs, &fs->groups[group]);
1d088: e5941020 ldr r1, [r4, #32] 1d08c: e1a00004 mov r0, r4 1d090: e0811005 add r1, r1, r5 1d094: ebffce04 bl 108ac <rtems_rfs_group_close>
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
1d098: e5943024 ldr r3, [r4, #36] ; 0x24 1d09c: e2866001 add r6, r6, #1 1d0a0: e1530006 cmp r3, r6 1d0a4: e2855050 add r5, r5, #80 ; 0x50
1d0a8: cafffff6 bgt 1d088 <rtems_rfs_fs_close+0x30>
rtems_rfs_group_close (fs, &fs->groups[group]);
rtems_rfs_buffer_close (fs);
1d0ac: e1a00004 mov r0, r4 1d0b0: ebfff518 bl 1a518 <rtems_rfs_buffer_close>
free (fs);
1d0b4: e1a00004 mov r0, r4 1d0b8: ebffa85e bl 7238 <free>
return 0; }
1d0bc: e3a00000 mov r0, #0
1d0c0: e8bd8070 pop {r4, r5, r6, pc}
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
1d0c4: e59f0004 ldr r0, [pc, #4] ; 1d0d0 <rtems_rfs_fs_close+0x78><== NOT EXECUTED 1d0c8: eb000d8d bl 20704 <puts> <== NOT EXECUTED 1d0cc: eaffffe8 b 1d074 <rtems_rfs_fs_close+0x1c> <== NOT EXECUTED
0001c878 <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)
{
1c878: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
1c87c: e1a06000 mov r6, r0
1c880: e24dd038 sub sp, sp, #56 ; 0x38
1c884: e1a05001 mov r5, r1
#endif
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1c888: e3a00001 mov r0, #1 1c88c: 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)
{
1c890: e1a07002 mov r7, r2 1c894: e1a08003 mov r8, r3 1c898: e59d4058 ldr r4, [sp, #88] ; 0x58
#endif
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1c89c: ebffd7e3 bl 12830 <rtems_rfs_trace> 1c8a0: e3500000 cmp r0, #0
1c8a4: 1a000062 bne 1ca34 <rtems_rfs_fs_open+0x1bc>
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
1c8a8: e3a00084 mov r0, #132 ; 0x84 1c8ac: ebffabe0 bl 7834 <malloc>
if (!*fs)
1c8b0: 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));
1c8b4: e5840000 str r0, [r4]
if (!*fs)
1c8b8: 0a00012b beq 1cd6c <rtems_rfs_fs_open+0x4f4>
printf ("rtems-rfs: open: no memory for file system data\n");
errno = ENOMEM;
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
1c8bc: e3a01000 mov r1, #0 1c8c0: e3a02084 mov r2, #132 ; 0x84 1c8c4: eb000e85 bl 202e0 <memset>
(*fs)->user = user;
1c8c8: e5943000 ldr r3, [r4] 1c8cc: e5835080 str r5, [r3, #128] ; 0x80
rtems_chain_initialize_empty (&(*fs)->buffers);
1c8d0: e5943000 ldr r3, [r4]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
1c8d4: 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 );
1c8d8: e2831044 add r1, r3, #68 ; 0x44 1c8dc: e2832048 add r2, r3, #72 ; 0x48
head->next = tail;
head->previous = NULL;
tail->previous = head;
1c8e0: e583104c str r1, [r3, #76] ; 0x4c
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
1c8e4: e5832044 str r2, [r3, #68] ; 0x44
head->previous = NULL;
1c8e8: e5835048 str r5, [r3, #72] ; 0x48
rtems_chain_initialize_empty (&(*fs)->release);
1c8ec: e5943000 ldr r3, [r4]
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 );
1c8f0: e2831054 add r1, r3, #84 ; 0x54 1c8f4: e2832058 add r2, r3, #88 ; 0x58
head->next = tail;
head->previous = NULL;
tail->previous = head;
1c8f8: e583105c str r1, [r3, #92] ; 0x5c
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
1c8fc: e5832054 str r2, [r3, #84] ; 0x54
head->previous = NULL;
1c900: e5835058 str r5, [r3, #88] ; 0x58
rtems_chain_initialize_empty (&(*fs)->release_modified);
1c904: e5943000 ldr r3, [r4]
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 );
1c908: e2831064 add r1, r3, #100 ; 0x64 1c90c: e2832068 add r2, r3, #104 ; 0x68
head->next = tail;
head->previous = NULL;
tail->previous = head;
1c910: e583106c str r1, [r3, #108] ; 0x6c
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
1c914: e5832064 str r2, [r3, #100] ; 0x64
head->previous = NULL;
1c918: e5835068 str r5, [r3, #104] ; 0x68
rtems_chain_initialize_empty (&(*fs)->file_shares);
1c91c: e5943000 ldr r3, [r4]
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 );
1c920: e2831078 add r1, r3, #120 ; 0x78 1c924: e2832074 add r2, r3, #116 ; 0x74
head->next = tail;
1c928: e5831074 str r1, [r3, #116] ; 0x74
head->previous = NULL;
1c92c: e5835078 str r5, [r3, #120] ; 0x78
tail->previous = head;
1c930: e583207c str r2, [r3, #124] ; 0x7c
(*fs)->max_held_buffers = max_held_buffers;
1c934: e5941000 ldr r1, [r4]
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
1c938: e1a00006 mov r0, r6
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;
1c93c: e5818040 str r8, [r1, #64] ; 0x40
(*fs)->buffers_count = 0;
1c940: e5815050 str r5, [r1, #80] ; 0x50
(*fs)->release_count = 0;
1c944: e5815060 str r5, [r1, #96] ; 0x60
(*fs)->release_modified_count = 0;
1c948: e5815070 str r5, [r1, #112] ; 0x70
(*fs)->flags = flags;
1c94c: e5817000 str r7, [r1]
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
1c950: ebfff60a bl 1a180 <rtems_rfs_buffer_open>
if (rc > 0)
1c954: e2506000 subs r6, r0, #0
1c958: ca00007c bgt 1cb50 <rtems_rfs_fs_open+0x2d8>
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
1c95c: e5946000 ldr r6, [r4]
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);
1c960: e28d102c add r1, sp, #44 ; 0x2c 1c964: e1a00006 mov r0, r6 1c968: e1a02005 mov r2, r5 1c96c: 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;
1c970: e5cd502c strb r5, [sp, #44] ; 0x2c
handle->bnum = 0;
1c974: e58d5030 str r5, [sp, #48] ; 0x30
handle->buffer = NULL;
1c978: e58d5034 str r5, [sp, #52] ; 0x34 1c97c: ebfff558 bl 19ee4 <rtems_rfs_buffer_handle_request>
if (rc > 0)
1c980: e2508000 subs r8, r0, #0
1c984: da000013 ble 1c9d8 <rtems_rfs_fs_open+0x160>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1c988: e3a00001 mov r0, #1 <== NOT EXECUTED 1c98c: e3a01000 mov r1, #0 <== NOT EXECUTED 1c990: ebffd7a6 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1c994: e3500000 cmp r0, #0 <== NOT EXECUTED 1c998: 1a000030 bne 1ca60 <rtems_rfs_fs_open+0x1e8> <== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
1c99c: e5940000 ldr r0, [r4] <== NOT EXECUTED 1c9a0: ebfff6dc bl 1a518 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
1c9a4: e5940000 ldr r0, [r4] <== NOT EXECUTED 1c9a8: ebffaa22 bl 7238 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1c9ac: e3a00001 mov r0, #1 <== NOT EXECUTED 1c9b0: e3a01000 mov r1, #0 <== NOT EXECUTED 1c9b4: ebffd79d bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1c9b8: e3500000 cmp r0, #0 <== NOT EXECUTED 1c9bc: 1a00007c bne 1cbb4 <rtems_rfs_fs_open+0x33c> <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
rc, strerror (rc));
errno = rc;
1c9c0: eb000af3 bl 1f594 <__errno> <== NOT EXECUTED 1c9c4: e5808000 str r8, [r0] <== NOT EXECUTED
return -1;
1c9c8: e3e03000 mvn r3, #0 <== NOT EXECUTED
return -1;
}
errno = 0;
return 0;
}
1c9cc: e1a00003 mov r0, r3
1c9d0: e28dd038 add sp, sp, #56 ; 0x38
1c9d4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
1c9d8: e59d3034 ldr r3, [sp, #52] ; 0x34 1c9dc: 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)
1c9e0: e5d72001 ldrb r2, [r7, #1] 1c9e4: e5d73000 ldrb r3, [r7] 1c9e8: e1a02802 lsl r2, r2, #16 1c9ec: e5d71003 ldrb r1, [r7, #3] 1c9f0: e1822c03 orr r2, r2, r3, lsl #24 1c9f4: e5d73002 ldrb r3, [r7, #2] 1c9f8: e1822001 orr r2, r2, r1 1c9fc: e1822403 orr r2, r2, r3, lsl #8 1ca00: e59f3608 ldr r3, [pc, #1544] ; 1d010 <rtems_rfs_fs_open+0x798> 1ca04: e1520003 cmp r2, r3
1ca08: 0a00001b beq 1ca7c <rtems_rfs_fs_open+0x204>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1ca0c: e3a00001 mov r0, #1 <== NOT EXECUTED 1ca10: e3a01000 mov r1, #0 <== NOT EXECUTED 1ca14: ebffd785 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1ca18: e3500000 cmp r0, #0 <== NOT EXECUTED 1ca1c: 1a000008 bne 1ca44 <rtems_rfs_fs_open+0x1cc> <== 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);
1ca20: e1a00006 mov r0, r6 <== NOT EXECUTED 1ca24: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 1ca28: ebfff4b4 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
1ca2c: e3a08005 mov r8, #5 <== NOT EXECUTED 1ca30: eaffffd9 b 1c99c <rtems_rfs_fs_open+0x124> <== NOT EXECUTED
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: %s\n", name);
1ca34: e1a01006 mov r1, r6 <== NOT EXECUTED 1ca38: e59f05d4 ldr r0, [pc, #1492] ; 1d014 <rtems_rfs_fs_open+0x79c><== NOT EXECUTED 1ca3c: eb000e98 bl 204a4 <printf> <== NOT EXECUTED 1ca40: eaffff98 b 1c8a8 <rtems_rfs_fs_open+0x30> <== 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))
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
1ca44: e59f05cc ldr r0, [pc, #1484] ; 1d018 <rtems_rfs_fs_open+0x7a0><== NOT EXECUTED 1ca48: eb000f2d bl 20704 <puts> <== NOT EXECUTED 1ca4c: e1a00006 mov r0, r6 <== NOT EXECUTED 1ca50: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 1ca54: ebfff4a9 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: inode size mismatch: fs:%" PRId32 " target:%" PRId32 "\n",
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
1ca58: e3a08005 mov r8, #5 <== NOT EXECUTED 1ca5c: eaffffce b 1c99c <rtems_rfs_fs_open+0x124> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
1ca60: e1a00008 mov r0, r8 <== NOT EXECUTED 1ca64: eb00133c bl 2175c <strerror> <== NOT EXECUTED 1ca68: e1a01008 mov r1, r8 <== NOT EXECUTED 1ca6c: e1a02000 mov r2, r0 <== NOT EXECUTED 1ca70: e59f05a4 ldr r0, [pc, #1444] ; 1d01c <rtems_rfs_fs_open+0x7a4><== NOT EXECUTED 1ca74: eb000e8a bl 204a4 <printf> <== NOT EXECUTED 1ca78: eaffffc7 b 1c99c <rtems_rfs_fs_open+0x124> <== 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);
1ca7c: e5d7300d ldrb r3, [r7, #13] 1ca80: e5d7000c ldrb r0, [r7, #12] 1ca84: e5d7100f ldrb r1, [r7, #15] 1ca88: e1a03803 lsl r3, r3, #16 1ca8c: e5d7200e ldrb r2, [r7, #14] 1ca90: e1833c00 orr r3, r3, r0, lsl #24 1ca94: e1833001 orr r3, r3, r1 1ca98: e1833402 orr r3, r3, r2, lsl #8 1ca9c: e5863004 str r3, [r6, #4]
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
1caa0: e5d71009 ldrb r1, [r7, #9] 1caa4: e5d7c008 ldrb ip, [r7, #8] 1caa8: e5d7000b ldrb r0, [r7, #11]
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
1caac: e5962010 ldr r2, [r6, #16]
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);
1cab0: e1a01801 lsl r1, r1, #16 1cab4: e1811c0c orr r1, r1, ip, lsl #24 1cab8: e5d7e00a ldrb lr, [r7, #10] 1cabc: e1811000 orr r1, r1, r0
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);
1cac0: e282001c add r0, r2, #28
1cac4: e8901001 ldm r0, {r0, ip}
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);
1cac8: e181140e orr r1, r1, lr, lsl #8
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;
1cacc: e0898391 umull r8, r9, r1, 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;
1cad0: e083209c umull r2, r3, ip, r0
}
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))
1cad4: e1530009 cmp r3, r9 1cad8: 01520008 cmpeq r2, r8
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);
1cadc: e5861008 str r1, [r6, #8]
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
1cae0: 3a00002b bcc 1cb94 <rtems_rfs_fs_open+0x31c>
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)
1cae4: e5d73025 ldrb r3, [r7, #37] ; 0x25 1cae8: e5d72024 ldrb r2, [r7, #36] ; 0x24 1caec: e1a03803 lsl r3, r3, #16 1caf0: e5d70027 ldrb r0, [r7, #39] ; 0x27 1caf4: e1833c02 orr r3, r3, r2, lsl #24 1caf8: e5d72026 ldrb r2, [r7, #38] ; 0x26 1cafc: e1833000 orr r3, r3, r0 1cb00: e1833402 orr r3, r3, r2, lsl #8 1cb04: e3530038 cmp r3, #56 ; 0x38
1cb08: 0a000030 beq 1cbd0 <rtems_rfs_fs_open+0x358>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1cb0c: e3a00001 mov r0, #1 <== NOT EXECUTED 1cb10: e3a01000 mov r1, #0 <== NOT EXECUTED 1cb14: ebffd745 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1cb18: e3500000 cmp r0, #0 <== NOT EXECUTED 1cb1c: 0affffbf beq 1ca20 <rtems_rfs_fs_open+0x1a8> <== 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);
1cb20: e5d73005 ldrb r3, [r7, #5] <== NOT EXECUTED 1cb24: e5d71004 ldrb r1, [r7, #4] <== NOT EXECUTED 1cb28: e5d72007 ldrb r2, [r7, #7] <== NOT EXECUTED 1cb2c: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED 1cb30: e1833c01 orr r3, r3, r1, lsl #24 <== NOT EXECUTED 1cb34: e5d71006 ldrb r1, [r7, #6] <== NOT EXECUTED 1cb38: 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",
1cb3c: e1831401 orr r1, r3, r1, lsl #8 <== NOT EXECUTED 1cb40: e1a02005 mov r2, r5 <== NOT EXECUTED 1cb44: e59f04d4 ldr r0, [pc, #1236] ; 1d020 <rtems_rfs_fs_open+0x7a8><== NOT EXECUTED 1cb48: eb000e55 bl 204a4 <printf> <== NOT EXECUTED 1cb4c: eaffffb3 b 1ca20 <rtems_rfs_fs_open+0x1a8> <== NOT EXECUTED
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
if (rc > 0)
{
free (*fs);
1cb50: e5940000 ldr r0, [r4] <== NOT EXECUTED 1cb54: ebffa9b7 bl 7238 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1cb58: e3a00001 mov r0, #1 <== NOT EXECUTED 1cb5c: e3a01000 mov r1, #0 <== NOT EXECUTED 1cb60: ebffd732 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1cb64: e1500005 cmp r0, r5 <== NOT EXECUTED 1cb68: 0a000005 beq 1cb84 <rtems_rfs_fs_open+0x30c> <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
1cb6c: e1a00006 mov r0, r6 <== NOT EXECUTED 1cb70: eb0012f9 bl 2175c <strerror> <== NOT EXECUTED 1cb74: e1a01006 mov r1, r6 <== NOT EXECUTED 1cb78: e1a02000 mov r2, r0 <== NOT EXECUTED 1cb7c: e59f04a0 ldr r0, [pc, #1184] ; 1d024 <rtems_rfs_fs_open+0x7ac><== NOT EXECUTED 1cb80: eb000e47 bl 204a4 <printf> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
1cb84: eb000a82 bl 1f594 <__errno> <== NOT EXECUTED
return -1;
1cb88: e3e03000 mvn r3, #0 <== NOT EXECUTED
{
free (*fs);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
rc, strerror (rc));
errno = rc;
1cb8c: e5806000 str r6, [r0] <== NOT EXECUTED
return -1;
1cb90: eaffff8d b 1c9cc <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1cb94: e3a00001 mov r0, #1 <== NOT EXECUTED 1cb98: e3a01000 mov r1, #0 <== NOT EXECUTED 1cb9c: ebffd723 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1cba0: e3500000 cmp r0, #0 <== NOT EXECUTED 1cba4: 0affff9d beq 1ca20 <rtems_rfs_fs_open+0x1a8> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
1cba8: e59f0478 ldr r0, [pc, #1144] ; 1d028 <rtems_rfs_fs_open+0x7b0><== NOT EXECUTED 1cbac: eb000ed4 bl 20704 <puts> <== NOT EXECUTED 1cbb0: eaffff9a b 1ca20 <rtems_rfs_fs_open+0x1a8> <== NOT EXECUTED
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
free (*fs);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
1cbb4: e1a00008 mov r0, r8 <== NOT EXECUTED 1cbb8: eb0012e7 bl 2175c <strerror> <== NOT EXECUTED 1cbbc: e1a01008 mov r1, r8 <== NOT EXECUTED 1cbc0: e1a02000 mov r2, r0 <== NOT EXECUTED 1cbc4: e59f0460 ldr r0, [pc, #1120] ; 1d02c <rtems_rfs_fs_open+0x7b4><== NOT EXECUTED 1cbc8: eb000e35 bl 204a4 <printf> <== NOT EXECUTED 1cbcc: eaffff7b b 1c9c0 <rtems_rfs_fs_open+0x148> <== 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);
1cbd0: e5d73011 ldrb r3, [r7, #17] 1cbd4: e5d7c010 ldrb ip, [r7, #16] 1cbd8: e5d70013 ldrb r0, [r7, #19] 1cbdc: e1a03803 lsl r3, r3, #16 1cbe0: e5d72012 ldrb r2, [r7, #18] 1cbe4: e1833c0c orr r3, r3, ip, lsl #24 1cbe8: e1833000 orr r3, r3, r0 1cbec: e1833402 orr r3, r3, r2, lsl #8 1cbf0: e5863018 str r3, [r6, #24]
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
1cbf4: e5d73015 ldrb r3, [r7, #21] 1cbf8: e5d7c014 ldrb ip, [r7, #20] 1cbfc: e5d70017 ldrb r0, [r7, #23] 1cc00: e1a03803 lsl r3, r3, #16 1cc04: e5d72016 ldrb r2, [r7, #22] 1cc08: e1833c0c orr r3, r3, ip, lsl #24 1cc0c: e1833000 orr r3, r3, r0 1cc10: e1833402 orr r3, r3, r2, lsl #8 1cc14: e586301c str r3, [r6, #28]
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
1cc18: e5d73019 ldrb r3, [r7, #25] 1cc1c: e5d70018 ldrb r0, [r7, #24] 1cc20: e5d7201b ldrb r2, [r7, #27] 1cc24: e1a03803 lsl r3, r3, #16 1cc28: e5d7e01a ldrb lr, [r7, #26] 1cc2c: e1833c00 orr r3, r3, r0, lsl #24 1cc30: e1833002 orr r3, r3, r2 1cc34: e183e40e orr lr, r3, lr, lsl #8 1cc38: e586e024 str lr, [r6, #36] ; 0x24
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
1cc3c: e5d7301d ldrb r3, [r7, #29] 1cc40: e5d7c01c ldrb ip, [r7, #28] 1cc44: e5d7201f ldrb r2, [r7, #31] 1cc48: e1a03803 lsl r3, r3, #16 1cc4c: e5d7001e ldrb r0, [r7, #30] 1cc50: e1833c0c orr r3, r3, ip, lsl #24 1cc54: e1833002 orr r3, r3, r2 1cc58: e1830400 orr r0, r3, r0, lsl #8 1cc5c: e5860028 str r0, [r6, #40] ; 0x28
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
1cc60: e5d73021 ldrb r3, [r7, #33] ; 0x21 1cc64: e5d72020 ldrb r2, [r7, #32] 1cc68: e5d78023 ldrb r8, [r7, #35] ; 0x23 1cc6c: e1a03803 lsl r3, r3, #16 1cc70: e5d7c022 ldrb ip, [r7, #34] ; 0x22 1cc74: e1832c02 orr r2, r3, r2, lsl #24 1cc78: e1822008 orr r2, r2, r8
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
1cc7c: e1a03121 lsr r3, r1, #2
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;
1cc80: e59f73a8 ldr r7, [pc, #936] ; 1d030 <rtems_rfs_fs_open+0x7b8>
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);
1cc84: e182240c orr r2, r2, ip, lsl #8
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;
1cc88: e1a081a1 lsr r8, r1, #3
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;
1cc8c: e00c0393 mul ip, r3, r3
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
1cc90: e087a798 umull sl, r7, r8, r7
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;
1cc94: e00e0e92 mul lr, r2, lr
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
if (fs->group_blocks >
1cc98: e1500181 cmp r0, r1, lsl #3
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;
1cc9c: e0838103 add r8, r3, r3, lsl #2
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
1cca0: e08cc10c add ip, ip, ip, lsl #2
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);
1cca4: e586202c str r2, [r6, #44] ; 0x2c
fs->blocks_per_block =
1cca8: e5863034 str r3, [r6, #52] ; 0x34
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
1ccac: e5868038 str r8, [r6, #56] ; 0x38
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
1ccb0: e586c03c str ip, [r6, #60] ; 0x3c
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
1ccb4: e586e014 str lr, [r6, #20]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
1ccb8: e5867030 str r7, [r6, #48] ; 0x30 1ccbc: e28d102c add r1, sp, #44 ; 0x2c 1ccc0: e1a00006 mov r0, r6
if (fs->group_blocks >
1ccc4: 9a00000d bls 1cd00 <rtems_rfs_fs_open+0x488>
1ccc8: ebfff40c bl 19d00 <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))
1cccc: e3a00001 mov r0, #1 <== NOT EXECUTED 1ccd0: e3a01000 mov r1, #0 <== NOT EXECUTED
handle->dirty = false;
1ccd4: e5cd502c strb r5, [sp, #44] ; 0x2c <== NOT EXECUTED
handle->bnum = 0;
1ccd8: e58d5030 str r5, [sp, #48] ; 0x30 <== NOT EXECUTED
handle->buffer = NULL;
1ccdc: e58d5034 str r5, [sp, #52] ; 0x34 <== NOT EXECUTED 1cce0: ebffd6d2 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1cce4: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
return EIO;
1cce8: 03a08005 moveq r8, #5 <== NOT EXECUTED
if (fs->group_blocks >
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))
1ccec: 0affff2a beq 1c99c <rtems_rfs_fs_open+0x124> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
1ccf0: e59f033c ldr r0, [pc, #828] ; 1d034 <rtems_rfs_fs_open+0x7bc><== NOT EXECUTED 1ccf4: eb000e82 bl 20704 <puts> <== NOT EXECUTED
return EIO;
1ccf8: e3a08005 mov r8, #5 <== NOT EXECUTED 1ccfc: eaffff26 b 1c99c <rtems_rfs_fs_open+0x124> <== 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);
1cd00: ebfff3fe bl 19d00 <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));
1cd04: e5961008 ldr r1, [r6, #8] 1cd08: e1a00006 mov r0, r6
handle->dirty = false;
1cd0c: e5cd502c strb r5, [sp, #44] ; 0x2c
handle->bnum = 0;
1cd10: e58d5030 str r5, [sp, #48] ; 0x30
handle->buffer = NULL;
1cd14: e58d5034 str r5, [sp, #52] ; 0x34 1cd18: ebfff5c0 bl 1a420 <rtems_rfs_buffer_setblksize>
if (rc > 0)
1cd1c: e2508000 subs r8, r0, #0
1cd20: da00001c ble 1cd98 <rtems_rfs_fs_open+0x520>
*/
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);
1cd24: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 1cd28: e1a00006 mov r0, r6 <== NOT EXECUTED 1cd2c: ebfff3f3 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1cd30: e3a00001 mov r0, #1 <== NOT EXECUTED 1cd34: e3a01000 mov r1, #0 <== NOT EXECUTED
handle->dirty = false;
1cd38: e5cd502c strb r5, [sp, #44] ; 0x2c <== NOT EXECUTED
handle->bnum = 0;
1cd3c: e58d5030 str r5, [sp, #48] ; 0x30 <== NOT EXECUTED
handle->buffer = NULL;
1cd40: e58d5034 str r5, [sp, #52] ; 0x34 <== NOT EXECUTED 1cd44: ebffd6b9 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1cd48: e3500000 cmp r0, #0 <== NOT EXECUTED 1cd4c: 0affff12 beq 1c99c <rtems_rfs_fs_open+0x124> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
1cd50: e1a00008 mov r0, r8 <== NOT EXECUTED 1cd54: eb001280 bl 2175c <strerror> <== NOT EXECUTED 1cd58: e1a01008 mov r1, r8 <== NOT EXECUTED 1cd5c: e1a02000 mov r2, r0 <== NOT EXECUTED 1cd60: e59f02d0 ldr r0, [pc, #720] ; 1d038 <rtems_rfs_fs_open+0x7c0><== NOT EXECUTED 1cd64: eb000dce bl 204a4 <printf> <== NOT EXECUTED 1cd68: eaffff0b b 1c99c <rtems_rfs_fs_open+0x124> <== NOT EXECUTED
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
if (!*fs)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1cd6c: e3a00001 mov r0, #1 <== NOT EXECUTED 1cd70: e3a01000 mov r1, #0 <== NOT EXECUTED 1cd74: ebffd6ad bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1cd78: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
1cd7c: 159f02b8 ldrne r0, [pc, #696] ; 1d03c <rtems_rfs_fs_open+0x7c4><== NOT EXECUTED 1cd80: 1b000e5f blne 20704 <puts> <== NOT EXECUTED
errno = ENOMEM;
1cd84: eb000a02 bl 1f594 <__errno> <== NOT EXECUTED 1cd88: e3a0300c mov r3, #12 <== NOT EXECUTED 1cd8c: e5803000 str r3, [r0] <== NOT EXECUTED
return -1;
1cd90: e3e03000 mvn r3, #0 <== NOT EXECUTED 1cd94: eaffff0c b 1c9cc <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
rc, strerror (rc));
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
1cd98: e5965024 ldr r5, [r6, #36] ; 0x24 1cd9c: e3a01050 mov r1, #80 ; 0x50 1cda0: e1a00005 mov r0, r5 1cda4: ebffa83e bl 6ea4 <calloc>
if (!fs->groups)
1cda8: 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));
1cdac: e1a08000 mov r8, r0 1cdb0: e5860020 str r0, [r6, #32]
if (!fs->groups)
1cdb4: 0a000085 beq 1cfd0 <rtems_rfs_fs_open+0x758>
/*
* 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++)
1cdb8: e3550000 cmp r5, #0
1cdbc: da000032 ble 1ce8c <rtems_rfs_fs_open+0x614>
1cdc0: e3a07000 mov r7, #0
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");
1cdc4: e5962028 ldr r2, [r6, #40] ; 0x28
/* * 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++)
1cdc8: e1a05007 mov r5, r7 1cdcc: ea000006 b 1cdec <rtems_rfs_fs_open+0x574> 1cdd0: e5963024 ldr r3, [r6, #36] ; 0x24 1cdd4: e2855001 add r5, r5, #1 1cdd8: e1550003 cmp r5, r3 1cddc: e2877050 add r7, r7, #80 ; 0x50
1cde0: aa000029 bge 1ce8c <rtems_rfs_fs_open+0x614>
1cde4: e5962028 ldr r2, [r6, #40] ; 0x28 <== NOT EXECUTED 1cde8: e5968020 ldr r8, [r6, #32] <== NOT EXECUTED
{
rc = rtems_rfs_group_open (fs,
rtems_rfs_fs_block (fs, group, 0),
1cdec: e0010592 mul r1, r2, r5
* 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,
1cdf0: e088c007 add ip, r8, r7 1cdf4: e596302c ldr r3, [r6, #44] ; 0x2c 1cdf8: e1a00006 mov r0, r6 1cdfc: e2811001 add r1, r1, #1 1ce00: e58dc000 str ip, [sp] 1ce04: ebffce25 bl 106a0 <rtems_rfs_group_open>
rtems_rfs_fs_block (fs, group, 0),
fs->group_blocks,
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
1ce08: e2508000 subs r8, r0, #0
1ce0c: daffffef ble 1cdd0 <rtems_rfs_fs_open+0x558>
{
int g;
for (g = 0; g < group; g++)
1ce10: e3550000 cmp r5, #0 <== NOT EXECUTED 1ce14: 0a000009 beq 1ce40 <rtems_rfs_fs_open+0x5c8> <== NOT EXECUTED 1ce18: e3a07000 mov r7, #0 <== NOT EXECUTED 1ce1c: e1a0a007 mov sl, r7 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
1ce20: e5961020 ldr r1, [r6, #32] <== NOT EXECUTED 1ce24: e1a00006 mov r0, r6 <== NOT EXECUTED 1ce28: e0811007 add r1, r1, r7 <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
1ce2c: e28aa001 add sl, sl, #1 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
1ce30: ebffce9d bl 108ac <rtems_rfs_group_close> <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
1ce34: e15a0005 cmp sl, r5 <== NOT EXECUTED 1ce38: e2877050 add r7, r7, #80 ; 0x50 <== NOT EXECUTED 1ce3c: 1afffff7 bne 1ce20 <rtems_rfs_fs_open+0x5a8> <== 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);
1ce40: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 1ce44: e1a00006 mov r0, r6 <== NOT EXECUTED 1ce48: ebfff3ac bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
1ce4c: 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))
1ce50: e3a00001 mov r0, #1 <== NOT EXECUTED 1ce54: e3a01000 mov r1, #0 <== NOT EXECUTED 1ce58: e5cd302c strb r3, [sp, #44] ; 0x2c <== NOT EXECUTED
handle->bnum = 0;
1ce5c: e58d3030 str r3, [sp, #48] ; 0x30 <== NOT EXECUTED
handle->buffer = NULL;
1ce60: e58d3034 str r3, [sp, #52] ; 0x34 <== NOT EXECUTED 1ce64: ebffd671 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1ce68: e3500000 cmp r0, #0 <== NOT EXECUTED 1ce6c: 0afffeca beq 1c99c <rtems_rfs_fs_open+0x124> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
1ce70: e1a00008 mov r0, r8 <== NOT EXECUTED 1ce74: eb001238 bl 2175c <strerror> <== NOT EXECUTED 1ce78: e1a01008 mov r1, r8 <== NOT EXECUTED 1ce7c: e1a02000 mov r2, r0 <== NOT EXECUTED 1ce80: e59f01b8 ldr r0, [pc, #440] ; 1d040 <rtems_rfs_fs_open+0x7c8><== NOT EXECUTED 1ce84: eb000d86 bl 204a4 <printf> <== NOT EXECUTED 1ce88: eafffec3 b 1c99c <rtems_rfs_fs_open+0x124> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
1ce8c: e3a01001 mov r1, #1 1ce90: e5940000 ldr r0, [r4] 1ce94: e28d2004 add r2, sp, #4 1ce98: e1a03001 mov r3, r1 1ce9c: ebffd009 bl 10ec8 <rtems_rfs_inode_open>
if (rc > 0)
1cea0: e2505000 subs r5, r0, #0
1cea4: ca000039 bgt 1cf90 <rtems_rfs_fs_open+0x718>
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
1cea8: e5940000 ldr r0, [r4] 1ceac: e5903000 ldr r3, [r0] 1ceb0: e3130004 tst r3, #4
1ceb4: 1a000009 bne 1cee0 <rtems_rfs_fs_open+0x668>
* @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);
1ceb8: e59d3010 ldr r3, [sp, #16] 1cebc: e5d32002 ldrb r2, [r3, #2] 1cec0: e5d33003 ldrb r3, [r3, #3] 1cec4: e1833402 orr r3, r3, r2, lsl #8
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
1cec8: e59f2174 ldr r2, [pc, #372] ; 1d044 <rtems_rfs_fs_open+0x7cc> 1cecc: e1530002 cmp r3, r2
1ced0: 0a00001d beq 1cf4c <rtems_rfs_fs_open+0x6d4>
1ced4: e2033a0f and r3, r3, #61440 ; 0xf000 1ced8: e3530901 cmp r3, #16384 ; 0x4000
1cedc: 1a00001a bne 1cf4c <rtems_rfs_fs_open+0x6d4>
errno = EIO;
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
1cee0: e28d1004 add r1, sp, #4 1cee4: ebffd071 bl 110b0 <rtems_rfs_inode_close>
if (rc > 0)
1cee8: e2505000 subs r5, r0, #0
1ceec: ca000003 bgt 1cf00 <rtems_rfs_fs_open+0x688>
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
return -1;
}
errno = 0;
1cef0: eb0009a7 bl 1f594 <__errno> 1cef4: e3a03000 mov r3, #0 1cef8: e5803000 str r3, [r0]
return 0;
1cefc: eafffeb2 b 1c9cc <rtems_rfs_fs_open+0x154>
}
rc = rtems_rfs_inode_close (*fs, &inode);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
1cf00: e5940000 ldr r0, [r4] <== NOT EXECUTED 1cf04: ebfff583 bl 1a518 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
1cf08: e5940000 ldr r0, [r4] <== NOT EXECUTED 1cf0c: ebffa8c9 bl 7238 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1cf10: e3a00001 mov r0, #1 <== NOT EXECUTED 1cf14: e3a01000 mov r1, #0 <== NOT EXECUTED 1cf18: ebffd644 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1cf1c: e3500000 cmp r0, #0 <== NOT EXECUTED 1cf20: 0a000005 beq 1cf3c <rtems_rfs_fs_open+0x6c4> <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
1cf24: e1a00005 mov r0, r5 <== NOT EXECUTED 1cf28: eb00120b bl 2175c <strerror> <== NOT EXECUTED 1cf2c: e1a01005 mov r1, r5 <== NOT EXECUTED 1cf30: e1a02000 mov r2, r0 <== NOT EXECUTED 1cf34: e59f010c ldr r0, [pc, #268] ; 1d048 <rtems_rfs_fs_open+0x7d0><== NOT EXECUTED 1cf38: eb000d59 bl 204a4 <printf> <== NOT EXECUTED
errno = rc;
1cf3c: eb000994 bl 1f594 <__errno> <== NOT EXECUTED
return -1;
1cf40: e3e03000 mvn r3, #0 <== NOT EXECUTED
{
rtems_rfs_buffer_close (*fs);
free (*fs);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
1cf44: e5805000 str r5, [r0] <== NOT EXECUTED
return -1;
1cf48: eafffe9f b 1c9cc <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
{
rtems_rfs_inode_close (*fs, &inode);
1cf4c: e28d1004 add r1, sp, #4 <== NOT EXECUTED 1cf50: ebffd056 bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
1cf54: e5940000 ldr r0, [r4] <== NOT EXECUTED 1cf58: ebfff56e bl 1a518 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
1cf5c: e5940000 ldr r0, [r4] <== NOT EXECUTED 1cf60: ebffa8b4 bl 7238 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1cf64: e3a00001 mov r0, #1 <== NOT EXECUTED 1cf68: e3a01000 mov r1, #0 <== NOT EXECUTED 1cf6c: ebffd62f bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1cf70: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
1cf74: 159f00d0 ldrne r0, [pc, #208] ; 1d04c <rtems_rfs_fs_open+0x7d4><== NOT EXECUTED 1cf78: 1b000de1 blne 20704 <puts> <== NOT EXECUTED
errno = EIO;
1cf7c: eb000984 bl 1f594 <__errno> <== NOT EXECUTED 1cf80: e3a03005 mov r3, #5 <== NOT EXECUTED 1cf84: e5803000 str r3, [r0] <== NOT EXECUTED
return -1;
1cf88: e3e03000 mvn r3, #0 <== NOT EXECUTED 1cf8c: eafffe8e b 1c9cc <rtems_rfs_fs_open+0x154> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
1cf90: e5940000 ldr r0, [r4] <== NOT EXECUTED 1cf94: ebfff55f bl 1a518 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
1cf98: e5940000 ldr r0, [r4] <== NOT EXECUTED 1cf9c: ebffa8a5 bl 7238 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1cfa0: e3a00001 mov r0, #1 <== NOT EXECUTED 1cfa4: e3a01000 mov r1, #0 <== NOT EXECUTED 1cfa8: ebffd620 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1cfac: e3500000 cmp r0, #0 <== NOT EXECUTED 1cfb0: 0affffe1 beq 1cf3c <rtems_rfs_fs_open+0x6c4> <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
1cfb4: e1a00005 mov r0, r5 <== NOT EXECUTED 1cfb8: eb0011e7 bl 2175c <strerror> <== NOT EXECUTED 1cfbc: e1a01005 mov r1, r5 <== NOT EXECUTED 1cfc0: e1a02000 mov r2, r0 <== NOT EXECUTED 1cfc4: e59f0084 ldr r0, [pc, #132] ; 1d050 <rtems_rfs_fs_open+0x7d8><== NOT EXECUTED 1cfc8: eb000d35 bl 204a4 <printf> <== NOT EXECUTED 1cfcc: eaffffda b 1cf3c <rtems_rfs_fs_open+0x6c4> <== 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);
1cfd0: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 1cfd4: e1a00006 mov r0, r6 <== NOT EXECUTED 1cfd8: ebfff348 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
if (!fs->groups)
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1cfdc: e3a00001 mov r0, #1 <== NOT EXECUTED 1cfe0: e3a01000 mov r1, #0 <== NOT EXECUTED
handle->dirty = false;
1cfe4: e5cd802c strb r8, [sp, #44] ; 0x2c <== NOT EXECUTED
handle->bnum = 0;
1cfe8: e58d8030 str r8, [sp, #48] ; 0x30 <== NOT EXECUTED
handle->buffer = NULL;
1cfec: e58d8034 str r8, [sp, #52] ; 0x34 <== NOT EXECUTED 1cff0: ebffd60e bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1cff4: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
return ENOMEM;
1cff8: 03a0800c moveq r8, #12 <== NOT EXECUTED
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
if (!fs->groups)
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
1cffc: 0afffe66 beq 1c99c <rtems_rfs_fs_open+0x124> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
1d000: e59f004c ldr r0, [pc, #76] ; 1d054 <rtems_rfs_fs_open+0x7dc><== NOT EXECUTED 1d004: eb000dbe bl 20704 <puts> <== NOT EXECUTED
return ENOMEM;
1d008: e3a0800c mov r8, #12 <== NOT EXECUTED 1d00c: eafffe62 b 1c99c <rtems_rfs_fs_open+0x124> <== NOT EXECUTED
0001c854 <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);
1c854: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED
uint64_t block_size = rtems_rfs_fs_block_size (fs);
1c858: e5902008 ldr r2, [r0, #8] <== NOT EXECUTED
return blocks * block_size;
1c85c: e0810392 umull r0, r1, r2, r3 <== NOT EXECUTED
}
1c860: e12fff1e bx lr <== NOT EXECUTED
0001093c <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)
{
1093c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
10940: e21220ff ands r2, r2, #255 ; 0xff
int
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
bool inode,
rtems_rfs_bitmap_bit* result)
{
10944: e24dd018 sub sp, sp, #24 10948: e58d300c str r3, [sp, #12]
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
1094c: e58d2008 str r2, [sp, #8]
{
size = fs->group_inodes;
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
10950: 05903028 ldreq r3, [r0, #40] ; 0x28
bool updown;
int direction;
if (inode)
{
size = fs->group_inodes;
10954: 1590202c ldrne r2, [r0, #44] ; 0x2c
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
10958: 058d3000 streq r3, [sp]
bool updown;
int direction;
if (inode)
{
size = fs->group_inodes;
1095c: 158d2000 strne r2, [sp]
int
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
bool inode,
rtems_rfs_bitmap_bit* result)
{
10960: e1a04001 mov r4, r1
int direction;
if (inode)
{
size = fs->group_inodes;
goal -= RTEMS_RFS_ROOT_INO;
10964: 12414001 subne r4, 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)
{
10968: e1a07000 mov r7, r0
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
1096c: e59d1000 ldr r1, [sp] 10970: e1a00004 mov r0, r4 10974: ebffc44b bl 1aa8 <__aeabi_uidiv>
bit = (rtems_rfs_bitmap_bit) (goal % size);
10978: e59d1000 ldr r1, [sp]
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
1097c: e1a0a000 mov sl, r0
bit = (rtems_rfs_bitmap_bit) (goal % size);
10980: e1a00004 mov r0, r4 10984: eb00719b bl 2cff8 <__umodsi3>
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
10988: e28d9018 add r9, sp, #24 1098c: e3a03000 mov r3, #0
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
updown = true;
direction = 1;
10990: e3a05001 mov r5, #1
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
10994: e58d0010 str r0, [sp, #16]
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
10998: e5693001 strb r3, [r9, #-1]!
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
1099c: e1a06003 mov r6, r3
/*
* 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);
109a0: e1a0400a mov r4, sl
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
updown = true;
109a4: e1a08005 mov r8, r5
/*
* 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))
109a8: e3540000 cmp r4, #0
109ac: ba000027 blt 10a50 <rtems_rfs_group_bitmap_alloc+0x114>
109b0: e5973024 ldr r3, [r7, #36] ; 0x24 109b4: e1530004 cmp r3, r4
109b8: da000024 ble 10a50 <rtems_rfs_group_bitmap_alloc+0x114>
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
109bc: e59d2008 ldr r2, [sp, #8]
bitmap = &fs->groups[group].inode_bitmap;
109c0: e1a03104 lsl r3, r4, #2 109c4: e58d3004 str r3, [sp, #4]
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
109c8: e3520000 cmp r2, #0
bitmap = &fs->groups[group].inode_bitmap;
109cc: e59d2004 ldr r2, [sp, #4] 109d0: e5973020 ldr r3, [r7, #32] 109d4: e082b004 add fp, r2, r4 109d8: e083b20b add fp, r3, fp, lsl #4 109dc: 128bb02c addne fp, fp, #44 ; 0x2c
else
bitmap = &fs->groups[group].block_bitmap;
109e0: 028bb008 addeq fp, fp, #8
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
109e4: e1a0000b mov r0, fp 109e8: e59d1010 ldr r1, [sp, #16] 109ec: e1a02009 mov r2, r9 109f0: e28d3010 add r3, sp, #16 109f4: eb001fe7 bl 18998 <rtems_rfs_bitmap_map_alloc>
if (rc > 0)
109f8: e3500000 cmp r0, #0
109fc: ca00003a bgt 10aec <rtems_rfs_group_bitmap_alloc+0x1b0>
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
10a00: e5973000 ldr r3, [r7] 10a04: e3130001 tst r3, #1
10a08: 0a000043 beq 10b1c <rtems_rfs_group_bitmap_alloc+0x1e0>
rtems_rfs_bitmap_release_buffer (fs, bitmap);
if (allocated)
10a0c: e5dd3017 ldrb r3, [sp, #23] 10a10: e3530000 cmp r3, #0
10a14: 1a00001a bne 10a84 <rtems_rfs_group_bitmap_alloc+0x148>
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
inode ? "inode" : "block", *result);
return 0;
}
if (updown)
10a18: e3580000 cmp r8, #0
10a1c: 0a000002 beq 10a2c <rtems_rfs_group_bitmap_alloc+0xf0>
direction = direction > 0 ? -1 : 1;
10a20: e3550001 cmp r5, #1 10a24: 13a05001 movne r5, #1 10a28: 03e05000 mvneq r5, #0
offset++;
10a2c: e2866001 add r6, r6, #1
/*
* 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);
10a30: e024a596 mla r4, r6, r5, sl
if (offset)
bit = direction > 0 ? 0 : size - 1;
10a34: e3550001 cmp r5, #1 10a38: 159d2000 ldrne r2, [sp] 10a3c: 03a03000 moveq r3, #0 10a40: 12423001 subne r3, r2, #1
/*
* 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))
10a44: e3540000 cmp r4, #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)
bit = direction > 0 ? 0 : size - 1;
10a48: e58d3010 str r3, [sp, #16]
/*
* 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))
10a4c: aaffffd7 bge 109b0 <rtems_rfs_group_bitmap_alloc+0x74>
{
if (!updown)
10a50: e3580000 cmp r8, #0
10a54: 0a000026 beq 10af4 <rtems_rfs_group_bitmap_alloc+0x1b8>
break;
direction = direction > 0 ? -1 : 1;
10a58: e3550001 cmp r5, #1 10a5c: 03e05000 mvneq r5, #0 10a60: 13a05001 movne r5, #1
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
10a64: e3a03000 mov r3, #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)
10a68: e3560000 cmp r6, #0
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
10a6c: e5cd3017 strb r3, [sp, #23]
/*
* 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);
10a70: e024a596 mla r4, r6, r5, sl
if (offset)
10a74: 01a08006 moveq r8, r6
10a78: 0affffca beq 109a8 <rtems_rfs_group_bitmap_alloc+0x6c>
10a7c: e3a08000 mov r8, #0 10a80: eaffffeb b 10a34 <rtems_rfs_group_bitmap_alloc+0xf8>
if (rtems_rfs_fs_release_bitmaps (fs))
rtems_rfs_bitmap_release_buffer (fs, bitmap);
if (allocated)
{
if (inode)
10a84: e59d3008 ldr r3, [sp, #8] 10a88: e3530000 cmp r3, #0
10a8c: 1a000026 bne 10b2c <rtems_rfs_group_bitmap_alloc+0x1f0>
*result = rtems_rfs_group_inode (fs, group, bit);
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
10a90: e59d2004 ldr r2, [sp, #4] 10a94: e5973020 ldr r3, [r7, #32] 10a98: e0824004 add r4, r2, r4 10a9c: e7933204 ldr r3, [r3, r4, lsl #4] 10aa0: e59d2010 ldr r2, [sp, #16] 10aa4: e0823003 add r3, r2, r3 10aa8: e59d200c ldr r2, [sp, #12] 10aac: e5823000 str r3, [r2]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
10ab0: e3a00802 mov r0, #131072 ; 0x20000 10ab4: e3a01000 mov r1, #0 10ab8: eb00075c bl 12830 <rtems_rfs_trace> 10abc: e3500000 cmp r0, #0
10ac0: 0a000009 beq 10aec <rtems_rfs_group_bitmap_alloc+0x1b0>
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
10ac4: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 10ac8: e59f3078 ldr r3, [pc, #120] ; 10b48 <rtems_rfs_group_bitmap_alloc+0x20c><== NOT EXECUTED 10acc: e3520000 cmp r2, #0 <== NOT EXECUTED 10ad0: e59f1074 ldr r1, [pc, #116] ; 10b4c <rtems_rfs_group_bitmap_alloc+0x210><== NOT EXECUTED 10ad4: 11a01003 movne r1, r3 <== NOT EXECUTED 10ad8: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 10adc: e59f006c ldr r0, [pc, #108] ; 10b50 <rtems_rfs_group_bitmap_alloc+0x214><== NOT EXECUTED 10ae0: e5932000 ldr r2, [r3] <== NOT EXECUTED 10ae4: eb003e6e bl 204a4 <printf> <== NOT EXECUTED
inode ? "inode" : "block", *result);
return 0;
10ae8: e3a00000 mov r0, #0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
}
10aec: e28dd018 add sp, sp, #24
10af0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
direction = direction > 0 ? -1 : 1;
offset++;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
10af4: e3a00802 mov r0, #131072 ; 0x20000 10af8: e3a01000 mov r1, #0 10afc: eb00074b bl 12830 <rtems_rfs_trace> 10b00: e3500000 cmp r0, #0
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
10b04: 03a0001c moveq r0, #28
direction = direction > 0 ? -1 : 1;
offset++;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
10b08: 0afffff7 beq 10aec <rtems_rfs_group_bitmap_alloc+0x1b0>
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
10b0c: e59f0040 ldr r0, [pc, #64] ; 10b54 <rtems_rfs_group_bitmap_alloc+0x218><== NOT EXECUTED 10b10: eb003efb bl 20704 <puts> <== NOT EXECUTED
return ENOSPC;
10b14: e3a0001c mov r0, #28 <== NOT EXECUTED 10b18: eafffff3 b 10aec <rtems_rfs_group_bitmap_alloc+0x1b0> <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
if (rc > 0)
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
rtems_rfs_bitmap_release_buffer (fs, bitmap);
10b1c: e1a00007 mov r0, r7 10b20: e59b1000 ldr r1, [fp] 10b24: eb002475 bl 19d00 <rtems_rfs_buffer_handle_release> 10b28: eaffffb7 b 10a0c <rtems_rfs_group_bitmap_alloc+0xd0>
if (allocated)
{
if (inode)
*result = rtems_rfs_group_inode (fs, group, bit);
10b2c: e59d3010 ldr r3, [sp, #16] 10b30: e597202c ldr r2, [r7, #44] ; 0x2c 10b34: e2833001 add r3, r3, #1 10b38: e0243492 mla r4, r2, r4, r3 10b3c: e59d200c ldr r2, [sp, #12] 10b40: e5824000 str r4, [r2] 10b44: eaffffd9 b 10ab0 <rtems_rfs_group_bitmap_alloc+0x174>
00010b58 <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
10b58: e92d40f0 push {r4, r5, r6, r7, lr}
10b5c: e1a06001 mov r6, r1
10b60: e1a04000 mov r4, r0
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
10b64: e3a01000 mov r1, #0 10b68: e3a00802 mov r0, #131072 ; 0x20000
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
10b6c: e1a05002 mov r5, r2
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
10b70: eb00072e bl 12830 <rtems_rfs_trace> 10b74: e3500000 cmp r0, #0
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
10b78: e20660ff and r6, r6, #255 ; 0xff
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
10b7c: 0a000006 beq 10b9c <rtems_rfs_group_bitmap_free+0x44>
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
10b80: e59f30ac ldr r3, [pc, #172] ; 10c34 <rtems_rfs_group_bitmap_free+0xdc><== NOT EXECUTED 10b84: e3560000 cmp r6, #0 <== NOT EXECUTED 10b88: e59f10a8 ldr r1, [pc, #168] ; 10c38 <rtems_rfs_group_bitmap_free+0xe0><== NOT EXECUTED 10b8c: e59f00a8 ldr r0, [pc, #168] ; 10c3c <rtems_rfs_group_bitmap_free+0xe4><== NOT EXECUTED 10b90: 11a01003 movne r1, r3 <== NOT EXECUTED 10b94: e1a02005 mov r2, r5 <== NOT EXECUTED 10b98: eb003e41 bl 204a4 <printf> <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
10b9c: e3560000 cmp r6, #0
10ba0: 0a000015 beq 10bfc <rtems_rfs_group_bitmap_free+0xa4>
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
10ba4: e594702c ldr r7, [r4, #44] ; 0x2c
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
inode ? "inode" : "block", no);
if (inode)
{
no -= RTEMS_RFS_ROOT_INO;
10ba8: e2455001 sub r5, r5, #1
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
10bac: e1a00005 mov r0, r5 10bb0: e1a01007 mov r1, r7 10bb4: eb00710f bl 2cff8 <__umodsi3>
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
10bb8: e1a01007 mov r1, r7
bit = (rtems_rfs_bitmap_bit) (no % size);
10bbc: e1a06000 mov r6, r0
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
10bc0: e1a00005 mov r0, r5 10bc4: ebffc3b7 bl 1aa8 <__aeabi_uidiv>
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
10bc8: e5943020 ldr r3, [r4, #32] 10bcc: e0800100 add r0, r0, r0, lsl #2 10bd0: e0835200 add r5, r3, r0, lsl #4 10bd4: e285502c add r5, r5, #44 ; 0x2c
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
10bd8: e1a01006 mov r1, r6 10bdc: e1a00005 mov r0, r5 10be0: eb001edd bl 1875c <rtems_rfs_bitmap_map_clear>
rtems_rfs_bitmap_release_buffer (fs, bitmap);
10be4: 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);
10be8: e1a06000 mov r6, r0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
10bec: e1a00004 mov r0, r4 10bf0: eb002442 bl 19d00 <rtems_rfs_buffer_handle_release>
return rc;
}
10bf4: e1a00006 mov r0, r6
10bf8: e8bd80f0 pop {r4, r5, r6, r7, pc}
size = fs->group_inodes;
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
10bfc: e5947028 ldr r7, [r4, #40] ; 0x28
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
10c00: e2455001 sub r5, r5, #1
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
10c04: e1a00005 mov r0, r5 10c08: e1a01007 mov r1, r7 10c0c: eb0070f9 bl 2cff8 <__umodsi3>
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
10c10: e1a01007 mov r1, r7
bit = (rtems_rfs_bitmap_bit) (no % size);
10c14: e1a06000 mov r6, r0
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
10c18: e1a00005 mov r0, r5 10c1c: ebffc3a1 bl 1aa8 <__aeabi_uidiv>
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
10c20: e5943020 ldr r3, [r4, #32] 10c24: e0800100 add r0, r0, r0, lsl #2 10c28: e0835200 add r5, r3, r0, lsl #4 10c2c: e2855008 add r5, r5, #8 10c30: eaffffe8 b 10bd8 <rtems_rfs_group_bitmap_free+0x80>
00010c40 <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)
{
10c40: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
10c44: e1a06001 mov r6, r1 <== NOT EXECUTED
10c48: e1a05000 mov r5, r0 <== NOT EXECUTED
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
10c4c: e3a01000 mov r1, #0 <== NOT EXECUTED 10c50: e3a00802 mov r0, #131072 ; 0x20000 <== NOT EXECUTED
int
rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no,
bool* state)
{
10c54: e1a04002 mov r4, r2 <== NOT EXECUTED 10c58: 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))
10c5c: eb0006f3 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 10c60: e3500000 cmp r0, #0 <== NOT EXECUTED
int
rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no,
bool* state)
{
10c64: e20660ff and r6, r6, #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))
10c68: 0a000006 beq 10c88 <rtems_rfs_group_bitmap_test+0x48> <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
10c6c: e59f30d8 ldr r3, [pc, #216] ; 10d4c <rtems_rfs_group_bitmap_test+0x10c><== NOT EXECUTED 10c70: e3560000 cmp r6, #0 <== NOT EXECUTED 10c74: e59f10d4 ldr r1, [pc, #212] ; 10d50 <rtems_rfs_group_bitmap_test+0x110><== NOT EXECUTED 10c78: e59f00d4 ldr r0, [pc, #212] ; 10d54 <rtems_rfs_group_bitmap_test+0x114><== NOT EXECUTED 10c7c: 11a01003 movne r1, r3 <== NOT EXECUTED 10c80: e1a02004 mov r2, r4 <== NOT EXECUTED 10c84: eb003e06 bl 204a4 <printf> <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
10c88: e3560000 cmp r6, #0 <== NOT EXECUTED 10c8c: 0a000007 beq 10cb0 <rtems_rfs_group_bitmap_test+0x70> <== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
10c90: e3540000 cmp r4, #0 <== NOT EXECUTED 10c94: da000002 ble 10ca4 <rtems_rfs_group_bitmap_test+0x64> <== NOT EXECUTED 10c98: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED 10c9c: e1540003 cmp r4, r3 <== NOT EXECUTED 10ca0: 9a00001b bls 10d14 <rtems_rfs_group_bitmap_test+0xd4> <== NOT EXECUTED
size = fs->group_inodes;
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
10ca4: e3a06016 mov r6, #22 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
rtems_rfs_bitmap_release_buffer (fs, bitmap);
return rc;
}
10ca8: e1a00006 mov r0, r6 <== NOT EXECUTED
10cac: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
10cb0: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED 10cb4: e1540003 cmp r4, r3 <== NOT EXECUTED 10cb8: 2afffff9 bcs 10ca4 <rtems_rfs_group_bitmap_test+0x64> <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
10cbc: e5958028 ldr r8, [r5, #40] ; 0x28 <== NOT EXECUTED
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
10cc0: e1a00004 mov r0, r4 <== NOT EXECUTED 10cc4: e1a01008 mov r1, r8 <== NOT EXECUTED 10cc8: eb0070ca bl 2cff8 <__umodsi3> <== NOT EXECUTED
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
10ccc: e1a01008 mov r1, r8 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
10cd0: e1a06000 mov r6, r0 <== NOT EXECUTED
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
10cd4: e1a00004 mov r0, r4 <== NOT EXECUTED 10cd8: ebffc372 bl 1aa8 <__aeabi_uidiv> <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
10cdc: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED 10ce0: e0800100 add r0, r0, r0, lsl #2 <== NOT EXECUTED 10ce4: e0834200 add r4, r3, r0, lsl #4 <== NOT EXECUTED 10ce8: e2844008 add r4, r4, #8 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
10cec: e1a01006 mov r1, r6 <== NOT EXECUTED 10cf0: e1a02007 mov r2, r7 <== NOT EXECUTED 10cf4: e1a00004 mov r0, r4 <== NOT EXECUTED 10cf8: eb001eb9 bl 187e4 <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
10cfc: 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);
10d00: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
10d04: e1a00005 mov r0, r5 <== NOT EXECUTED 10d08: eb0023fc bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
return rc;
}
10d0c: e1a00006 mov r0, r6 <== NOT EXECUTED
10d10: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
if (inode)
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
10d14: e595802c ldr r8, [r5, #44] ; 0x2c <== NOT EXECUTED
if (inode)
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
10d18: e2444001 sub r4, r4, #1 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
10d1c: e1a00004 mov r0, r4 <== NOT EXECUTED 10d20: e1a01008 mov r1, r8 <== NOT EXECUTED 10d24: eb0070b3 bl 2cff8 <__umodsi3> <== NOT EXECUTED
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
10d28: e1a01008 mov r1, r8 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
10d2c: e1a06000 mov r6, r0 <== NOT EXECUTED
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
10d30: e1a00004 mov r0, r4 <== NOT EXECUTED 10d34: ebffc35b bl 1aa8 <__aeabi_uidiv> <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
10d38: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED 10d3c: e0800100 add r0, r0, r0, lsl #2 <== NOT EXECUTED 10d40: e0834200 add r4, r3, r0, lsl #4 <== NOT EXECUTED 10d44: e284402c add r4, r4, #44 ; 0x2c <== NOT EXECUTED 10d48: eaffffe7 b 10cec <rtems_rfs_group_bitmap_test+0xac> <== NOT EXECUTED
000108ac <rtems_rfs_group_close>:
return 0;
}
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
108ac: e92d40f0 push {r4, r5, r6, r7, lr}
108b0: e1a05000 mov r5, r0
108b4: e1a04001 mov r4, r1
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
108b8: e3a00801 mov r0, #65536 ; 0x10000 108bc: e3a01000 mov r1, #0 108c0: eb0007da bl 12830 <rtems_rfs_trace> 108c4: e3500000 cmp r0, #0
108c8: 1a000016 bne 10928 <rtems_rfs_group_close+0x7c> /* * We need to close as much as possible and also return any error if one * occurs but this may result in one even more important error being lost but * we cannot OR the errors together so this is a reasonable compromise. */ rc = rtems_rfs_bitmap_close (&group->inode_bitmap);
108cc: e284002c add r0, r4, #44 ; 0x2c 108d0: eb0020a9 bl 18b7c <rtems_rfs_bitmap_close>
*/
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);
108d4: e2841044 add r1, r4, #68 ; 0x44 108d8: e1a07000 mov r7, r0 108dc: e1a00005 mov r0, r5 108e0: eb002506 bl 19d00 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
108e4: e3a03000 mov r3, #0 108e8: e5c43044 strb r3, [r4, #68] ; 0x44
handle->bnum = 0;
108ec: e5843048 str r3, [r4, #72] ; 0x48
handle->buffer = NULL;
108f0: e584304c str r3, [r4, #76] ; 0x4c
if (rc > 0)
result = rc;
rc = rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
if (rc > 0)
result = rc;
rc = rtems_rfs_bitmap_close (&group->block_bitmap);
108f4: e2840008 add r0, r4, #8 108f8: eb00209f bl 18b7c <rtems_rfs_bitmap_close>
*/
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);
108fc: e2841020 add r1, r4, #32
if (rc > 0)
10900: e2506000 subs r6, r0, #0 10904: e1a00005 mov r0, r5 10908: d1c76fc7 bicle r6, r7, r7, asr #31 1090c: eb0024fb bl 19d00 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
10910: e3a03000 mov r3, #0 10914: e5c43020 strb r3, [r4, #32]
handle->bnum = 0;
10918: e5843024 str r3, [r4, #36] ; 0x24
handle->buffer = NULL;
1091c: e5843028 str r3, [r4, #40] ; 0x28
rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rc > 0)
result = rc;
return result;
}
10920: e1a00006 mov r0, r6
10924: e8bd80f0 pop {r4, r5, r6, r7, pc}
{
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
10928: e5941000 ldr r1, [r4] <== NOT EXECUTED 1092c: e59f0004 ldr r0, [pc, #4] ; 10938 <rtems_rfs_group_close+0x8c><== NOT EXECUTED 10930: eb003edb bl 204a4 <printf> <== NOT EXECUTED 10934: eaffffe4 b 108cc <rtems_rfs_group_close+0x20> <== NOT EXECUTED
000106a0 <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)
{
106a0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
106a4: e1a08000 mov r8, r0
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
106a8: e5900004 ldr r0, [r0, #4]
rtems_rfs_group_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block base,
size_t size,
size_t inodes,
rtems_rfs_group* group)
{
106ac: e24dd004 sub sp, sp, #4
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
106b0: e1500001 cmp r0, r1
rtems_rfs_group_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block base,
size_t size,
size_t inodes,
rtems_rfs_group* group)
{
106b4: e1a06001 mov r6, r1 106b8: e1a07002 mov r7, r2 106bc: e59d4028 ldr r4, [sp, #40] ; 0x28
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
106c0: 9a000027 bls 10764 <rtems_rfs_group_open+0xc4>
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
106c4: e0822001 add r2, r2, r1 106c8: e1500002 cmp r0, r2
size = rtems_rfs_fs_blocks (fs) - base;
106cc: 90617000 rsbls r7, r1, r0
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
106d0: e3a00902 mov r0, #32768 ; 0x8000 106d4: e3a01000 mov r1, #0
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
size = rtems_rfs_fs_blocks (fs) - base;
106d8: e1570003 cmp r7, r3 106dc: 31a0b007 movcc fp, r7 106e0: 21a0b003 movcs fp, r3
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
106e4: eb000851 bl 12830 <rtems_rfs_trace> 106e8: e3500000 cmp r0, #0
106ec: 1a00002a bne 1079c <rtems_rfs_group_open+0xfc>
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
106f0: 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,
106f4: e2849008 add r9, r4, #8 106f8: 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;
106fc: e88400c0 stm r4, {r6, r7}
10700: e5c45020 strb r5, [r4, #32]
handle->bnum = 0;
10704: e5845024 str r5, [r4, #36] ; 0x24
handle->buffer = NULL;
10708: 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,
1070c: e1a00009 mov r0, r9 10710: e1a01008 mov r1, r8 10714: e1a0200a mov r2, sl 10718: e1a03007 mov r3, r7 1071c: e58d6000 str r6, [sp] 10720: eb002101 bl 18b2c <rtems_rfs_bitmap_open>
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
10724: e2506000 subs r6, r0, #0
10728: da000028 ble 107d0 <rtems_rfs_group_open+0x130>
*/
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);
1072c: e1a0100a mov r1, sl <== NOT EXECUTED 10730: e1a00008 mov r0, r8 <== NOT EXECUTED 10734: eb002571 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
10738: e5c45020 strb r5, [r4, #32] <== NOT EXECUTED
handle->bnum = 0;
1073c: e5845024 str r5, [r4, #36] ; 0x24 <== NOT EXECUTED
handle->buffer = NULL;
10740: 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))
10744: e3a00902 mov r0, #32768 ; 0x8000 <== NOT EXECUTED 10748: e3a01000 mov r1, #0 <== NOT EXECUTED 1074c: eb000837 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 10750: e1500005 cmp r0, r5 <== NOT EXECUTED 10754: 1a000016 bne 107b4 <rtems_rfs_group_open+0x114> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
}
10758: e1a00006 mov r0, r6
1075c: e28dd004 add sp, sp, #4
10760: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
10764: e3a00902 mov r0, #32768 ; 0x8000 <== NOT EXECUTED 10768: e3a01000 mov r1, #0 <== NOT EXECUTED 1076c: eb00082f bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 10770: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
EIO, strerror (EIO));
return EIO;
10774: 03a06005 moveq r6, #5 <== NOT EXECUTED
{
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
10778: 0afffff6 beq 10758 <rtems_rfs_group_open+0xb8> <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
1077c: e3a00005 mov r0, #5 <== NOT EXECUTED 10780: eb0043f5 bl 2175c <strerror> <== NOT EXECUTED 10784: e3a01005 mov r1, #5 <== NOT EXECUTED 10788: e1a02000 mov r2, r0 <== NOT EXECUTED 1078c: e59f0108 ldr r0, [pc, #264] ; 1089c <rtems_rfs_group_open+0x1fc><== NOT EXECUTED 10790: eb003f43 bl 204a4 <printf> <== NOT EXECUTED
EIO, strerror (EIO));
return EIO;
10794: e3a06005 mov r6, #5 <== NOT EXECUTED 10798: eaffffee b 10758 <rtems_rfs_group_open+0xb8> <== NOT EXECUTED
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
1079c: e1a01006 mov r1, r6 <== NOT EXECUTED 107a0: e1a02007 mov r2, r7 <== NOT EXECUTED 107a4: e1a0300b mov r3, fp <== NOT EXECUTED 107a8: e59f00f0 ldr r0, [pc, #240] ; 108a0 <rtems_rfs_group_open+0x200><== NOT EXECUTED 107ac: eb003f3c bl 204a4 <printf> <== NOT EXECUTED 107b0: eaffffce b 106f0 <rtems_rfs_group_open+0x50> <== NOT EXECUTED
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
107b4: e1a00006 mov r0, r6 <== NOT EXECUTED 107b8: eb0043e7 bl 2175c <strerror> <== NOT EXECUTED 107bc: e1a01006 mov r1, r6 <== NOT EXECUTED 107c0: e1a02000 mov r2, r0 <== NOT EXECUTED 107c4: e59f00d8 ldr r0, [pc, #216] ; 108a4 <rtems_rfs_group_open+0x204><== NOT EXECUTED 107c8: eb003f35 bl 204a4 <printf> <== NOT EXECUTED 107cc: eaffffe1 b 10758 <rtems_rfs_group_open+0xb8> <== 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,
107d0: e594c000 ldr ip, [r4] 107d4: e2847044 add r7, r4, #68 ; 0x44 107d8: e28cc001 add ip, ip, #1
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
107dc: e5c45044 strb r5, [r4, #68] ; 0x44
handle->bnum = 0;
107e0: e5845048 str r5, [r4, #72] ; 0x48
handle->buffer = NULL;
107e4: e584504c str r5, [r4, #76] ; 0x4c 107e8: e284002c add r0, r4, #44 ; 0x2c 107ec: e1a01008 mov r1, r8 107f0: e1a02007 mov r2, r7 107f4: e1a0300b mov r3, fp 107f8: e58dc000 str ip, [sp] 107fc: eb0020ca bl 18b2c <rtems_rfs_bitmap_open>
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
10800: e2506000 subs r6, r0, #0
10804: da000019 ble 10870 <rtems_rfs_group_open+0x1d0>
*/
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);
10808: e1a01007 mov r1, r7 <== NOT EXECUTED 1080c: e1a00008 mov r0, r8 <== NOT EXECUTED 10810: eb00253a bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
10814: e5c45044 strb r5, [r4, #68] ; 0x44 <== NOT EXECUTED
handle->bnum = 0;
10818: e5845048 str r5, [r4, #72] ; 0x48 <== NOT EXECUTED
handle->buffer = NULL;
1081c: 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);
10820: e1a00009 mov r0, r9 <== NOT EXECUTED 10824: eb0020d4 bl 18b7c <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);
10828: e1a0100a mov r1, sl <== NOT EXECUTED 1082c: e1a00008 mov r0, r8 <== NOT EXECUTED 10830: eb002532 bl 19d00 <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
10834: e5c45020 strb r5, [r4, #32] <== NOT EXECUTED
handle->bnum = 0;
10838: e5845024 str r5, [r4, #36] ; 0x24 <== NOT EXECUTED
handle->buffer = NULL;
1083c: 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))
10840: e3a00902 mov r0, #32768 ; 0x8000 <== NOT EXECUTED 10844: e3a01000 mov r1, #0 <== NOT EXECUTED 10848: eb0007f8 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1084c: e3500000 cmp r0, #0 <== NOT EXECUTED 10850: 0affffc0 beq 10758 <rtems_rfs_group_open+0xb8> <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
10854: e1a00006 mov r0, r6 <== NOT EXECUTED 10858: eb0043bf bl 2175c <strerror> <== NOT EXECUTED 1085c: e1a01006 mov r1, r6 <== NOT EXECUTED 10860: e1a02000 mov r2, r0 <== NOT EXECUTED 10864: e59f003c ldr r0, [pc, #60] ; 108a8 <rtems_rfs_group_open+0x208><== NOT EXECUTED 10868: eb003f0d bl 204a4 <printf> <== NOT EXECUTED 1086c: eaffffb9 b 10758 <rtems_rfs_group_open+0xb8> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
10870: e5986000 ldr r6, [r8] 10874: e2166001 ands r6, r6, #1
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
10878: 11a06005 movne r6, 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))
1087c: 1affffb5 bne 10758 <rtems_rfs_group_open+0xb8>
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
10880: e5941008 ldr r1, [r4, #8] 10884: e1a00008 mov r0, r8 10888: eb00251c bl 19d00 <rtems_rfs_buffer_handle_release>
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
1088c: e1a00008 mov r0, r8 10890: e594102c ldr r1, [r4, #44] ; 0x2c 10894: eb002519 bl 19d00 <rtems_rfs_buffer_handle_release> 10898: eaffffae b 10758 <rtems_rfs_group_open+0xb8>
00010d58 <rtems_rfs_group_usage>:
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
10d58: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
10d5c: e3a0c000 mov ip, #0 <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
10d60: e153000c cmp r3, ip <== NOT EXECUTED
int
rtems_rfs_group_usage (rtems_rfs_file_system* fs,
size_t* blocks,
size_t* inodes)
{
10d64: e92d00f0 push {r4, r5, r6, r7} <== NOT EXECUTED
int g;
*blocks = 0;
10d68: e581c000 str ip, [r1] <== NOT EXECUTED
*inodes = 0;
10d6c: e582c000 str ip, [r2] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
10d70: da000010 ble 10db8 <rtems_rfs_group_usage+0x60> <== NOT EXECUTED 10d74: e5904020 ldr r4, [r0, #32] <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
10d78: e5947014 ldr r7, [r4, #20] <== NOT EXECUTED 10d7c: e5915000 ldr r5, [r1] <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
10d80: e5946018 ldr r6, [r4, #24] <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
10d84: e0875005 add r5, r7, r5 <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
10d88: e0665005 rsb r5, r6, r5 <== NOT EXECUTED 10d8c: e5815000 str r5, [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) -
10d90: e5947038 ldr r7, [r4, #56] ; 0x38 <== NOT EXECUTED 10d94: e5925000 ldr r5, [r2] <== 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 +=
10d98: e594603c ldr r6, [r4, #60] ; 0x3c <== NOT EXECUTED
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
10d9c: e0875005 add r5, r7, r5 <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
10da0: e28cc001 add ip, ip, #1 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
10da4: e0665005 rsb r5, r6, r5 <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
10da8: e15c0003 cmp ip, r3 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
10dac: e5825000 str r5, [r2] <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
10db0: e2844050 add r4, r4, #80 ; 0x50 <== NOT EXECUTED 10db4: 1affffef bne 10d78 <rtems_rfs_group_usage+0x20> <== NOT EXECUTED
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
rtems_rfs_bitmap_map_free (&group->inode_bitmap);
}
if (*blocks > rtems_rfs_fs_blocks (fs))
10db8: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED 10dbc: e591c000 ldr ip, [r1] <== NOT EXECUTED 10dc0: e15c0003 cmp ip, r3 <== NOT EXECUTED 10dc4: 9581c000 strls ip, [r1] <== NOT EXECUTED 10dc8: 85813000 strhi r3, [r1] <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
10dcc: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 10dd0: e5921000 ldr r1, [r2] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
10dd4: 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))
10dd8: e1510003 cmp r1, r3 <== NOT EXECUTED 10ddc: 95821000 strls r1, [r2] <== NOT EXECUTED 10de0: 85823000 strhi r3, [r2] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
10de4: e8bd00f0 pop {r4, r5, r6, r7} <== NOT EXECUTED
10de8: e12fff1e bx lr <== NOT EXECUTED
000110b0 <rtems_rfs_inode_close>:
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
110b0: e92d4030 push {r4, r5, lr}
110b4: e1a05000 mov r5, r0
110b8: e1a04001 mov r4, r1
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
110bc: e3a00702 mov r0, #524288 ; 0x80000 110c0: e3a01000 mov r1, #0 110c4: eb0005d9 bl 12830 <rtems_rfs_trace> 110c8: e3500000 cmp r0, #0
110cc: 1a000011 bne 11118 <rtems_rfs_inode_close+0x68>
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
rc = rtems_rfs_inode_unload (fs, handle, true);
110d0: e1a00005 mov r0, r5 110d4: e1a01004 mov r1, r4 110d8: e3a02001 mov r2, #1 110dc: ebffffb7 bl 10fc0 <rtems_rfs_inode_unload>
if ((rc == 0) && (handle->loads > 0))
110e0: e3500000 cmp r0, #0
110e4: 1a000008 bne 1110c <rtems_rfs_inode_close+0x5c>
110e8: e5943024 ldr r3, [r4, #36] ; 0x24 110ec: e3530000 cmp r3, #0
110f0: da000005 ble 1110c <rtems_rfs_inode_close+0x5c>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
110f4: e3a00702 mov r0, #524288 ; 0x80000 <== NOT EXECUTED 110f8: e3a01000 mov r1, #0 <== NOT EXECUTED 110fc: eb0005cb bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 11100: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
handle->loads);
rc = EIO;
11104: 03a00005 moveq r0, #5 <== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
if ((rc == 0) && (handle->loads > 0))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
11108: 1a000006 bne 11128 <rtems_rfs_inode_close+0x78> <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
handle->loads);
rc = EIO;
}
handle->ino = 0;
1110c: e3a03000 mov r3, #0 11110: e5843008 str r3, [r4, #8]
return rc; }
11114: e8bd8030 pop {r4, r5, pc}
rtems_rfs_inode_handle* handle)
{
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
11118: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED 1111c: e59f0020 ldr r0, [pc, #32] ; 11144 <rtems_rfs_inode_close+0x94><== NOT EXECUTED 11120: eb003cdf bl 204a4 <printf> <== NOT EXECUTED 11124: eaffffe9 b 110d0 <rtems_rfs_inode_close+0x20> <== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
if ((rc == 0) && (handle->loads > 0))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
11128: e5941024 ldr r1, [r4, #36] ; 0x24 <== NOT EXECUTED 1112c: e59f0014 ldr r0, [pc, #20] ; 11148 <rtems_rfs_inode_close+0x98><== NOT EXECUTED 11130: eb003cdb bl 204a4 <printf> <== NOT EXECUTED
handle->loads);
rc = EIO;
}
handle->ino = 0;
11134: e3a03000 mov r3, #0 <== NOT EXECUTED
if ((rc == 0) && (handle->loads > 0))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
handle->loads);
rc = EIO;
11138: e3a00005 mov r0, #5 <== NOT EXECUTED
}
handle->ino = 0;
1113c: e5843008 str r3, [r4, #8] <== NOT EXECUTED
return rc; }
11140: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00011450 <rtems_rfs_inode_create>:
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
11450: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
11454: e24dd060 sub sp, sp, #96 ; 0x60
11458: e1ddc8bc ldrh ip, [sp, #140] ; 0x8c
1145c: e58dc004 str ip, [sp, #4]
11460: e1ddc9b0 ldrh ip, [sp, #144] ; 0x90
11464: e1a0a000 mov sl, r0
11468: 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))
1146c: e3a00501 mov r0, #4194304 ; 0x400000 11470: e3a01000 mov r1, #0
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
11474: e1dd78b4 ldrh r7, [sp, #132] ; 0x84 11478: e1a05002 mov r5, r2 1147c: e1a04003 mov r4, r3 11480: e1ddb8b8 ldrh fp, [sp, #136] ; 0x88 11484: e58dc008 str ip, [sp, #8]
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
11488: eb0004e8 bl 12830 <rtems_rfs_trace> 1148c: e3500000 cmp r0, #0
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
11490: e2076a0f and r6, r7, #61440 ; 0xf000
{
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
11494: 0a00002a beq 11544 <rtems_rfs_inode_create+0xf4>
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
11498: e3560901 cmp r6, #16384 ; 0x4000 <== NOT EXECUTED
type = "dir";
1149c: 059f92d4 ldreq r9, [pc, #724] ; 11778 <rtems_rfs_inode_create+0x328><== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
114a0: 0a00000c beq 114d8 <rtems_rfs_inode_create+0x88> <== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
114a4: e3560a02 cmp r6, #8192 ; 0x2000 <== NOT EXECUTED
type = "char";
114a8: 059f92cc ldreq r9, [pc, #716] ; 1177c <rtems_rfs_inode_create+0x32c><== NOT EXECUTED
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
114ac: 0a000009 beq 114d8 <rtems_rfs_inode_create+0x88> <== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
114b0: e3560a06 cmp r6, #24576 ; 0x6000 <== NOT EXECUTED
type = "block";
114b4: 059f92c4 ldreq r9, [pc, #708] ; 11780 <rtems_rfs_inode_create+0x330><== 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))
114b8: 0a000006 beq 114d8 <rtems_rfs_inode_create+0x88> <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
114bc: e3560902 cmp r6, #32768 ; 0x8000 <== NOT EXECUTED
type = "file";
114c0: 059f92bc ldreq r9, [pc, #700] ; 11784 <rtems_rfs_inode_create+0x334><== 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))
114c4: 0a000003 beq 114d8 <rtems_rfs_inode_create+0x88> <== NOT EXECUTED
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
114c8: e59f32b8 ldr r3, [pc, #696] ; 11788 <rtems_rfs_inode_create+0x338><== NOT EXECUTED 114cc: e3560a0a cmp r6, #40960 ; 0xa000 <== NOT EXECUTED 114d0: e59f92b4 ldr r9, [pc, #692] ; 1178c <rtems_rfs_inode_create+0x33c><== NOT EXECUTED 114d4: 01a09003 moveq r9, r3 <== NOT EXECUTED
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
114d8: e59f02b0 ldr r0, [pc, #688] ; 11790 <rtems_rfs_inode_create+0x340><== NOT EXECUTED 114dc: e1a01008 mov r1, r8 <== NOT EXECUTED 114e0: eb003bef bl 204a4 <printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
114e4: e3540000 cmp r4, #0 <== NOT EXECUTED 114e8: 0a00000f beq 1152c <rtems_rfs_inode_create+0xdc> <== NOT EXECUTED 114ec: e3a02000 mov r2, #0 <== NOT EXECUTED 114f0: e58db00c str fp, [sp, #12] <== NOT EXECUTED 114f4: e1a0b007 mov fp, r7 <== NOT EXECUTED 114f8: e1a07006 mov r7, r6 <== NOT EXECUTED 114fc: e1a06004 mov r6, r4 <== NOT EXECUTED 11500: e1a04002 mov r4, r2 <== NOT EXECUTED
printf ("%c", name[c]);
11504: e7d50002 ldrb r0, [r5, r2] <== 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++)
11508: e2844001 add r4, r4, #1 <== NOT EXECUTED
printf ("%c", name[c]);
1150c: eb003c4e bl 2064c <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++)
11510: e1540006 cmp r4, r6 <== NOT EXECUTED 11514: e1a02004 mov r2, r4 <== NOT EXECUTED 11518: 1afffff9 bne 11504 <rtems_rfs_inode_create+0xb4> <== NOT EXECUTED 1151c: e1a04006 mov r4, r6 <== NOT EXECUTED 11520: e1a06007 mov r6, r7 <== NOT EXECUTED 11524: e1a0700b mov r7, fp <== NOT EXECUTED 11528: e59db00c ldr fp, [sp, #12] <== NOT EXECUTED
printf ("%c", name[c]);
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
1152c: e1a03b07 lsl r3, r7, #22 <== NOT EXECUTED 11530: e59f025c ldr r0, [pc, #604] ; 11794 <rtems_rfs_inode_create+0x344><== NOT EXECUTED 11534: e1a01009 mov r1, r9 <== NOT EXECUTED 11538: e1a02007 mov r2, r7 <== NOT EXECUTED 1153c: e1a03b23 lsr r3, r3, #22 <== NOT EXECUTED 11540: eb003bd7 bl 204a4 <printf> <== NOT EXECUTED
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
11544: e3560a06 cmp r6, #24576 ; 0x6000
11548: 0a00000c beq 11580 <rtems_rfs_inode_create+0x130> 1154c: da000007 ble 11570 <rtems_rfs_inode_create+0x120>
11550: e3560902 cmp r6, #32768 ; 0x8000
11554: 0a000009 beq 11580 <rtems_rfs_inode_create+0x130>
11558: e3560a0a cmp r6, #40960 ; 0xa000
1155c: 0a000007 beq 11580 <rtems_rfs_inode_create+0x130>
case RTEMS_RFS_S_IFBLK:
case RTEMS_RFS_S_IFREG:
case RTEMS_RFS_S_IFLNK:
break;
default:
return EINVAL;
11560: e3a09016 mov r9, #22 <== NOT EXECUTED
rtems_rfs_inode_free (fs, *ino);
return rc;
}
return 0;
}
11564: e1a00009 mov r0, r9
11568: e28dd060 add sp, sp, #96 ; 0x60
1156c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
11570: e3560a02 cmp r6, #8192 ; 0x2000
11574: 0a000001 beq 11580 <rtems_rfs_inode_create+0x130>
11578: e3560901 cmp r6, #16384 ; 0x4000
1157c: 1afffff7 bne 11560 <rtems_rfs_inode_create+0x110>
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
11580: e1a0000a mov r0, sl 11584: e1a01008 mov r1, r8 11588: e59d2094 ldr r2, [sp, #148] ; 0x94 1158c: ebfffe16 bl 10dec <rtems_rfs_inode_alloc>
if (rc > 0)
11590: e2509000 subs r9, r0, #0
11594: cafffff2 bgt 11564 <rtems_rfs_inode_create+0x114>
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
11598: e59dc094 ldr ip, [sp, #148] ; 0x94 1159c: e1a0000a mov r0, sl 115a0: e59c1000 ldr r1, [ip] 115a4: e28d2038 add r2, sp, #56 ; 0x38 115a8: e3a03001 mov r3, #1 115ac: ebfffe45 bl 10ec8 <rtems_rfs_inode_open>
if (rc > 0)
115b0: e2509000 subs r9, r0, #0
115b4: da000004 ble 115cc <rtems_rfs_inode_create+0x17c>
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_inode_free (fs, *ino);
115b8: e59dc094 ldr ip, [sp, #148] ; 0x94 <== NOT EXECUTED 115bc: e1a0000a mov r0, sl <== NOT EXECUTED 115c0: e59c1000 ldr r1, [ip] <== NOT EXECUTED 115c4: ebfffe12 bl 10e14 <rtems_rfs_inode_free> <== NOT EXECUTED
return rc;
115c8: eaffffe5 b 11564 <rtems_rfs_inode_create+0x114> <== NOT EXECUTED
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
115cc: e99d1008 ldmib sp, {r3, ip}
115d0: e28d0038 add r0, sp, #56 ; 0x38
115d4: e1a0100b mov r1, fp
115d8: e1a02007 mov r2, r7
115dc: e58dc000 str ip, [sp]
115e0: ebffff3c bl 112d8 <rtems_rfs_inode_initialise>
if (rc > 0)
115e4: e2509000 subs r9, r0, #0
115e8: ca00000f bgt 1162c <rtems_rfs_inode_create+0x1dc> /* * 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))
115ec: e3560901 cmp r6, #16384 ; 0x4000
115f0: 0a00003d beq 116ec <rtems_rfs_inode_create+0x29c>
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
115f4: e1a0000a mov r0, sl 115f8: e1a01008 mov r1, r8 115fc: e28d2010 add r2, sp, #16 11600: e3a03001 mov r3, #1 11604: ebfffe2f bl 10ec8 <rtems_rfs_inode_open>
if (rc > 0)
11608: e2509000 subs r9, r0, #0
1160c: da00000e ble 1164c <rtems_rfs_inode_create+0x1fc>
{
rtems_rfs_inode_delete (fs, &inode);
11610: e28d1038 add r1, sp, #56 ; 0x38 <== NOT EXECUTED 11614: e1a0000a mov r0, sl <== NOT EXECUTED 11618: ebfffecb bl 1114c <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
1161c: e1a0000a mov r0, sl <== NOT EXECUTED 11620: e28d1038 add r1, sp, #56 ; 0x38 <== NOT EXECUTED 11624: ebfffea1 bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
11628: eaffffcd b 11564 <rtems_rfs_inode_create+0x114> <== NOT EXECUTED
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
1162c: e28d1038 add r1, sp, #56 ; 0x38 <== NOT EXECUTED 11630: e1a0000a mov r0, sl <== NOT EXECUTED 11634: ebfffe9d bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_free (fs, *ino);
11638: e59dc094 ldr ip, [sp, #148] ; 0x94 <== NOT EXECUTED 1163c: e1a0000a mov r0, sl <== NOT EXECUTED 11640: e59c1000 ldr r1, [ip] <== NOT EXECUTED 11644: ebfffdf2 bl 10e14 <rtems_rfs_inode_free> <== NOT EXECUTED
return rc;
11648: eaffffc5 b 11564 <rtems_rfs_inode_create+0x114> <== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
1164c: e59d3094 ldr r3, [sp, #148] ; 0x94 11650: e593c000 ldr ip, [r3] 11654: e1a0000a mov r0, sl 11658: e28d1010 add r1, sp, #16 1165c: e1a02005 mov r2, r5 11660: e1a03004 mov r3, r4 11664: e58dc000 str ip, [sp] 11668: eb00252c bl 1ab20 <rtems_rfs_dir_add_entry>
if (rc > 0)
1166c: e2509000 subs r9, r0, #0
11670: ca000031 bgt 1173c <rtems_rfs_inode_create+0x2ec>
/*
* 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))
11674: e3560901 cmp r6, #16384 ; 0x4000
11678: 1a00000f bne 116bc <rtems_rfs_inode_create+0x26c>
*/
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);
1167c: e59d201c ldr r2, [sp, #28] 11680: e5d21000 ldrb r1, [r2] 11684: e5d23001 ldrb r3, [r2, #1] 11688: e1833401 orr r3, r3, r1, lsl #8
if (links == 0xffff)
links = 0;
1168c: e59f1104 ldr r1, [pc, #260] ; 11798 <rtems_rfs_inode_create+0x348> 11690: e1530001 cmp r3, r1 11694: 03a03000 moveq r3, #0
rtems_rfs_inode_set_links (&parent_inode,
11698: e2833001 add r3, r3, #1 1169c: e1a03803 lsl r3, 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);
116a0: e1a01c23 lsr r1, r3, #24 116a4: e5c21000 strb r1, [r2] 116a8: e59d201c ldr r2, [sp, #28] 116ac: e1a03823 lsr r3, r3, #16 116b0: e5c23001 strb r3, [r2, #1]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
116b4: e3a03001 mov r3, #1 116b8: e5cd3020 strb r3, [sp, #32]
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
116bc: e28d1010 add r1, sp, #16 116c0: e1a0000a mov r0, sl 116c4: ebfffe79 bl 110b0 <rtems_rfs_inode_close>
if (rc > 0)
116c8: e2509000 subs r9, r0, #0
{
rtems_rfs_inode_delete (fs, &inode);
116cc: e28d1038 add r1, sp, #56 ; 0x38 116d0: e1a0000a mov r0, sl
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)
116d4: da000022 ble 11764 <rtems_rfs_inode_create+0x314>
{
rtems_rfs_inode_delete (fs, &inode);
116d8: ebfffe9b bl 1114c <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
116dc: e1a0000a mov r0, sl <== NOT EXECUTED 116e0: e28d1038 add r1, sp, #56 ; 0x38 <== NOT EXECUTED 116e4: ebfffe71 bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
116e8: eaffff9d b 11564 <rtems_rfs_inode_create+0x114> <== NOT EXECUTED
*
* The inode delete will free the inode.
*/
if (RTEMS_RFS_S_ISDIR (mode))
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
116ec: e59d3094 ldr r3, [sp, #148] ; 0x94 116f0: e593c000 ldr ip, [r3] 116f4: e1a0000a mov r0, sl 116f8: e28d1038 add r1, sp, #56 ; 0x38 116fc: e59f2098 ldr r2, [pc, #152] ; 1179c <rtems_rfs_inode_create+0x34c> 11700: e3a03001 mov r3, #1 11704: e58dc000 str ip, [sp] 11708: eb002504 bl 1ab20 <rtems_rfs_dir_add_entry>
if (rc == 0)
1170c: e2509000 subs r9, r0, #0
11710: 1a000006 bne 11730 <rtems_rfs_inode_create+0x2e0>
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
11714: e1a0000a mov r0, sl 11718: e28d1038 add r1, sp, #56 ; 0x38 1171c: e59f207c ldr r2, [pc, #124] ; 117a0 <rtems_rfs_inode_create+0x350> 11720: e3a03002 mov r3, #2 11724: e58d8000 str r8, [sp] 11728: eb0024fc bl 1ab20 <rtems_rfs_dir_add_entry> 1172c: e1a09000 mov r9, r0
if (rc > 0)
11730: e3590000 cmp r9, #0
11734: daffffae ble 115f4 <rtems_rfs_inode_create+0x1a4>
11738: eaffffb4 b 11610 <rtems_rfs_inode_create+0x1c0> <== NOT EXECUTED
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
1173c: e28d1038 add r1, sp, #56 ; 0x38 <== NOT EXECUTED 11740: e1a0000a mov r0, sl <== NOT EXECUTED 11744: ebfffe80 bl 1114c <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
11748: e28d1038 add r1, sp, #56 ; 0x38 <== NOT EXECUTED 1174c: e1a0000a mov r0, sl <== NOT EXECUTED 11750: ebfffe56 bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
11754: e1a0000a mov r0, sl <== NOT EXECUTED 11758: e28d1010 add r1, sp, #16 <== NOT EXECUTED 1175c: ebfffe53 bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
11760: eaffff7f b 11564 <rtems_rfs_inode_create+0x114> <== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &inode);
11764: ebfffe51 bl 110b0 <rtems_rfs_inode_close>
if (rc > 0)
11768: e2509000 subs r9, r0, #0
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
return 0;
1176c: d3a09000 movle r9, #0
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
11770: caffff90 bgt 115b8 <rtems_rfs_inode_create+0x168>
11774: eaffff7a b 11564 <rtems_rfs_inode_create+0x114>
0001114c <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
1114c: e92d4030 push {r4, r5, lr}
11150: e1a05000 mov r5, r0
11154: e24dd050 sub sp, sp, #80 ; 0x50
11158: e1a04001 mov r4, r1
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
1115c: e3a00502 mov r0, #8388608 ; 0x800000 11160: e3a01000 mov r1, #0 11164: eb0005b1 bl 12830 <rtems_rfs_trace> 11168: e3500000 cmp r0, #0
1116c: 0a000007 beq 11190 <rtems_rfs_inode_delete+0x44>
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
11170: e594c00c ldr ip, [r4, #12] <== NOT EXECUTED 11174: e59f30a0 ldr r3, [pc, #160] ; 1121c <rtems_rfs_inode_delete+0xd0><== NOT EXECUTED 11178: e35c0000 cmp ip, #0 <== NOT EXECUTED 1117c: e59f209c ldr r2, [pc, #156] ; 11220 <rtems_rfs_inode_delete+0xd4><== NOT EXECUTED 11180: e59f009c ldr r0, [pc, #156] ; 11224 <rtems_rfs_inode_delete+0xd8><== NOT EXECUTED 11184: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED 11188: 11a02003 movne r2, r3 <== NOT EXECUTED 1118c: eb003cc4 bl 204a4 <printf> <== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
11190: e594000c ldr r0, [r4, #12] 11194: e3500000 cmp r0, #0
11198: 0a000004 beq 111b0 <rtems_rfs_inode_delete+0x64>
rtems_rfs_block_map map;
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
1119c: e1a00005 mov r0, r5 111a0: e5941008 ldr r1, [r4, #8] 111a4: ebffff1a bl 10e14 <rtems_rfs_inode_free>
if (rc > 0)
111a8: e3500000 cmp r0, #0
111ac: da000001 ble 111b8 <rtems_rfs_inode_delete+0x6c>
handle->loads = 0;
handle->node = NULL;
}
}
return rc;
}
111b0: e28dd050 add sp, sp, #80 ; 0x50
111b4: e8bd8030 pop {r4, r5, pc}
return rc;
/*
* Free the blocks the inode may have attached.
*/
rc = rtems_rfs_block_map_open (fs, handle, &map);
111b8: e1a00005 mov r0, r5 111bc: e1a01004 mov r1, r4 111c0: e1a0200d mov r2, sp 111c4: eb001f5b bl 18f38 <rtems_rfs_block_map_open>
if (rc == 0)
111c8: e3500000 cmp r0, #0
111cc: 1afffff7 bne 111b0 <rtems_rfs_inode_delete+0x64>
{
int rrc;
rrc = rtems_rfs_block_map_free_all (fs, &map);
111d0: e1a0100d mov r1, sp 111d4: e1a00005 mov r0, r5 111d8: eb002263 bl 19b6c <rtems_rfs_block_map_free_all>
rc = rtems_rfs_block_map_close (fs, &map);
111dc: e1a0100d mov r1, sp 111e0: e1a00005 mov r0, r5 111e4: eb001fad bl 190a0 <rtems_rfs_block_map_close>
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
111e8: e3a010ff mov r1, #255 ; 0xff 111ec: e3a02038 mov r2, #56 ; 0x38 111f0: e594000c ldr r0, [r4, #12] 111f4: eb003c39 bl 202e0 <memset>
rtems_rfs_buffer_mark_dirty (&handle->buffer);
111f8: e3a03001 mov r3, #1 111fc: e1a01004 mov r1, r4 11200: 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);
11204: e1a00005 mov r0, r5 11208: eb0022bc bl 19d00 <rtems_rfs_buffer_handle_release>
handle->loads = 0;
1120c: e3a03000 mov r3, #0 11210: e5843024 str r3, [r4, #36] ; 0x24
handle->node = NULL;
11214: e584300c str r3, [r4, #12] 11218: eaffffe4 b 111b0 <rtems_rfs_inode_delete+0x64>
00010e20 <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
10e20: e92d4030 push {r4, r5, lr}
10e24: e1a05000 mov r5, r0
10e28: e1a04001 mov r4, r1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
10e2c: e3a00601 mov r0, #1048576 ; 0x100000 10e30: e3a01000 mov r1, #0 10e34: eb00067d bl 12830 <rtems_rfs_trace> 10e38: e3500000 cmp r0, #0
10e3c: 0a000008 beq 10e64 <rtems_rfs_inode_load+0x44>
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
10e40: e594e00c ldr lr, [r4, #12] <== NOT EXECUTED 10e44: e59fc070 ldr ip, [pc, #112] ; 10ebc <rtems_rfs_inode_load+0x9c><== NOT EXECUTED 10e48: e35e0000 cmp lr, #0 <== NOT EXECUTED 10e4c: e59f306c ldr r3, [pc, #108] ; 10ec0 <rtems_rfs_inode_load+0xa0><== NOT EXECUTED 10e50: e59f006c ldr r0, [pc, #108] ; 10ec4 <rtems_rfs_inode_load+0xa4><== NOT EXECUTED 10e54: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED 10e58: e5942024 ldr r2, [r4, #36] ; 0x24 <== NOT EXECUTED 10e5c: 11a0300c movne r3, ip <== NOT EXECUTED 10e60: eb003d8f bl 204a4 <printf> <== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
10e64: e594300c ldr r3, [r4, #12] 10e68: e3530000 cmp r3, #0
10e6c: 0a000004 beq 10e84 <rtems_rfs_inode_load+0x64>
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
10e70: e5943024 ldr r3, [r4, #36] ; 0x24 10e74: e2833001 add r3, r3, #1 10e78: e5843024 str r3, [r4, #36] ; 0x24
return 0;
10e7c: e3a00000 mov r0, #0
}
10e80: e8bd8030 pop {r4, r5, pc}
if (!rtems_rfs_inode_is_loaded (handle))
{
int rc;
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
10e84: e1a00005 mov r0, r5 10e88: e2841010 add r1, r4, #16 10e8c: e594201c ldr r2, [r4, #28] 10e90: e3a03001 mov r3, #1 10e94: eb002412 bl 19ee4 <rtems_rfs_buffer_handle_request>
handle->block, true);
if (rc > 0)
10e98: e3500000 cmp r0, #0
10e9c: c8bd8030 popgt {r4, r5, pc}
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
10ea0: e5942018 ldr r2, [r4, #24]
handle->node += handle->offset;
10ea4: e5943020 ldr r3, [r4, #32] 10ea8: e592201c ldr r2, [r2, #28] 10eac: e0633183 rsb r3, r3, r3, lsl #3 10eb0: e0823183 add r3, r2, r3, lsl #3 10eb4: e584300c str r3, [r4, #12] 10eb8: eaffffec b 10e70 <rtems_rfs_inode_load+0x50>
00010ec8 <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)
{
10ec8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
10ecc: e1a05000 mov r5, r0
10ed0: e1a04001 mov r4, r1
int group;
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
10ed4: e3a00701 mov r0, #262144 ; 0x40000 10ed8: 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)
{
10edc: e1a06002 mov r6, r2 10ee0: e20370ff and r7, r3, #255 ; 0xff
int group;
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
10ee4: eb000651 bl 12830 <rtems_rfs_trace> 10ee8: e3500000 cmp r0, #0
10eec: 1a000008 bne 10f14 <rtems_rfs_inode_open+0x4c>
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
if (ino == RTEMS_RFS_EMPTY_INO)
10ef0: e3540000 cmp r4, #0
return EINVAL;
10ef4: 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)
10ef8: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
10efc: e5953014 ldr r3, [r5, #20] 10f00: e2448001 sub r8, r4, #1 10f04: e1580003 cmp r8, r3
10f08: 9a000008 bls 10f30 <rtems_rfs_inode_open+0x68>
return EINVAL;
10f0c: 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;
}
10f10: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
10f14: e59f00a0 ldr r0, [pc, #160] ; 10fbc <rtems_rfs_inode_open+0xf4><== NOT EXECUTED 10f18: e1a01004 mov r1, r4 <== NOT EXECUTED 10f1c: eb003d60 bl 204a4 <printf> <== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
10f20: e3540000 cmp r4, #0 <== NOT EXECUTED
return EINVAL;
10f24: 03a00016 moveq r0, #22 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
if (ino == RTEMS_RFS_EMPTY_INO)
10f28: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
10f2c: eafffff2 b 10efc <rtems_rfs_inode_open+0x34> <== NOT EXECUTED
handle->ino = ino;
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
10f30: e595902c ldr r9, [r5, #44] ; 0x2c
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
handle->node = NULL;
10f34: e3a0a000 mov sl, #0
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
10f38: e1a01009 mov r1, r9
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
10f3c: e5864008 str r4, [r6, #8]
handle->node = NULL;
10f40: e586a00c str sl, [r6, #12]
handle->loads = 0;
10f44: e586a024 str sl, [r6, #36] ; 0x24
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
10f48: e1a00008 mov r0, r8 10f4c: eb007029 bl 2cff8 <__umodsi3>
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
10f50: e5954030 ldr r4, [r5, #48] ; 0x30
handle->offset = gino % fs->inodes_per_block;
10f54: e1a01004 mov r1, r4
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
10f58: e1a0b000 mov fp, r0
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
10f5c: eb007025 bl 2cff8 <__umodsi3>
handle->ino = ino;
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
10f60: 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;
10f64: 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;
10f68: e1a00008 mov r0, r8 10f6c: ebffc2cd bl 1aa8 <__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);
10f70: e5953020 ldr r3, [r5, #32] 10f74: e0800100 add r0, r0, r0, lsl #2
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;
10f78: e7933200 ldr r3, [r3, r0, lsl #4] 10f7c: e1a01004 mov r1, r4 10f80: e1a0000b mov r0, fp 10f84: e2834002 add r4, r3, #2 10f88: ebffc2c6 bl 1aa8 <__aeabi_uidiv>
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)
10f8c: e157000a cmp r7, sl
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);
10f90: e0840000 add r0, r4, r0 10f94: 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;
10f98: e5c6a010 strb sl, [r6, #16]
handle->bnum = 0;
10f9c: e586a014 str sl, [r6, #20]
handle->buffer = NULL;
10fa0: e586a018 str sl, [r6, #24]
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
10fa4: 01a00007 moveq r0, r7
if ((rc == 0) && load)
10fa8: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rc = rtems_rfs_inode_load (fs, handle);
10fac: e1a00005 mov r0, r5 10fb0: e1a01006 mov r1, r6
return rc; }
10fb4: 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);
10fb8: eaffff98 b 10e20 <rtems_rfs_inode_load>
00011228 <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))
11228: e590300c ldr r3, [r0, #12] 1122c: e3530000 cmp r3, #0
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
11230: e92d4070 push {r4, r5, r6, lr}
11234: e1a04000 mov r4, r0
11238: e20160ff and r6, r1, #255 ; 0xff
1123c: e20250ff and r5, r2, #255 ; 0xff
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
return ENXIO;
11240: 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))
11244: 08bd8070 popeq {r4, r5, r6, pc}
return ENXIO;
now = time (NULL);
11248: e3a00000 mov r0, #0 1124c: eb004ccf bl 24590 <time>
if (atime)
11250: e3560000 cmp r6, #0
11254: 0a00000c beq 1128c <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);
11258: e594300c ldr r3, [r4, #12] 1125c: e1a02c20 lsr r2, r0, #24 11260: e5c32010 strb r2, [r3, #16] 11264: e594300c ldr r3, [r4, #12] 11268: e1a02820 lsr r2, r0, #16 1126c: e5c32011 strb r2, [r3, #17] 11270: e594300c ldr r3, [r4, #12] 11274: e1a02420 lsr r2, r0, #8 11278: e5c32012 strb r2, [r3, #18] 1127c: e594300c ldr r3, [r4, #12] 11280: e5c30013 strb r0, [r3, #19]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
11284: e3a03001 mov r3, #1 11288: e5c43010 strb r3, [r4, #16]
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
1128c: e3550000 cmp r5, #0
11290: 0a00000e beq 112d0 <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);
11294: e594300c ldr r3, [r4, #12] 11298: e1a02c20 lsr r2, r0, #24 1129c: e5c32014 strb r2, [r3, #20] 112a0: e594300c ldr r3, [r4, #12] 112a4: e1a02820 lsr r2, r0, #16 112a8: e5c32015 strb r2, [r3, #21] 112ac: e594300c ldr r3, [r4, #12] 112b0: e1a02420 lsr r2, r0, #8 112b4: e5c32016 strb r2, [r3, #22] 112b8: e594300c ldr r3, [r4, #12] 112bc: e5c30017 strb r0, [r3, #23]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
112c0: e3a03001 mov r3, #1
rtems_rfs_inode_set_mtime (handle, now);
return 0;
112c4: e3a00000 mov r0, #0
112c8: e5c43010 strb r3, [r4, #16]
112cc: e8bd8070 pop {r4, r5, r6, pc}
112d0: e1a00005 mov r0, r5 <== NOT EXECUTED
}
112d4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00010fc0 <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
10fc0: e92d4070 push {r4, r5, r6, lr}
10fc4: e1a05000 mov r5, r0
10fc8: e1a04001 mov r4, r1
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
10fcc: e3a00602 mov r0, #2097152 ; 0x200000 10fd0: e3a01000 mov r1, #0
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
10fd4: e20260ff and r6, r2, #255 ; 0xff
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
10fd8: eb000614 bl 12830 <rtems_rfs_trace> 10fdc: e3500000 cmp r0, #0
10fe0: 0a000008 beq 11008 <rtems_rfs_inode_unload+0x48>
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
10fe4: e594e00c ldr lr, [r4, #12] <== NOT EXECUTED 10fe8: e59fc0b4 ldr ip, [pc, #180] ; 110a4 <rtems_rfs_inode_unload+0xe4><== NOT EXECUTED 10fec: e35e0000 cmp lr, #0 <== NOT EXECUTED 10ff0: e59f30b0 ldr r3, [pc, #176] ; 110a8 <rtems_rfs_inode_unload+0xe8><== NOT EXECUTED 10ff4: e59f00b0 ldr r0, [pc, #176] ; 110ac <rtems_rfs_inode_unload+0xec><== NOT EXECUTED 10ff8: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED 10ffc: e5942024 ldr r2, [r4, #36] ; 0x24 <== NOT EXECUTED 11000: 11a0300c movne r3, ip <== NOT EXECUTED 11004: eb003d26 bl 204a4 <printf> <== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
11008: e594000c ldr r0, [r4, #12]
1100c: e3500000 cmp r0, #0
11010: 08bd8070 popeq {r4, r5, r6, pc}
{
if (handle->loads == 0)
11014: e5943024 ldr r3, [r4, #36] ; 0x24 11018: e3530000 cmp r3, #0
return EIO;
1101c: 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)
11020: 08bd8070 popeq {r4, r5, r6, pc}
return EIO;
handle->loads--;
11024: e2430001 sub r0, r3, #1
if (handle->loads == 0)
11028: e3500000 cmp r0, #0
if (rtems_rfs_inode_is_loaded (handle))
{
if (handle->loads == 0)
return EIO;
handle->loads--;
1102c: e5840024 str r0, [r4, #36] ; 0x24
if (handle->loads == 0)
11030: 1a00000a bne 11060 <rtems_rfs_inode_unload+0xa0>
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
11034: e5d43010 ldrb r3, [r4, #16] 11038: e3530000 cmp r3, #0
1103c: 0a000001 beq 11048 <rtems_rfs_inode_unload+0x88>
11040: e3560000 cmp r6, #0
11044: 1a000007 bne 11068 <rtems_rfs_inode_unload+0xa8>
rtems_rfs_inode_set_ctime (handle, time (NULL));
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
11048: e1a00005 mov r0, r5 1104c: e2841010 add r1, r4, #16 11050: eb00232a bl 19d00 <rtems_rfs_buffer_handle_release>
handle->node = NULL;
11054: e3a03000 mov r3, #0
11058: e584300c str r3, [r4, #12]
1105c: 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;
11060: e3a00000 mov r0, #0
handle->node = NULL;
}
}
return rc;
}
11064: e8bd8070 pop {r4, r5, r6, pc}
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
rtems_rfs_inode_set_ctime (handle, time (NULL));
11068: eb004d48 bl 24590 <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);
1106c: e594300c ldr r3, [r4, #12] 11070: e1a02c20 lsr r2, r0, #24 11074: e5c32018 strb r2, [r3, #24] 11078: e594300c ldr r3, [r4, #12] 1107c: e1a02820 lsr r2, r0, #16 11080: e5c32019 strb r2, [r3, #25] 11084: e594300c ldr r3, [r4, #12] 11088: e1a02420 lsr r2, r0, #8 1108c: e5c3201a strb r2, [r3, #26] 11090: e594300c ldr r3, [r4, #12] 11094: e5c3001b strb r0, [r3, #27]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
11098: e3a03001 mov r3, #1 1109c: e5c43010 strb r3, [r4, #16] 110a0: eaffffe8 b 11048 <rtems_rfs_inode_unload+0x88>
0001d0d4 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
1d0d4: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
1d0d8: e1a06000 mov r6, r0
1d0dc: e24dd054 sub sp, sp, #84 ; 0x54
1d0e0: e1a05001 mov r5, 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))
1d0e4: e3a00401 mov r0, #16777216 ; 0x1000000 1d0e8: e3a01000 mov r1, #0
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
1d0ec: e1a04002 mov r4, r2 1d0f0: e1a07003 mov r7, r3 1d0f4: e59da074 ldr sl, [sp, #116] ; 0x74 1d0f8: e5dd8078 ldrb r8, [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))
1d0fc: ebffd5cb bl 12830 <rtems_rfs_trace> 1d100: e3500000 cmp r0, #0
1d104: 1a000045 bne 1d220 <rtems_rfs_link+0x14c>
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
1d108: e1a00006 mov r0, r6 1d10c: e1a0100a mov r1, sl 1d110: e28d202c add r2, sp, #44 ; 0x2c 1d114: e3a03001 mov r3, #1 1d118: ebffcf6a bl 10ec8 <rtems_rfs_inode_open>
if (rc)
1d11c: e2509000 subs r9, r0, #0
1d120: 1a000034 bne 1d1f8 <rtems_rfs_link+0x124>
/*
* 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)))
1d124: e3580000 cmp r8, #0
{
rtems_rfs_inode_close (fs, &target_inode);
1d128: e1a00006 mov r0, r6
/*
* 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)))
1d12c: 1a000005 bne 1d148 <rtems_rfs_link+0x74>
1d130: e59d3038 ldr r3, [sp, #56] ; 0x38 1d134: e5d33002 ldrb r3, [r3, #2] 1d138: e1a03403 lsl r3, r3, #8 1d13c: e2033a0f and r3, r3, #61440 ; 0xf000 1d140: e3530901 cmp r3, #16384 ; 0x4000
1d144: 0a000044 beq 1d25c <rtems_rfs_link+0x188>
{
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
1d148: e1a01007 mov r1, r7 1d14c: e28d2004 add r2, sp, #4 1d150: e3a03001 mov r3, #1 1d154: ebffcf5b bl 10ec8 <rtems_rfs_inode_open>
if (rc)
1d158: e2509000 subs r9, r0, #0
{
rtems_rfs_inode_close (fs, &target_inode);
1d15c: e1a00006 mov r0, r6
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
if (rc)
1d160: 1a00002b bne 1d214 <rtems_rfs_link+0x140>
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
1d164: e28d1004 add r1, sp, #4 1d168: e1a02005 mov r2, r5 1d16c: e1a03004 mov r3, r4 1d170: e58da000 str sl, [sp] 1d174: ebfff669 bl 1ab20 <rtems_rfs_dir_add_entry>
if (rc > 0)
1d178: e2509000 subs r9, r0, #0
1d17c: ca000020 bgt 1d204 <rtems_rfs_link+0x130>
*/
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);
1d180: e59d3038 ldr r3, [sp, #56] ; 0x38 1d184: e5d31000 ldrb r1, [r3] 1d188: e5d32001 ldrb r2, [r3, #1] 1d18c: e1822401 orr r2, r2, r1, lsl #8
if (links == 0xffff)
1d190: e59f10f4 ldr r1, [pc, #244] ; 1d28c <rtems_rfs_link+0x1b8> 1d194: e1520001 cmp r2, r1 1d198: 12822001 addne r2, r2, #1 1d19c: 11a02802 lslne r2, r2, #16 1d1a0: 11a00822 lsrne r0, r2, #16 1d1a4: 03a02000 moveq r2, #0 1d1a8: 11a02c22 lsrne r2, r2, #24
* @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);
1d1ac: e5c32000 strb r2, [r3] 1d1b0: e59d2038 ldr r2, [sp, #56] ; 0x38
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
if (links == 0xffff)
1d1b4: 120000ff andne r0, r0, #255 ; 0xff 1d1b8: 03a00001 moveq r0, #1
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1d1bc: e3a03001 mov r3, #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);
1d1c0: e5c20001 strb r0, [r2, #1]
}
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);
1d1c4: e1a01003 mov r1, r3 1d1c8: e28d0004 add r0, sp, #4 1d1cc: e1a02003 mov r2, r3
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1d1d0: e5cd303c strb r3, [sp, #60] ; 0x3c 1d1d4: ebffd013 bl 11228 <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
1d1d8: e2509000 subs r9, r0, #0
{
rtems_rfs_inode_close (fs, &parent_inode);
1d1dc: e28d1004 add r1, sp, #4 1d1e0: e1a00006 mov r0, r6
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)
1d1e4: da000020 ble 1d26c <rtems_rfs_link+0x198>
{
rtems_rfs_inode_close (fs, &parent_inode);
1d1e8: ebffcfb0 bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
1d1ec: e1a00006 mov r0, r6 <== NOT EXECUTED 1d1f0: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 1d1f4: ebffcfad bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
1d1f8: e1a00009 mov r0, r9
1d1fc: e28dd054 add sp, sp, #84 ; 0x54
1d200: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
1d204: e1a00006 mov r0, r6 <== NOT EXECUTED 1d208: e28d1004 add r1, sp, #4 <== NOT EXECUTED 1d20c: ebffcfa7 bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
1d210: e1a00006 mov r0, r6 <== NOT EXECUTED 1d214: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 1d218: ebffcfa4 bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
1d21c: eafffff5 b 1d1f8 <rtems_rfs_link+0x124> <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_LINK))
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
1d220: e59f0068 ldr r0, [pc, #104] ; 1d290 <rtems_rfs_link+0x1bc> <== NOT EXECUTED 1d224: e1a01007 mov r1, r7 <== NOT EXECUTED 1d228: eb000c9d bl 204a4 <printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
1d22c: e3540000 cmp r4, #0 <== NOT EXECUTED 1d230: da000005 ble 1d24c <rtems_rfs_link+0x178> <== NOT EXECUTED 1d234: e3a09000 mov r9, #0 <== NOT EXECUTED
printf ("%c", name[c]);
1d238: e7d50009 ldrb r0, [r5, r9] <== 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++)
1d23c: e2899001 add r9, r9, #1 <== NOT EXECUTED
printf ("%c", name[c]);
1d240: eb000d01 bl 2064c <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++)
1d244: e1590004 cmp r9, r4 <== NOT EXECUTED 1d248: 1afffffa bne 1d238 <rtems_rfs_link+0x164> <== NOT EXECUTED
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
1d24c: e1a0100a mov r1, sl <== NOT EXECUTED 1d250: e59f003c ldr r0, [pc, #60] ; 1d294 <rtems_rfs_link+0x1c0> <== NOT EXECUTED 1d254: eb000c92 bl 204a4 <printf> <== NOT EXECUTED 1d258: eaffffaa b 1d108 <rtems_rfs_link+0x34> <== NOT EXECUTED
* If the target inode is a directory and we cannot link directories
* return a not supported error code.
*/
if (!link_dir && S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)))
{
rtems_rfs_inode_close (fs, &target_inode);
1d25c: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 1d260: ebffcf92 bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
return ENOTSUP;
1d264: e3a09086 mov r9, #134 ; 0x86 <== NOT EXECUTED 1d268: eaffffe2 b 1d1f8 <rtems_rfs_link+0x124> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
1d26c: ebffcf8f bl 110b0 <rtems_rfs_inode_close>
if (rc > 0)
1d270: e2509000 subs r9, r0, #0
{
rtems_rfs_inode_close (fs, &target_inode);
1d274: e28d102c add r1, sp, #44 ; 0x2c 1d278: e1a00006 mov r0, r6
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
if (rc > 0)
1d27c: caffffe5 bgt 1d218 <rtems_rfs_link+0x144>
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
1d280: ebffcf8a bl 110b0 <rtems_rfs_inode_close> 1d284: e1a09000 mov r9, r0
return rc;
1d288: eaffffda b 1d1f8 <rtems_rfs_link+0x124>
0001daf4 <rtems_rfs_mutex_create>:
RTEMS_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
1daf4: e92d4010 push {r4, lr}
1daf8: e24dd004 sub sp, sp, #4
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
1dafc: e58d0000 str r0, [sp] 1db00: e3a01001 mov r1, #1 1db04: e59f0050 ldr r0, [pc, #80] ; 1db5c <rtems_rfs_mutex_create+0x68> 1db08: e3a02054 mov r2, #84 ; 0x54 1db0c: e3a03000 mov r3, #0 1db10: ebffb79e bl b990 <rtems_semaphore_create>
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
1db14: e2504000 subs r4, r0, #0
printf ("rtems-rfs: mutex: open failed: %s\n",
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
1db18: 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)
1db1c: 1a000001 bne 1db28 <rtems_rfs_mutex_create+0x34>
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
1db20: e28dd004 add sp, sp, #4
1db24: e8bd8010 pop {r4, pc}
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1db28: e3a00004 mov r0, #4 <== NOT EXECUTED 1db2c: e3a01000 mov r1, #0 <== NOT EXECUTED 1db30: ebffd33e bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1db34: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
rtems_status_text (sc));
return EIO;
1db38: 03a00005 moveq r0, #5 <== NOT EXECUTED
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1db3c: 0afffff7 beq 1db20 <rtems_rfs_mutex_create+0x2c> <== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
1db40: e1a00004 mov r0, r4 <== NOT EXECUTED 1db44: ebffa530 bl 700c <rtems_status_text> <== NOT EXECUTED 1db48: e1a01000 mov r1, r0 <== NOT EXECUTED 1db4c: e59f000c ldr r0, [pc, #12] ; 1db60 <rtems_rfs_mutex_create+0x6c><== NOT EXECUTED 1db50: eb000a53 bl 204a4 <printf> <== NOT EXECUTED
rtems_status_text (sc));
return EIO;
1db54: e3a00005 mov r0, #5 <== NOT EXECUTED 1db58: eafffff0 b 1db20 <rtems_rfs_mutex_create+0x2c> <== NOT EXECUTED
0001db64 <rtems_rfs_mutex_destroy>:
return 0;
}
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
1db64: e92d4010 push {r4, lr}
#if __rtems__ rtems_status_code sc; sc = rtems_semaphore_delete (*mutex);
1db68: e5900000 ldr r0, [r0] 1db6c: ebffb7f7 bl bb50 <rtems_semaphore_delete>
if (sc != RTEMS_SUCCESSFUL)
1db70: e2504000 subs r4, r0, #0
printf ("rtems-rfs: mutex: close failed: %s\n",
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
1db74: 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)
1db78: 08bd8010 popeq {r4, pc}
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1db7c: e3a00004 mov r0, #4 <== NOT EXECUTED 1db80: e3a01000 mov r1, #0 <== NOT EXECUTED 1db84: ebffd329 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1db88: e3500000 cmp r0, #0 <== NOT EXECUTED 1db8c: 1a000001 bne 1db98 <rtems_rfs_mutex_destroy+0x34> <== NOT EXECUTED
printf ("rtems-rfs: mutex: close failed: %s\n",
rtems_status_text (sc));
return EIO;
1db90: e3a00005 mov r0, #5 <== NOT EXECUTED
} #endif return 0; }
1db94: e8bd8010 pop {r4, pc} <== NOT EXECUTED
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
printf ("rtems-rfs: mutex: close failed: %s\n",
1db98: e1a00004 mov r0, r4 <== NOT EXECUTED 1db9c: ebffa51a bl 700c <rtems_status_text> <== NOT EXECUTED 1dba0: e1a01000 mov r1, r0 <== NOT EXECUTED 1dba4: e59f0008 ldr r0, [pc, #8] ; 1dbb4 <rtems_rfs_mutex_destroy+0x50><== NOT EXECUTED 1dba8: eb000a3d bl 204a4 <printf> <== NOT EXECUTED
rtems_status_text (sc));
return EIO;
1dbac: e3a00005 mov r0, #5 <== NOT EXECUTED
1dbb0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00019b74 <rtems_rfs_release_chain>:
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
19b74: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
19b78: e1a04000 mov r4, r0
19b7c: e1a05001 mov r5, r1
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
19b80: e3a00080 mov r0, #128 ; 0x80 19b84: e3a01000 mov r1, #0
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
19b88: e1a0a002 mov sl, r2
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
19b8c: ebffe327 bl 12830 <rtems_rfs_trace> 19b90: e3500000 cmp r0, #0
19b94: 1a000017 bne 19bf8 <rtems_rfs_release_chain+0x84>
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
19b98: e3a06000 mov r6, #0 19b9c: e2847004 add r7, r4, #4
while (!rtems_chain_is_empty (chain))
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
buffer->user = (void*) 0;
19ba0: e1a08006 mov r8, r6 19ba4: ea00000d b 19be0 <rtems_rfs_release_chain+0x6c>
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
19ba8: ebffcac2 bl c6b8 <_Chain_Get>
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
19bac: e5952000 ldr r2, [r5] 19bb0: e2422001 sub r2, r2, #1 19bb4: e5852000 str r2, [r5]
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
19bb8: e1a0100a mov r1, sl
while (!rtems_chain_is_empty (chain))
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
buffer->user = (void*) 0;
19bbc: e5808034 str r8, [r0, #52] ; 0x34
rc = rtems_rfs_buffer_io_release (buffer, modified);
19bc0: eb0015b8 bl 1f2a8 <rtems_rfs_buffer_bdbuf_release>
if ((rc > 0) && (rrc == 0))
19bc4: e3500000 cmp r0, #0 19bc8: d3a03000 movle r3, #0 19bcc: c3a03001 movgt r3, #1 19bd0: e3560000 cmp r6, #0 19bd4: 13a03000 movne r3, #0 19bd8: e3530000 cmp r3, #0 19bdc: 11a06000 movne r6, r0
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
19be0: e5943000 ldr r3, [r4] 19be4: e1530007 cmp r3, r7 19be8: e1a00004 mov r0, r4
19bec: 1affffed bne 19ba8 <rtems_rfs_release_chain+0x34>
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
rrc = rc;
}
return rrc;
}
19bf0: e1a00006 mov r0, r6
19bf4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
19bf8: e5951000 ldr r1, [r5] <== NOT EXECUTED 19bfc: e59f0004 ldr r0, [pc, #4] ; 19c08 <rtems_rfs_release_chain+0x94><== NOT EXECUTED 19c00: eb001a27 bl 204a4 <printf> <== NOT EXECUTED 19c04: eaffffe3 b 19b98 <rtems_rfs_release_chain+0x24> <== NOT EXECUTED
00011bc4 <rtems_rfs_rtems_chown>:
static int
rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
11bc4: e92d40f0 push {r4, r5, r6, r7, lr}
11bc8: e1a03000 mov r3, r0
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
11bcc: e5900014 ldr r0, [r0, #20] 11bd0: e5904008 ldr r4, [r0, #8]
static int
rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
11bd4: e24dd028 sub sp, sp, #40 ; 0x28 11bd8: e1a05801 lsl r5, r1, #16 11bdc: e1a06802 lsl r6, r2, #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);
11be0: e5931008 ldr r1, [r3, #8] 11be4: e1a00004 mov r0, r4 11be8: e1a0200d mov r2, sp 11bec: e3a03001 mov r3, #1 11bf0: ebfffcb4 bl 10ec8 <rtems_rfs_inode_open>
if (rc > 0)
11bf4: e2507000 subs r7, r0, #0
static int
rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
11bf8: e1a05825 lsr r5, r5, #16 11bfc: e1a06826 lsr r6, r6, #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);
if (rc > 0)
11c00: da000005 ble 11c1c <rtems_rfs_rtems_chown+0x58>
{
return rtems_rfs_rtems_error ("chown: opening inode", rc);
11c04: eb003662 bl 1f594 <__errno> <== NOT EXECUTED 11c08: e5807000 str r7, [r0] <== NOT EXECUTED 11c0c: e3e03000 mvn r3, #0 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("chown: closing inode", rc);
}
return 0;
}
11c10: e1a00003 mov r0, r3
11c14: e28dd028 add sp, sp, #40 ; 0x28
11c18: e8bd80f0 pop {r4, r5, r6, r7, pc}
*/
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);
11c1c: e59d300c ldr r3, [sp, #12] 11c20: e1856806 orr r6, r5, r6, lsl #16 11c24: e1a02c26 lsr r2, r6, #24 11c28: e5c32004 strb r2, [r3, #4] 11c2c: e59d300c ldr r3, [sp, #12] 11c30: e1a02826 lsr r2, r6, #16 11c34: e5c32005 strb r2, [r3, #5] 11c38: e59d300c ldr r3, [sp, #12] 11c3c: e1a06426 lsr r6, r6, #8 11c40: e5c36006 strb r6, [r3, #6] 11c44: e59d300c ldr r3, [sp, #12]
}
#endif
rtems_rfs_inode_set_uid_gid (&inode, owner, group);
rc = rtems_rfs_inode_close (fs, &inode);
11c48: e1a00004 mov r0, r4 11c4c: e5c35007 strb r5, [r3, #7] 11c50: e1a0100d mov r1, sp
rtems_rfs_buffer_mark_dirty (&handle->buffer);
11c54: e3a03001 mov r3, #1 11c58: e5cd3010 strb r3, [sp, #16] 11c5c: ebfffd13 bl 110b0 <rtems_rfs_inode_close>
if (rc)
11c60: e2504000 subs r4, r0, #0
{
return rtems_rfs_rtems_error ("chown: closing inode", rc);
}
return 0;
11c64: 01a03004 moveq r3, r4
#endif
rtems_rfs_inode_set_uid_gid (&inode, owner, group);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc)
11c68: 0affffe8 beq 11c10 <rtems_rfs_rtems_chown+0x4c>
{
return rtems_rfs_rtems_error ("chown: closing inode", rc);
11c6c: eb003648 bl 1f594 <__errno> <== NOT EXECUTED 11c70: e3e03000 mvn r3, #0 <== NOT EXECUTED 11c74: e5804000 str r4, [r0] <== NOT EXECUTED 11c78: eaffffe4 b 11c10 <rtems_rfs_rtems_chown+0x4c> <== NOT EXECUTED
0001dc20 <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);
1dc20: e2801028 add r1, r0, #40 ; 0x28 <== NOT EXECUTED
1dc24: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
1dc28: ea000490 b 1ee70 <rtems_deviceio_close> <== NOT EXECUTED
0001dbb8 <rtems_rfs_rtems_device_ftruncate>:
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, off_t length)
{
return 0;
}
1dbb8: e3a00000 mov r0, #0 <== NOT EXECUTED 1dbbc: e12fff1e bx lr <== NOT EXECUTED
0001dbc0 <rtems_rfs_rtems_device_ioctl>:
static int
rtems_rfs_rtems_device_ioctl (rtems_libio_t* iop,
ioctl_command_t command,
void* buffer)
{
1dbc0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== 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);
1dbc4: e2803028 add r3, r0, #40 ; 0x28 <== NOT EXECUTED
1dbc8: e8931008 ldm r3, {r3, ip} <== NOT EXECUTED
static int
rtems_rfs_rtems_device_ioctl (rtems_libio_t* iop,
ioctl_command_t command,
void* buffer)
{
1dbcc: e24dd004 sub sp, sp, #4 <== 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);
1dbd0: e58dc000 str ip, [sp] <== NOT EXECUTED 1dbd4: eb0004e8 bl 1ef7c <rtems_deviceio_control> <== NOT EXECUTED
}
1dbd8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
1dbdc: e8bd8000 pop {pc} <== NOT EXECUTED
0001dc2c <rtems_rfs_rtems_device_open>:
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode)
{
1dc2c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
1dc30: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
1dc34: e5900024 ldr r0, [r0, #36] ; 0x24 <== NOT EXECUTED 1dc38: e5904008 ldr r4, [r0, #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 };
1dc3c: e5940080 ldr r0, [r4, #128] ; 0x80 <== NOT EXECUTED
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode)
{
1dc40: 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);
1dc44: e3a01000 mov r1, #0 <== NOT EXECUTED 1dc48: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED 1dc4c: e1a06002 mov r6, r2 <== NOT EXECUTED 1dc50: e5900000 ldr r0, [r0] <== NOT EXECUTED 1dc54: e1a02001 mov r2, r1 <== NOT EXECUTED 1dc58: e1a08003 mov r8, r3 <== 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);
1dc5c: e595a018 ldr sl, [r5, #24] <== NOT EXECUTED 1dc60: ebffb7e3 bl bbf4 <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
1dc64: e2509000 subs r9, r0, #0 <== NOT EXECUTED 1dc68: 1a00001e bne 1dce8 <rtems_rfs_rtems_device_open+0xbc> <== NOT EXECUTED
rtems_device_minor_number minor;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1dc6c: e1a0100a mov r1, sl <== NOT EXECUTED 1dc70: e1a00004 mov r0, r4 <== NOT EXECUTED 1dc74: e28d2020 add r2, sp, #32 <== NOT EXECUTED 1dc78: e3a03001 mov r3, #1 <== NOT EXECUTED 1dc7c: ebffcc91 bl 10ec8 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
1dc80: e250a000 subs sl, r0, #0 <== NOT EXECUTED 1dc84: da000022 ble 1dd14 <rtems_rfs_rtems_device_open+0xe8> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1dc88: e5945080 ldr r5, [r4, #128] ; 0x80 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
1dc8c: e1a00004 mov r0, r4 <== NOT EXECUTED 1dc90: ebfff1c4 bl 1a3a8 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
1dc94: e5950000 ldr r0, [r5] <== NOT EXECUTED 1dc98: ebffb81e bl bd18 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
1dc9c: e2504000 subs r4, r0, #0 <== NOT EXECUTED 1dca0: 1a000005 bne 1dcbc <rtems_rfs_rtems_device_open+0x90> <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
1dca4: eb00063a bl 1f594 <__errno> <== NOT EXECUTED 1dca8: e580a000 str sl, [r0] <== NOT EXECUTED 1dcac: e3e03000 mvn r3, #0 <== NOT EXECUTED
iop->data0 = major;
iop->data1 = (void *) minor;
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
}
1dcb0: e1a00003 mov r0, r3 <== NOT EXECUTED
1dcb4: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
1dcb8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1dcbc: e3a00004 mov r0, #4 <== NOT EXECUTED 1dcc0: e3a01000 mov r1, #0 <== NOT EXECUTED 1dcc4: ebffd2d9 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1dcc8: e3500000 cmp r0, #0 <== NOT EXECUTED 1dccc: 0afffff4 beq 1dca4 <rtems_rfs_rtems_device_open+0x78> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
1dcd0: e1a00004 mov r0, r4 <== NOT EXECUTED 1dcd4: ebffa4cc bl 700c <rtems_status_text> <== NOT EXECUTED 1dcd8: e1a01000 mov r1, r0 <== NOT EXECUTED 1dcdc: e59f012c ldr r0, [pc, #300] ; 1de10 <rtems_rfs_rtems_device_open+0x1e4><== NOT EXECUTED 1dce0: eb0009ef bl 204a4 <printf> <== NOT EXECUTED 1dce4: eaffffee b 1dca4 <rtems_rfs_rtems_device_open+0x78> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1dce8: e3a00004 mov r0, #4 <== NOT EXECUTED 1dcec: e3a01000 mov r1, #0 <== NOT EXECUTED 1dcf0: ebffd2ce bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1dcf4: e3500000 cmp r0, #0 <== NOT EXECUTED 1dcf8: 0affffdb beq 1dc6c <rtems_rfs_rtems_device_open+0x40> <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
1dcfc: e1a00009 mov r0, r9 <== NOT EXECUTED 1dd00: ebffa4c1 bl 700c <rtems_status_text> <== NOT EXECUTED 1dd04: e1a01000 mov r1, r0 <== NOT EXECUTED 1dd08: e59f0104 ldr r0, [pc, #260] ; 1de14 <rtems_rfs_rtems_device_open+0x1e8><== NOT EXECUTED 1dd0c: eb0009e4 bl 204a4 <printf> <== NOT EXECUTED 1dd10: eaffffd5 b 1dc6c <rtems_rfs_rtems_device_open+0x40> <== 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]);
1dd14: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED 1dd18: e5d3201c ldrb r2, [r3, #28] <== NOT EXECUTED 1dd1c: e58d2008 str r2, [sp, #8] <== NOT EXECUTED 1dd20: e5d3201e ldrb r2, [r3, #30] <== NOT EXECUTED 1dd24: e58d200c str r2, [sp, #12] <== NOT EXECUTED 1dd28: e5d3201f ldrb r2, [r3, #31] <== NOT EXECUTED 1dd2c: e58d2010 str r2, [sp, #16] <== NOT EXECUTED 1dd30: e5d32020 ldrb r2, [r3, #32] <== NOT EXECUTED 1dd34: e5d3b01d ldrb fp, [r3, #29] <== NOT EXECUTED 1dd38: e58d2014 str r2, [sp, #20] <== NOT EXECUTED 1dd3c: e5d39021 ldrb r9, [r3, #33] ; 0x21 <== NOT EXECUTED 1dd40: e5d32022 ldrb r2, [r3, #34] ; 0x22 <== NOT EXECUTED 1dd44: e5d33023 ldrb r3, [r3, #35] ; 0x23 <== 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);
1dd48: e1a00004 mov r0, r4 <== NOT EXECUTED 1dd4c: e28d1020 add r1, sp, #32 <== NOT EXECUTED 1dd50: e58d2018 str r2, [sp, #24] <== NOT EXECUTED 1dd54: e58d301c str r3, [sp, #28] <== NOT EXECUTED 1dd58: ebffccd4 bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
1dd5c: e250a000 subs sl, r0, #0 <== NOT EXECUTED 1dd60: caffffc8 bgt 1dc88 <rtems_rfs_rtems_device_open+0x5c> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1dd64: e594a080 ldr sl, [r4, #128] ; 0x80 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
1dd68: e1a00004 mov r0, r4 <== NOT EXECUTED 1dd6c: ebfff18d bl 1a3a8 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
1dd70: e59a0000 ldr r0, [sl] <== NOT EXECUTED 1dd74: ebffb7e7 bl bd18 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
1dd78: e2504000 subs r4, r0, #0 <== NOT EXECUTED 1dd7c: 1a000018 bne 1dde4 <rtems_rfs_rtems_device_open+0x1b8> <== NOT EXECUTED 1dd80: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 1dd84: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 1dd88: e1a0c80b lsl ip, fp, #16 <== NOT EXECUTED 1dd8c: e1a0e809 lsl lr, r9, #16 <== NOT EXECUTED 1dd90: e18ccc03 orr ip, ip, r3, lsl #24 <== NOT EXECUTED 1dd94: e18eec02 orr lr, lr, r2, lsl #24 <== NOT EXECUTED 1dd98: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 1dd9c: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED 1dda0: e18cc003 orr ip, ip, r3 <== NOT EXECUTED 1dda4: e18ee002 orr lr, lr, r2 <== NOT EXECUTED 1dda8: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 1ddac: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 1ddb0: e18cc403 orr ip, ip, r3, lsl #8 <== NOT EXECUTED 1ddb4: e18ee402 orr lr, lr, r2, lsl #8 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
1ddb8: e585c028 str ip, [r5, #40] ; 0x28 <== NOT EXECUTED
iop->data1 = (void *) minor;
1ddbc: e585e02c str lr, [r5, #44] ; 0x2c <== NOT EXECUTED
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
1ddc0: e1a03008 mov r3, r8 <== NOT EXECUTED 1ddc4: e1a00005 mov r0, r5 <== NOT EXECUTED 1ddc8: e1a01007 mov r1, r7 <== NOT EXECUTED 1ddcc: e1a02006 mov r2, r6 <== NOT EXECUTED 1ddd0: e58de000 str lr, [sp] <== NOT EXECUTED 1ddd4: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 1ddd8: eb000417 bl 1ee3c <rtems_deviceio_open> <== NOT EXECUTED 1dddc: e1a03000 mov r3, r0 <== NOT EXECUTED 1dde0: eaffffb2 b 1dcb0 <rtems_rfs_rtems_device_open+0x84> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1dde4: e3a00004 mov r0, #4 <== NOT EXECUTED 1dde8: e3a01000 mov r1, #0 <== NOT EXECUTED 1ddec: ebffd28f bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1ddf0: e3500000 cmp r0, #0 <== NOT EXECUTED 1ddf4: 0affffe1 beq 1dd80 <rtems_rfs_rtems_device_open+0x154> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
1ddf8: e1a00004 mov r0, r4 <== NOT EXECUTED 1ddfc: ebffa482 bl 700c <rtems_status_text> <== NOT EXECUTED 1de00: e1a01000 mov r1, r0 <== NOT EXECUTED 1de04: e59f0004 ldr r0, [pc, #4] ; 1de10 <rtems_rfs_rtems_device_open+0x1e4><== NOT EXECUTED 1de08: eb0009a5 bl 204a4 <printf> <== NOT EXECUTED 1de0c: eaffffdb b 1dd80 <rtems_rfs_rtems_device_open+0x154> <== NOT EXECUTED
0001dc00 <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)
{
1dc00: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== 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);
1dc04: e2803028 add r3, r0, #40 ; 0x28 <== NOT EXECUTED
1dc08: e8931008 ldm r3, {r3, ip} <== NOT EXECUTED
* @return ssize_t
*/
static ssize_t
rtems_rfs_rtems_device_read (rtems_libio_t* iop, void* buffer, size_t count)
{
1dc0c: e24dd004 sub sp, sp, #4 <== 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);
1dc10: e58dc000 str ip, [sp] <== NOT EXECUTED 1dc14: eb0004a2 bl 1eea4 <rtems_deviceio_read> <== NOT EXECUTED
}
1dc18: e28dd004 add sp, sp, #4 <== NOT EXECUTED
1dc1c: e8bd8000 pop {pc} <== NOT EXECUTED
0001dbe0 <rtems_rfs_rtems_device_write>:
static ssize_t
rtems_rfs_rtems_device_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
1dbe0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== 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);
1dbe4: e2803028 add r3, r0, #40 ; 0x28 <== NOT EXECUTED
1dbe8: e8931008 ldm r3, {r3, ip} <== NOT EXECUTED
static ssize_t
rtems_rfs_rtems_device_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
1dbec: e24dd004 sub sp, sp, #4 <== 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);
1dbf0: e58dc000 str ip, [sp] <== NOT EXECUTED 1dbf4: eb0004c5 bl 1ef10 <rtems_deviceio_write> <== NOT EXECUTED
}
1dbf8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
1dbfc: e8bd8000 pop {pc} <== NOT EXECUTED
0001e004 <rtems_rfs_rtems_dir_open>:
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
1e004: e5903024 ldr r3, [r0, #36] ; 0x24
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
1e008: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
1e00c: e5934008 ldr r4, [r3, #8]
.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 };
1e010: e5943080 ldr r3, [r4, #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);
1e014: e3a01000 mov r1, #0
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
1e018: e1a05000 mov r5, r0 1e01c: e24dd028 sub sp, sp, #40 ; 0x28 1e020: e5930000 ldr r0, [r3] 1e024: e1a02001 mov r2, r1
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo); rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
1e028: e5956018 ldr r6, [r5, #24] 1e02c: ebffb6f0 bl bbf4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
1e030: e2507000 subs r7, r0, #0
1e034: 1a000029 bne 1e0e0 <rtems_rfs_rtems_dir_open+0xdc>
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1e038: e1a01006 mov r1, r6 1e03c: e1a00004 mov r0, r4 1e040: e1a0200d mov r2, sp 1e044: e3a03001 mov r3, #1 1e048: ebffcb9e bl 10ec8 <rtems_rfs_inode_open>
if (rc)
1e04c: e2506000 subs r6, r0, #0
1e050: 1a000033 bne 1e124 <rtems_rfs_rtems_dir_open+0x120>
* @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);
1e054: e59d300c ldr r3, [sp, #12] 1e058: e5d33002 ldrb r3, [r3, #2]
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
1e05c: e1a03403 lsl r3, r3, #8 1e060: e2033a0f and r3, r3, #61440 ; 0xf000 1e064: e3530901 cmp r3, #16384 ; 0x4000
{
rtems_rfs_inode_close (fs, &inode);
1e068: e1a0100d mov r1, sp
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
1e06c: 1a000042 bne 1e17c <rtems_rfs_rtems_dir_open+0x178>
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
}
iop->offset = 0;
1e070: e3a02000 mov r2, #0
1e074: e3a03000 mov r3, #0
1e078: e985000c stmib r5, {r2, r3}
rtems_rfs_inode_close (fs, &inode);
1e07c: e1a00004 mov r0, r4 1e080: ebffcc0a bl 110b0 <rtems_rfs_inode_close>
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1e084: e5945080 ldr r5, [r4, #128] ; 0x80
rtems_rfs_buffers_release (fs);
1e088: e1a00004 mov r0, r4 1e08c: ebfff0c5 bl 1a3a8 <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);
1e090: e5950000 ldr r0, [r5] 1e094: ebffb71f bl bd18 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
1e098: e2504000 subs r4, r0, #0
1e09c: 1a000002 bne 1e0ac <rtems_rfs_rtems_dir_open+0xa8> rtems_rfs_rtems_unlock (fs); return 0; }
1e0a0: e1a00004 mov r0, r4
1e0a4: e28dd028 add sp, sp, #40 ; 0x28
1e0a8: e8bd80f0 pop {r4, r5, r6, r7, pc}
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1e0ac: e3a00004 mov r0, #4 <== NOT EXECUTED 1e0b0: e3a01000 mov r1, #0 <== NOT EXECUTED 1e0b4: ebffd1dd bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1e0b8: e3500000 cmp r0, #0 <== NOT EXECUTED
iop->offset = 0;
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return 0;
1e0bc: 01a04000 moveq r4, r0 <== NOT EXECUTED 1e0c0: 0afffff6 beq 1e0a0 <rtems_rfs_rtems_dir_open+0x9c> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
1e0c4: e1a00004 mov r0, r4 <== NOT EXECUTED 1e0c8: ebffa3cf bl 700c <rtems_status_text> <== NOT EXECUTED 1e0cc: e1a01000 mov r1, r0 <== NOT EXECUTED 1e0d0: e59f0108 ldr r0, [pc, #264] ; 1e1e0 <rtems_rfs_rtems_dir_open+0x1dc><== NOT EXECUTED 1e0d4: eb0008f2 bl 204a4 <printf> <== NOT EXECUTED 1e0d8: e1a04006 mov r4, r6 <== NOT EXECUTED 1e0dc: eaffffef b 1e0a0 <rtems_rfs_rtems_dir_open+0x9c> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1e0e0: e3a00004 mov r0, #4 <== NOT EXECUTED 1e0e4: e3a01000 mov r1, #0 <== NOT EXECUTED 1e0e8: ebffd1d0 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1e0ec: e3500000 cmp r0, #0 <== NOT EXECUTED 1e0f0: 0affffd0 beq 1e038 <rtems_rfs_rtems_dir_open+0x34> <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
1e0f4: e1a00007 mov r0, r7 <== NOT EXECUTED 1e0f8: ebffa3c3 bl 700c <rtems_status_text> <== NOT EXECUTED 1e0fc: e1a01000 mov r1, r0 <== NOT EXECUTED 1e100: e59f00dc ldr r0, [pc, #220] ; 1e1e4 <rtems_rfs_rtems_dir_open+0x1e0><== NOT EXECUTED 1e104: eb0008e6 bl 204a4 <printf> <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1e108: e1a01006 mov r1, r6 <== NOT EXECUTED 1e10c: e1a00004 mov r0, r4 <== NOT EXECUTED 1e110: e1a0200d mov r2, sp <== NOT EXECUTED 1e114: e3a03001 mov r3, #1 <== NOT EXECUTED 1e118: ebffcb6a bl 10ec8 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
1e11c: e2506000 subs r6, r0, #0 <== NOT EXECUTED 1e120: 0affffcb beq 1e054 <rtems_rfs_rtems_dir_open+0x50> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1e124: e5945080 ldr r5, [r4, #128] ; 0x80 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
1e128: e1a00004 mov r0, r4 <== NOT EXECUTED 1e12c: ebfff09d bl 1a3a8 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
1e130: e5950000 ldr r0, [r5] <== NOT EXECUTED 1e134: ebffb6f7 bl bd18 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
1e138: e2504000 subs r4, r0, #0 <== NOT EXECUTED 1e13c: 1a000003 bne 1e150 <rtems_rfs_rtems_dir_open+0x14c> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
1e140: eb000513 bl 1f594 <__errno> <== NOT EXECUTED 1e144: e3e04000 mvn r4, #0 <== NOT EXECUTED 1e148: e5806000 str r6, [r0] <== NOT EXECUTED 1e14c: eaffffd3 b 1e0a0 <rtems_rfs_rtems_dir_open+0x9c> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1e150: e3a00004 mov r0, #4 <== NOT EXECUTED 1e154: e3a01000 mov r1, #0 <== NOT EXECUTED 1e158: ebffd1b4 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1e15c: e3500000 cmp r0, #0 <== NOT EXECUTED 1e160: 0afffff6 beq 1e140 <rtems_rfs_rtems_dir_open+0x13c> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
1e164: e1a00004 mov r0, r4 <== NOT EXECUTED 1e168: ebffa3a7 bl 700c <rtems_status_text> <== NOT EXECUTED 1e16c: e1a01000 mov r1, r0 <== NOT EXECUTED 1e170: e59f0068 ldr r0, [pc, #104] ; 1e1e0 <rtems_rfs_rtems_dir_open+0x1dc><== NOT EXECUTED 1e174: eb0008ca bl 204a4 <printf> <== NOT EXECUTED 1e178: eafffff0 b 1e140 <rtems_rfs_rtems_dir_open+0x13c> <== NOT EXECUTED
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
{
rtems_rfs_inode_close (fs, &inode);
1e17c: e1a00004 mov r0, r4 <== NOT EXECUTED 1e180: ebffcbca bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1e184: e5945080 ldr r5, [r4, #128] ; 0x80 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
1e188: e1a00004 mov r0, r4 <== NOT EXECUTED 1e18c: ebfff085 bl 1a3a8 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
1e190: e5950000 ldr r0, [r5] <== NOT EXECUTED 1e194: ebffb6df bl bd18 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
1e198: e2504000 subs r4, r0, #0 <== NOT EXECUTED 1e19c: 1a000004 bne 1e1b4 <rtems_rfs_rtems_dir_open+0x1b0> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
1e1a0: eb0004fb bl 1f594 <__errno> <== NOT EXECUTED 1e1a4: e3a03014 mov r3, #20 <== NOT EXECUTED 1e1a8: e5803000 str r3, [r0] <== NOT EXECUTED 1e1ac: e3e04000 mvn r4, #0 <== NOT EXECUTED 1e1b0: eaffffba b 1e0a0 <rtems_rfs_rtems_dir_open+0x9c> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1e1b4: e3a00004 mov r0, #4 <== NOT EXECUTED 1e1b8: e3a01000 mov r1, #0 <== NOT EXECUTED 1e1bc: ebffd19b bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1e1c0: e3500000 cmp r0, #0 <== NOT EXECUTED 1e1c4: 0afffff5 beq 1e1a0 <rtems_rfs_rtems_dir_open+0x19c> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
1e1c8: e1a00004 mov r0, r4 <== NOT EXECUTED 1e1cc: ebffa38e bl 700c <rtems_status_text> <== NOT EXECUTED 1e1d0: e1a01000 mov r1, r0 <== NOT EXECUTED 1e1d4: e59f0004 ldr r0, [pc, #4] ; 1e1e0 <rtems_rfs_rtems_dir_open+0x1dc><== NOT EXECUTED 1e1d8: eb0008b1 bl 204a4 <printf> <== NOT EXECUTED 1e1dc: eaffffef b 1e1a0 <rtems_rfs_rtems_dir_open+0x19c> <== NOT EXECUTED
0001de20 <rtems_rfs_rtems_dir_read>:
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);
1de20: e5903024 ldr r3, [r0, #36] ; 0x24
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
1de24: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
1de28: e5937008 ldr r7, [r3, #8]
.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 };
1de2c: e5973080 ldr r3, [r7, #128] ; 0x80
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
1de30: e1a08001 mov r8, r1
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
1de34: e3a01000 mov r1, #0 1de38: e1a04000 mov r4, r0 1de3c: e24dd034 sub sp, sp, #52 ; 0x34 1de40: e1a05002 mov r5, r2 1de44: e5930000 ldr r0, [r3] 1de48: e1a02001 mov r2, r1
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo); rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
1de4c: e5946018 ldr r6, [r4, #24] 1de50: ebffb767 bl bbf4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
1de54: e250a000 subs sl, r0, #0
1de58: 1a00003b bne 1df4c <rtems_rfs_rtems_dir_read+0x12c>
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1de5c: e1a01006 mov r1, r6 1de60: e1a00007 mov r0, r7 1de64: e28d2008 add r2, sp, #8 1de68: e3a03001 mov r3, #1 1de6c: ebffcc15 bl 10ec8 <rtems_rfs_inode_open>
if (rc)
1de70: e2506000 subs r6, r0, #0
1de74: 1a000045 bne 1df90 <rtems_rfs_rtems_dir_read+0x170>
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
1de78: e59f9178 ldr r9, [pc, #376] ; 1dff8 <rtems_rfs_rtems_dir_read+0x1d8> 1de7c: e0893995 umull r3, r9, r5, r9
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
1de80: e1b09429 lsrs r9, r9, #8 1de84: 01a05009 moveq r5, r9
1de88: 0a000017 beq 1deec <rtems_rfs_rtems_dir_read+0xcc>
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
1de8c: e994000c ldmib 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,
1de90: e1a05006 mov r5, r6 1de94: e28da030 add sl, sp, #48 ; 0x30 1de98: ea000009 b 1dec4 <rtems_rfs_rtems_dir_read+0xa4>
if (rc == ENOENT)
{
rc = 0;
break;
}
if (rc > 0)
1de9c: e3500000 cmp r0, #0
1dea0: ca000045 bgt 1dfbc <rtems_rfs_rtems_dir_read+0x19c>
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
1dea4: e994000c ldmib r4, {r2, r3}
1dea8: e59d1030 ldr r1, [sp, #48] ; 0x30
1deac: e0922001 adds r2, r2, r1
1deb0: e2a33000 adc r3, r3, #0
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
1deb4: e1560009 cmp r6, r9
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
1deb8: 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,
1debc: e2855e11 add r5, r5, #272 ; 0x110
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
1dec0: 0a000009 beq 1deec <rtems_rfs_rtems_dir_read+0xcc>
* 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,
1dec4: e088c005 add ip, r8, r5
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
1dec8: e1a00007 mov r0, r7 1decc: e28d1008 add r1, sp, #8 1ded0: e58dc000 str ip, [sp] 1ded4: e58da004 str sl, [sp, #4] 1ded8: ebfff536 bl 1b3b8 <rtems_rfs_dir_read>
if (rc == ENOENT)
1dedc: e3500002 cmp r0, #2
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
1dee0: e1a0b000 mov fp, r0
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
1dee4: e2866001 add r6, r6, #1
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
if (rc == ENOENT)
1dee8: 1affffeb bne 1de9c <rtems_rfs_rtems_dir_read+0x7c>
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
1deec: e28d1008 add r1, sp, #8 1def0: e1a00007 mov r0, r7 1def4: ebffcc6d bl 110b0 <rtems_rfs_inode_close>
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1def8: e5974080 ldr r4, [r7, #128] ; 0x80
rtems_rfs_buffers_release (fs);
1defc: e1a00007 mov r0, r7 1df00: ebfff128 bl 1a3a8 <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);
1df04: e5940000 ldr r0, [r4] 1df08: ebffb782 bl bd18 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
1df0c: e2504000 subs r4, r0, #0
1df10: 1a000002 bne 1df20 <rtems_rfs_rtems_dir_read+0x100>
rtems_rfs_rtems_unlock (fs);
return bytes_transferred;
}
1df14: e1a00005 mov r0, r5
1df18: e28dd034 add sp, sp, #52 ; 0x34
1df1c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1df20: e3a00004 mov r0, #4 <== NOT EXECUTED 1df24: e3a01000 mov r1, #0 <== NOT EXECUTED 1df28: ebffd240 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1df2c: e3500000 cmp r0, #0 <== NOT EXECUTED 1df30: 0afffff7 beq 1df14 <rtems_rfs_rtems_dir_read+0xf4> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
1df34: e1a00004 mov r0, r4 <== NOT EXECUTED 1df38: ebffa433 bl 700c <rtems_status_text> <== NOT EXECUTED 1df3c: e1a01000 mov r1, r0 <== NOT EXECUTED 1df40: e59f00b4 ldr r0, [pc, #180] ; 1dffc <rtems_rfs_rtems_dir_read+0x1dc><== NOT EXECUTED 1df44: eb000956 bl 204a4 <printf> <== NOT EXECUTED 1df48: eafffff1 b 1df14 <rtems_rfs_rtems_dir_read+0xf4> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1df4c: e3a00004 mov r0, #4 <== NOT EXECUTED 1df50: e3a01000 mov r1, #0 <== NOT EXECUTED 1df54: ebffd235 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1df58: e3500000 cmp r0, #0 <== NOT EXECUTED 1df5c: 0affffbe beq 1de5c <rtems_rfs_rtems_dir_read+0x3c> <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
1df60: e1a0000a mov r0, sl <== NOT EXECUTED 1df64: ebffa428 bl 700c <rtems_status_text> <== NOT EXECUTED 1df68: e1a01000 mov r1, r0 <== NOT EXECUTED 1df6c: e59f008c ldr r0, [pc, #140] ; 1e000 <rtems_rfs_rtems_dir_read+0x1e0><== NOT EXECUTED 1df70: eb00094b bl 204a4 <printf> <== NOT EXECUTED
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1df74: e1a01006 mov r1, r6 <== NOT EXECUTED 1df78: e1a00007 mov r0, r7 <== NOT EXECUTED 1df7c: e28d2008 add r2, sp, #8 <== NOT EXECUTED 1df80: e3a03001 mov r3, #1 <== NOT EXECUTED 1df84: ebffcbcf bl 10ec8 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
1df88: e2506000 subs r6, r0, #0 <== NOT EXECUTED 1df8c: 0affffb9 beq 1de78 <rtems_rfs_rtems_dir_read+0x58> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1df90: e5974080 ldr r4, [r7, #128] ; 0x80 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
1df94: e1a00007 mov r0, r7 <== NOT EXECUTED 1df98: ebfff102 bl 1a3a8 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
1df9c: e5940000 ldr r0, [r4] <== NOT EXECUTED 1dfa0: ebffb75c bl bd18 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
1dfa4: e2504000 subs r4, r0, #0 <== NOT EXECUTED 1dfa8: 1a000007 bne 1dfcc <rtems_rfs_rtems_dir_read+0x1ac> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
1dfac: eb000578 bl 1f594 <__errno> <== NOT EXECUTED 1dfb0: e3e05000 mvn r5, #0 <== NOT EXECUTED 1dfb4: e5806000 str r6, [r0] <== NOT EXECUTED 1dfb8: eaffffd5 b 1df14 <rtems_rfs_rtems_dir_read+0xf4> <== NOT EXECUTED
rc = 0;
break;
}
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
1dfbc: eb000574 bl 1f594 <__errno> <== NOT EXECUTED 1dfc0: e3e05000 mvn r5, #0 <== NOT EXECUTED 1dfc4: e580b000 str fp, [r0] <== NOT EXECUTED 1dfc8: eaffffc7 b 1deec <rtems_rfs_rtems_dir_read+0xcc> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1dfcc: e3a00004 mov r0, #4 <== NOT EXECUTED 1dfd0: e3a01000 mov r1, #0 <== NOT EXECUTED 1dfd4: ebffd215 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1dfd8: e3500000 cmp r0, #0 <== NOT EXECUTED 1dfdc: 0afffff2 beq 1dfac <rtems_rfs_rtems_dir_read+0x18c> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
1dfe0: e1a00004 mov r0, r4 <== NOT EXECUTED 1dfe4: ebffa408 bl 700c <rtems_status_text> <== NOT EXECUTED 1dfe8: e1a01000 mov r1, r0 <== NOT EXECUTED 1dfec: e59f0008 ldr r0, [pc, #8] ; 1dffc <rtems_rfs_rtems_dir_read+0x1dc><== NOT EXECUTED 1dff0: eb00092b bl 204a4 <printf> <== NOT EXECUTED 1dff4: eaffffec b 1dfac <rtems_rfs_rtems_dir_read+0x18c> <== NOT EXECUTED
00011ee4 <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)
{
11ee4: 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);
11ee8: e590302c ldr r3, [r0, #44] ; 0x2c 11eec: 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)
{
11ef0: e24dd028 sub sp, sp, #40 ; 0x28 11ef4: 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);
11ef8: e5941020 ldr r1, [r4, #32] 11efc: e1a00005 mov r0, r5 11f00: e1a0200d mov r2, sp 11f04: e3a03001 mov r3, #1 11f08: ebfffbee bl 10ec8 <rtems_rfs_inode_open>
if (rc == 0) {
11f0c: e2506000 subs r6, r0, #0
11f10: 1a00000a bne 11f40 <rtems_rfs_rtems_eval_path+0x5c>
rtems_filesystem_eval_path_generic (
11f14: e59f2054 ldr r2, [pc, #84] ; 11f70 <rtems_rfs_rtems_eval_path+0x8c> 11f18: e1a00004 mov r0, r4 11f1c: e1a0100d mov r1, sp 11f20: eb001154 bl 16478 <rtems_filesystem_eval_path_generic>
ctx,
&inode,
&rtems_rfs_rtems_eval_config
);
rc = rtems_rfs_inode_close (fs, &inode);
11f24: e1a00005 mov r0, r5 11f28: e1a0100d mov r1, sp 11f2c: ebfffc5f bl 110b0 <rtems_rfs_inode_close>
if (rc != 0) {
11f30: e2505000 subs r5, r0, #0
11f34: 1a000007 bne 11f58 <rtems_rfs_rtems_eval_path+0x74>
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: opening inode", rc)
);
}
}
11f38: e28dd028 add sp, sp, #40 ; 0x28
11f3c: e8bd8070 pop {r4, r5, r6, pc}
);
}
} else {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: opening inode", rc)
11f40: eb003593 bl 1f594 <__errno> <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
);
}
} else {
rtems_filesystem_eval_path_error (
11f44: e3e01000 mvn r1, #0 <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: opening inode", rc)
11f48: e5806000 str r6, [r0] <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
);
}
} else {
rtems_filesystem_eval_path_error (
11f4c: e1a00004 mov r0, r4 <== NOT EXECUTED 11f50: ebffda58 bl 88b8 <rtems_filesystem_eval_path_error> <== NOT EXECUTED 11f54: eafffff7 b 11f38 <rtems_rfs_rtems_eval_path+0x54> <== NOT EXECUTED
);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc != 0) {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
11f58: eb00358d bl 1f594 <__errno> <== NOT EXECUTED
&inode,
&rtems_rfs_rtems_eval_config
);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc != 0) {
rtems_filesystem_eval_path_error (
11f5c: e3e01000 mvn r1, #0 <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
11f60: e5805000 str r5, [r0] <== NOT EXECUTED
&inode,
&rtems_rfs_rtems_eval_config
);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc != 0) {
rtems_filesystem_eval_path_error (
11f64: e1a00004 mov r0, r4 <== NOT EXECUTED 11f68: ebffda52 bl 88b8 <rtems_filesystem_eval_path_error> <== NOT EXECUTED 11f6c: eafffff1 b 11f38 <rtems_rfs_rtems_eval_path+0x54> <== NOT EXECUTED
00011f74 <rtems_rfs_rtems_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
11f74: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
11f78: e1a04001 mov r4, 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);
11f7c: e591100c ldr r1, [r1, #12]
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
11f80: e5d18005 ldrb r8, [r1, #5] 11f84: e5d15004 ldrb r5, [r1, #4]
* @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);
11f88: e5d16003 ldrb r6, [r1, #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;
11f8c: e5d1e006 ldrb lr, [r1, #6] 11f90: e5d1c007 ldrb ip, [r1, #7]
* @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);
11f94: e5d17002 ldrb r7, [r1, #2]
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
11f98: e1a08808 lsl r8, r8, #16
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(
11f9c: e1888c05 orr r8, r8, r5, lsl #24
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
11fa0: e24dd014 sub sp, sp, #20
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(
11fa4: e1a08828 lsr r8, r8, #16
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
11fa8: e1a0a002 mov sl, r2 11fac: e1a05003 mov r5, r3
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(
11fb0: e1862407 orr r2, r6, r7, lsl #8 11fb4: e3a01001 mov r1, #1 11fb8: e18c340e orr r3, ip, lr, lsl #8
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
11fbc: e1a06000 mov r6, r0
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(
11fc0: e58d8000 str r8, [sp] 11fc4: eb00111d bl 16440 <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) {
11fc8: e3500000 cmp r0, #0
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
11fcc: 03a00001 moveq r0, #1
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) {
11fd0: 0a00000f beq 12014 <rtems_rfs_rtems_eval_token+0xa0>
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
11fd4: e3550001 cmp r5, #1
11fd8: 0a00000f beq 1201c <rtems_rfs_rtems_eval_token+0xa8>
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);
11fdc: e596302c ldr r3, [r6, #44] ; 0x2c 11fe0: e5937008 ldr r7, [r3, #8]
rtems_rfs_ino entry_ino;
uint32_t entry_doff;
int rc = rtems_rfs_dir_lookup_ino (
11fe4: e28dc008 add ip, sp, #8 11fe8: e58dc000 str ip, [sp] 11fec: e1a00007 mov r0, r7 11ff0: e28dc00c add ip, sp, #12 11ff4: e1a01004 mov r1, r4 11ff8: e1a0200a mov r2, sl 11ffc: e1a03005 mov r3, r5 12000: e58dc004 str ip, [sp, #4] 12004: eb002179 bl 1a5f0 <rtems_rfs_dir_lookup_ino>
tokenlen,
&entry_ino,
&entry_doff
);
if (rc == 0) {
12008: e3500000 cmp r0, #0
* rtems_rfs_rtems_eval_path().
*/
memset (inode, 0, sizeof(*inode));
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
1200c: 13a00002 movne r0, #2
tokenlen,
&entry_ino,
&entry_doff
);
if (rc == 0) {
12010: 0a000008 beq 12038 <rtems_rfs_rtems_eval_token+0xc4>
}
}
}
return status;
}
12014: e28dd014 add sp, sp, #20
12018: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
1201c: e5da3000 ldrb r3, [sl]
12020: e353002e cmp r3, #46 ; 0x2e
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
12024: 03a03000 moveq r3, #0 12028: 0586300c streq r3, [r6, #12]
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
1202c: 01a00005 moveq r0, r5
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
12030: 1affffe9 bne 11fdc <rtems_rfs_rtems_eval_token+0x68>
12034: eafffff6 b 12014 <rtems_rfs_rtems_eval_token+0xa0>
&entry_ino,
&entry_doff
);
if (rc == 0) {
rc = rtems_rfs_inode_close (fs, inode);
12038: e1a00007 mov r0, r7 1203c: e1a01004 mov r1, r4 12040: ebfffc1a bl 110b0 <rtems_rfs_inode_close>
if (rc == 0) {
12044: e3500000 cmp r0, #0
12048: 0a000005 beq 12064 <rtems_rfs_rtems_eval_token+0xf0>
if (rc != 0) {
/*
* This prevents the rtems_rfs_inode_close() from doing something in
* rtems_rfs_rtems_eval_path().
*/
memset (inode, 0, sizeof(*inode));
1204c: e1a00004 mov r0, r4 <== NOT EXECUTED 12050: e3a01000 mov r1, #0 <== NOT EXECUTED 12054: e3a02028 mov r2, #40 ; 0x28 <== NOT EXECUTED 12058: eb0038a0 bl 202e0 <memset> <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
1205c: e3a00001 mov r0, #1 <== NOT EXECUTED 12060: eaffffeb b 12014 <rtems_rfs_rtems_eval_token+0xa0> <== NOT EXECUTED
);
if (rc == 0) {
rc = rtems_rfs_inode_close (fs, inode);
if (rc == 0) {
rc = rtems_rfs_inode_open (fs, entry_ino, inode, true);
12064: e1a00007 mov r0, r7 12068: e59d1008 ldr r1, [sp, #8] 1206c: e1a02004 mov r2, r4 12070: e3a03001 mov r3, #1 12074: ebfffb93 bl 10ec8 <rtems_rfs_inode_open>
}
if (rc != 0) {
12078: e2508000 subs r8, r0, #0
1207c: 1afffff2 bne 1204c <rtems_rfs_rtems_eval_token+0xd8>
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)
12080: e1a00004 mov r0, r4 12084: ebfffdd9 bl 117f0 <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);
12088: e5965004 ldr r5, [r6, #4] 1208c: e2755001 rsbs r5, r5, #1 12090: 33a05000 movcc r5, #0
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
12094: e3500003 cmp r0, #3
static inline int rtems_filesystem_eval_path_get_flags(
const rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->flags;
12098: e5963010 ldr r3, [r6, #16]
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
1209c: e586800c str r8, [r6, #12]
120a0: 1a00001b bne 12114 <rtems_rfs_rtems_eval_token+0x1a0>
120a4: e3130010 tst r3, #16
120a8: 1a000001 bne 120b4 <rtems_rfs_rtems_eval_token+0x140>
120ac: e3550000 cmp r5, #0
120b0: 1a000017 bne 12114 <rtems_rfs_rtems_eval_token+0x1a0>
rtems_filesystem_eval_path_context_t* ctx,
rtems_rfs_file_system* fs,
rtems_rfs_ino ino
)
{
size_t len = MAXPATHLEN;
120b4: e3a05b01 mov r5, #1024 ; 0x400
char *link = malloc(len + 1);
120b8: e59f00c0 ldr r0, [pc, #192] ; 12180 <rtems_rfs_rtems_eval_token+0x20c>
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);
120bc: 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;
120c0: e58d5010 str r5, [sp, #16]
char *link = malloc(len + 1);
120c4: ebffd5da bl 7834 <malloc>
if (link != NULL) {
120c8: e2504000 subs r4, r0, #0
120cc: 0a000026 beq 1216c <rtems_rfs_rtems_eval_token+0x1f8>
int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);
120d0: e28dc010 add ip, sp, #16 120d4: e1a00007 mov r0, r7 120d8: e1a01008 mov r1, r8 120dc: e1a02004 mov r2, r4 120e0: e1a03005 mov r3, r5 120e4: e58dc000 str ip, [sp] 120e8: eb002e08 bl 1d910 <rtems_rfs_symlink_read>
if (rc == 0) {
120ec: e3500000 cmp r0, #0
rtems_filesystem_eval_path_recursive (ctx, link, len);
120f0: e1a00006 mov r0, r6
char *link = malloc(len + 1);
if (link != NULL) {
int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);
if (rc == 0) {
120f4: 1a000019 bne 12160 <rtems_rfs_rtems_eval_token+0x1ec>
rtems_filesystem_eval_path_recursive (ctx, link, len);
120f8: e1a01004 mov r1, r4 120fc: e59d2010 ldr r2, [sp, #16] 12100: ebffdae7 bl 8ca4 <rtems_filesystem_eval_path_recursive>
} else {
rtems_filesystem_eval_path_error (ctx, 0);
}
free(link);
12104: e1a00004 mov r0, r4 12108: ebffd44a bl 7238 <free>
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
1210c: e3a00001 mov r0, #1 12110: eaffffbf b 12014 <rtems_rfs_rtems_eval_token+0xa0>
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;
12114: e2860018 add r0, r6, #24 12118: e1a01004 mov r1, r4 1211c: eb000192 bl 1276c <rtems_rfs_rtems_set_handlers> 12120: e3500000 cmp r0, #0
12124: 0a000005 beq 12140 <rtems_rfs_rtems_eval_token+0x1cc>
if (rc == 0) {
rtems_rfs_rtems_set_pathloc_ino (currentloc, entry_ino);
12128: e59d3008 ldr r3, [sp, #8] 1212c: e5863020 str r3, [r6, #32]
rtems_rfs_rtems_set_pathloc_doff (currentloc, entry_doff);
12130: e59d300c ldr r3, [sp, #12]
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
12134: e1a00005 mov r0, r5
rtems_rfs_rtems_follow_link (ctx, fs, entry_ino);
} else {
rc = rtems_rfs_rtems_set_handlers (currentloc, inode) ? 0 : EIO;
if (rc == 0) {
rtems_rfs_rtems_set_pathloc_ino (currentloc, entry_ino);
rtems_rfs_rtems_set_pathloc_doff (currentloc, entry_doff);
12138: e5863024 str r3, [r6, #36] ; 0x24 1213c: eaffffb4 b 12014 <rtems_rfs_rtems_eval_token+0xa0>
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: set handlers", rc)
12140: eb003513 bl 1f594 <__errno> <== NOT EXECUTED 12144: e3a03005 mov r3, #5 <== NOT EXECUTED 12148: e5803000 str r3, [r0] <== NOT EXECUTED
if (!terminal) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
1214c: e3e01000 mvn r1, #0 <== NOT EXECUTED 12150: e1a00006 mov r0, r6 <== NOT EXECUTED 12154: ebffd9d7 bl 88b8 <rtems_filesystem_eval_path_error> <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
12158: e3a00001 mov r0, #1 <== NOT EXECUTED 1215c: eaffffac b 12014 <rtems_rfs_rtems_eval_token+0xa0> <== NOT EXECUTED
int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);
if (rc == 0) {
rtems_filesystem_eval_path_recursive (ctx, link, len);
} else {
rtems_filesystem_eval_path_error (ctx, 0);
12160: e3a01000 mov r1, #0 <== NOT EXECUTED 12164: ebffd9d3 bl 88b8 <rtems_filesystem_eval_path_error> <== NOT EXECUTED 12168: eaffffe5 b 12104 <rtems_rfs_rtems_eval_token+0x190> <== NOT EXECUTED
}
free(link);
} else {
rtems_filesystem_eval_path_error (ctx, ENOMEM);
1216c: e1a00006 mov r0, r6 <== NOT EXECUTED 12170: e3a0100c mov r1, #12 <== NOT EXECUTED 12174: ebffd9cf bl 88b8 <rtems_filesystem_eval_path_error> <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
12178: e3a00001 mov r0, #1 <== NOT EXECUTED 1217c: eaffffa4 b 12014 <rtems_rfs_rtems_eval_token+0xa0> <== NOT EXECUTED
00011c7c <rtems_rfs_rtems_fchmod>:
}
static int
rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
11c7c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
11c80: e5902014 ldr r2, [r0, #20] <== NOT EXECUTED 11c84: e5924008 ldr r4, [r2, #8] <== NOT EXECUTED
}
static int
rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
11c88: e1a03000 mov r3, r0 <== NOT EXECUTED 11c8c: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED 11c90: e1a05001 mov r5, r1 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FCHMOD))
printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
ino, mode);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
11c94: e1a00004 mov r0, r4 <== NOT EXECUTED 11c98: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED 11c9c: e1a0200d mov r2, sp <== NOT EXECUTED 11ca0: e3a03001 mov r3, #1 <== NOT EXECUTED 11ca4: ebfffc87 bl 10ec8 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
11ca8: e2506000 subs r6, r0, #0 <== NOT EXECUTED 11cac: 0a000005 beq 11cc8 <rtems_rfs_rtems_fchmod+0x4c> <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("fchmod: opening inode", rc);
11cb0: eb003637 bl 1f594 <__errno> <== NOT EXECUTED 11cb4: e5806000 str r6, [r0] <== NOT EXECUTED 11cb8: e3e03000 mvn r3, #0 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
}
return 0;
}
11cbc: e1a00003 mov r0, r3 <== NOT EXECUTED
11cc0: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
11cc4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
11cc8: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 11ccc: e5d32002 ldrb r2, [r3, #2] <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
11cd0: e1a02402 lsl r2, r2, #8 <== NOT EXECUTED 11cd4: e2022a0f and r2, r2, #61440 ; 0xf000 <== NOT EXECUTED
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
11cd8: e1a05a05 lsl r5, r5, #20 <== NOT EXECUTED 11cdc: e1825a25 orr r5, r2, r5, lsr #20 <== NOT EXECUTED 11ce0: e1a05805 lsl r5, r5, #16 <== NOT EXECUTED
* @prarm mode The mode.
*/
static inline void
rtems_rfs_inode_set_mode (rtems_rfs_inode_handle* handle, uint16_t mode)
{
rtems_rfs_write_u16 (&handle->node->mode, mode);
11ce4: e1a02c25 lsr r2, r5, #24 <== NOT EXECUTED 11ce8: e5c32002 strb r2, [r3, #2] <== NOT EXECUTED 11cec: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 11cf0: e1a05825 lsr r5, r5, #16 <== NOT EXECUTED 11cf4: e5c35003 strb r5, [r3, #3] <== NOT EXECUTED
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
11cf8: e1a00004 mov r0, r4 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
11cfc: e3a03001 mov r3, #1 <== NOT EXECUTED 11d00: e1a0100d mov r1, sp <== NOT EXECUTED 11d04: e5cd3010 strb r3, [sp, #16] <== NOT EXECUTED 11d08: ebfffce8 bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
11d0c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
}
return 0;
11d10: d1a03006 movle r3, r6 <== NOT EXECUTED
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)
11d14: daffffe8 ble 11cbc <rtems_rfs_rtems_fchmod+0x40> <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
11d18: eb00361d bl 1f594 <__errno> <== NOT EXECUTED 11d1c: e3e03000 mvn r3, #0 <== NOT EXECUTED 11d20: e5804000 str r4, [r0] <== NOT EXECUTED 11d24: eaffffe4 b 11cbc <rtems_rfs_rtems_fchmod+0x40> <== NOT EXECUTED
0001273c <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));
1273c: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
12740: e92d4010 push {r4, lr} <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
12744: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 12748: eb001ef2 bl 1a318 <rtems_rfs_buffer_sync> <== NOT EXECUTED
if (rc)
1274c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
return 0;
12750: 01a03004 moveq r3, r4 <== NOT EXECUTED
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
if (rc)
12754: 0a000002 beq 12764 <rtems_rfs_rtems_fdatasync+0x28> <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
12758: eb00338d bl 1f594 <__errno> <== NOT EXECUTED 1275c: e5804000 str r4, [r0] <== NOT EXECUTED 12760: e3e03000 mvn r3, #0 <== NOT EXECUTED
return 0;
}
12764: e1a00003 mov r0, r3 <== NOT EXECUTED
12768: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0001e5fc <rtems_rfs_rtems_file_close>:
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
1e5fc: e92d4070 push {r4, r5, r6, lr}
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
1e600: e590501c ldr r5, [r0, #28]
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
1e604: e595301c ldr r3, [r5, #28] 1e608: e5934098 ldr r4, [r3, #152] ; 0x98
.fstat_h = rtems_rfs_rtems_fstat, .ftruncate_h = rtems_rfs_rtems_file_ftruncate, .fsync_h = rtems_rfs_rtems_fdatasync, .fdatasync_h = rtems_rfs_rtems_fdatasync, .fcntl_h = rtems_filesystem_default_fcntl };
1e60c: e5943080 ldr r3, [r4, #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);
1e610: e3a01000 mov r1, #0 1e614: e5930000 ldr r0, [r3] 1e618: e1a02001 mov r2, r1 1e61c: ebffb574 bl bbf4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
1e620: e2506000 subs r6, r0, #0
1e624: 1a000010 bne 1e66c <rtems_rfs_rtems_file_close+0x70>
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_CLOSE))
printf("rtems-rfs: file-close: handle:%p\n", file);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_file_close (fs, file);
1e628: e1a01005 mov r1, r5 1e62c: e1a00004 mov r0, r4 1e630: ebfff59d bl 1bcac <rtems_rfs_file_close>
if (rc > 0)
1e634: e2505000 subs r5, r0, #0
1e638: da000002 ble 1e648 <rtems_rfs_rtems_file_close+0x4c>
rc = rtems_rfs_rtems_error ("file-close: file close", rc);
1e63c: eb0003d4 bl 1f594 <__errno> <== NOT EXECUTED 1e640: e5805000 str r5, [r0] <== NOT EXECUTED 1e644: e3e05000 mvn r5, #0 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1e648: e5946080 ldr r6, [r4, #128] ; 0x80
rtems_rfs_buffers_release (fs);
1e64c: e1a00004 mov r0, r4 1e650: ebffef54 bl 1a3a8 <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);
1e654: e5960000 ldr r0, [r6] 1e658: ebffb5ae bl bd18 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
1e65c: e2504000 subs r4, r0, #0
1e660: 1a00000c bne 1e698 <rtems_rfs_rtems_file_close+0x9c>
rtems_rfs_rtems_unlock (fs);
return rc;
}
1e664: e1a00005 mov r0, r5
1e668: e8bd8070 pop {r4, r5, r6, pc}
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1e66c: e3a00004 mov r0, #4 <== NOT EXECUTED 1e670: e3a01000 mov r1, #0 <== NOT EXECUTED 1e674: ebffd06d bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1e678: e3500000 cmp r0, #0 <== NOT EXECUTED 1e67c: 0affffe9 beq 1e628 <rtems_rfs_rtems_file_close+0x2c> <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
1e680: e1a00006 mov r0, r6 <== NOT EXECUTED 1e684: ebffa260 bl 700c <rtems_status_text> <== NOT EXECUTED 1e688: e1a01000 mov r1, r0 <== NOT EXECUTED 1e68c: e59f0034 ldr r0, [pc, #52] ; 1e6c8 <rtems_rfs_rtems_file_close+0xcc><== NOT EXECUTED 1e690: eb000783 bl 204a4 <printf> <== NOT EXECUTED 1e694: eaffffe3 b 1e628 <rtems_rfs_rtems_file_close+0x2c> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1e698: e3a00004 mov r0, #4 <== NOT EXECUTED 1e69c: e3a01000 mov r1, #0 <== NOT EXECUTED 1e6a0: ebffd062 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1e6a4: e3500000 cmp r0, #0 <== NOT EXECUTED 1e6a8: 0affffed beq 1e664 <rtems_rfs_rtems_file_close+0x68> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
1e6ac: e1a00004 mov r0, r4 <== NOT EXECUTED
1e6b0: ebffa255 bl 700c <rtems_status_text> <== NOT EXECUTED
1e6b4: e1a01000 mov r1, r0 <== NOT EXECUTED
1e6b8: e59f000c ldr r0, [pc, #12] ; 1e6cc <rtems_rfs_rtems_file_close+0xd0><== NOT EXECUTED
1e6bc: eb000778 bl 204a4 <printf> <== NOT EXECUTED
1e6c0: e1a00005 mov r0, r5 <== NOT EXECUTED
1e6c4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
0001e3d8 <rtems_rfs_rtems_file_ftruncate>:
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
1e3d8: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
1e3dc: 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));
1e3e0: e594301c ldr r3, [r4, #28]
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1e3e4: e5933098 ldr r3, [r3, #152] ; 0x98
.fstat_h = rtems_rfs_rtems_fstat, .ftruncate_h = rtems_rfs_rtems_file_ftruncate, .fsync_h = rtems_rfs_rtems_fdatasync, .fdatasync_h = rtems_rfs_rtems_fdatasync, .fcntl_h = rtems_filesystem_default_fcntl };
1e3e8: e5933080 ldr r3, [r3, #128] ; 0x80
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
1e3ec: e1a06001 mov r6, r1
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
1e3f0: e3a01000 mov r1, #0 1e3f4: e1a07002 mov r7, r2 1e3f8: e5930000 ldr r0, [r3] 1e3fc: e1a02001 mov r2, r1 1e400: ebffb5fb bl bbf4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
1e404: e2505000 subs r5, r0, #0
1e408: 1a000012 bne 1e458 <rtems_rfs_rtems_file_ftruncate+0x80>
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));
rc = rtems_rfs_file_set_size (file, length);
1e40c: e1a00004 mov r0, r4 1e410: e1a01006 mov r1, r6 1e414: e1a02007 mov r2, r7 1e418: ebfff83b bl 1c50c <rtems_rfs_file_set_size>
if (rc)
1e41c: e2505000 subs r5, r0, #0
1e420: 0a000002 beq 1e430 <rtems_rfs_rtems_file_ftruncate+0x58>
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
1e424: eb00045a bl 1f594 <__errno> <== NOT EXECUTED 1e428: e5805000 str r5, [r0] <== NOT EXECUTED 1e42c: e3e05000 mvn r5, #0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
1e430: e594301c ldr r3, [r4, #28] 1e434: e5930098 ldr r0, [r3, #152] ; 0x98
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1e438: e5904080 ldr r4, [r0, #128] ; 0x80
rtems_rfs_buffers_release (fs);
1e43c: ebffefd9 bl 1a3a8 <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);
1e440: e5940000 ldr r0, [r4] 1e444: ebffb633 bl bd18 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
1e448: e2504000 subs r4, r0, #0
1e44c: 1a00000c bne 1e484 <rtems_rfs_rtems_file_ftruncate+0xac>
return rc;
}
1e450: e1a00005 mov r0, r5
1e454: e8bd80f0 pop {r4, r5, r6, r7, pc}
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1e458: e3a00004 mov r0, #4 <== NOT EXECUTED 1e45c: e3a01000 mov r1, #0 <== NOT EXECUTED 1e460: ebffd0f2 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1e464: e3500000 cmp r0, #0 <== NOT EXECUTED 1e468: 0affffe7 beq 1e40c <rtems_rfs_rtems_file_ftruncate+0x34> <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
1e46c: e1a00005 mov r0, r5 <== NOT EXECUTED 1e470: ebffa2e5 bl 700c <rtems_status_text> <== NOT EXECUTED 1e474: e1a01000 mov r1, r0 <== NOT EXECUTED 1e478: e59f0034 ldr r0, [pc, #52] ; 1e4b4 <rtems_rfs_rtems_file_ftruncate+0xdc><== NOT EXECUTED 1e47c: eb000808 bl 204a4 <printf> <== NOT EXECUTED 1e480: eaffffe1 b 1e40c <rtems_rfs_rtems_file_ftruncate+0x34> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1e484: e3a00004 mov r0, #4 <== NOT EXECUTED 1e488: e3a01000 mov r1, #0 <== NOT EXECUTED 1e48c: ebffd0e7 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1e490: e3500000 cmp r0, #0 <== NOT EXECUTED 1e494: 0affffed beq 1e450 <rtems_rfs_rtems_file_ftruncate+0x78> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
1e498: e1a00004 mov r0, r4 <== NOT EXECUTED
1e49c: ebffa2da bl 700c <rtems_status_text> <== NOT EXECUTED
1e4a0: e1a01000 mov r1, r0 <== NOT EXECUTED
1e4a4: e59f000c ldr r0, [pc, #12] ; 1e4b8 <rtems_rfs_rtems_file_ftruncate+0xe0><== NOT EXECUTED
1e4a8: eb0007fd bl 204a4 <printf> <== NOT EXECUTED
1e4ac: e1a00005 mov r0, r5 <== NOT EXECUTED
1e4b0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
0001e4bc <rtems_rfs_rtems_file_lseek>:
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
1e4bc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
1e4c0: e590501c ldr r5, [r0, #28]
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
1e4c4: 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));
1e4c8: e595001c ldr r0, [r5, #28]
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1e4cc: e5900098 ldr r0, [r0, #152] ; 0x98
.fstat_h = rtems_rfs_rtems_fstat, .ftruncate_h = rtems_rfs_rtems_file_ftruncate, .fsync_h = rtems_rfs_rtems_fdatasync, .fdatasync_h = rtems_rfs_rtems_fdatasync, .fcntl_h = rtems_filesystem_default_fcntl };
1e4d0: e5900080 ldr r0, [r0, #128] ; 0x80
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
1e4d4: e1a08001 mov r8, r1
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
1e4d8: e3a01000 mov r1, #0 1e4dc: e24dd010 sub sp, sp, #16 1e4e0: e1a09002 mov r9, r2 1e4e4: e5900000 ldr r0, [r0] 1e4e8: e1a02001 mov r2, r1 1e4ec: e1a06003 mov r6, r3 1e4f0: ebffb5bf bl bbf4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
1e4f4: e2507000 subs r7, r0, #0
1e4f8: 1a000020 bne 1e580 <rtems_rfs_rtems_file_lseek+0xc4>
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);
1e4fc: e1a03006 mov r3, r6
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;
1e500: e99400c0 ldmib r4, {r6, r7}
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
1e504: e1a01008 mov r1, r8 1e508: e1a02009 mov r2, r9 1e50c: e1a00004 mov r0, r4
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;
1e510: e88d00c0 stm sp, {r6, r7}
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
1e514: eb00018d bl 1eb50 <rtems_filesystem_default_lseek_file>
if (new_offset != -1)
1e518: e3e0a000 mvn sl, #0 1e51c: e3e0b000 mvn fp, #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);
1e520: e1a08000 mov r8, r0 1e524: e1a09001 mov r9, r1
if (new_offset != -1)
1e528: e159000b cmp r9, fp 1e52c: 0158000a cmpeq r8, sl
1e530: 0a000006 beq 1e550 <rtems_rfs_rtems_file_lseek+0x94>
{
rtems_rfs_pos pos = iop->offset;
1e534: e9940006 ldmib r4, {r1, r2}
1e538: e28d3010 add r3, sp, #16
1e53c: e9230006 stmdb r3!, {r1, r2}
int rc = rtems_rfs_file_seek (file, pos, &pos);
1e540: e1a00005 mov r0, r5 1e544: ebfff7b2 bl 1c414 <rtems_rfs_file_seek>
if (rc)
1e548: e2506000 subs r6, r0, #0
1e54c: 1a000021 bne 1e5d8 <rtems_rfs_rtems_file_lseek+0x11c>
iop->offset = old_offset;
new_offset = -1;
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
1e550: e595301c ldr r3, [r5, #28] 1e554: e5930098 ldr r0, [r3, #152] ; 0x98
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1e558: e5904080 ldr r4, [r0, #128] ; 0x80
rtems_rfs_buffers_release (fs);
1e55c: ebffef91 bl 1a3a8 <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);
1e560: e5940000 ldr r0, [r4] 1e564: ebffb5eb bl bd18 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
1e568: e2504000 subs r4, r0, #0
1e56c: 1a00000e bne 1e5ac <rtems_rfs_rtems_file_lseek+0xf0>
return new_offset;
}
1e570: e1a00008 mov r0, r8
1e574: e1a01009 mov r1, r9
1e578: e28dd010 add sp, sp, #16
1e57c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1e580: e3a00004 mov r0, #4 <== NOT EXECUTED 1e584: e3a01000 mov r1, #0 <== NOT EXECUTED 1e588: ebffd0a8 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1e58c: e3500000 cmp r0, #0 <== NOT EXECUTED 1e590: 0affffd9 beq 1e4fc <rtems_rfs_rtems_file_lseek+0x40> <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
1e594: e1a00007 mov r0, r7 <== NOT EXECUTED 1e598: ebffa29b bl 700c <rtems_status_text> <== NOT EXECUTED 1e59c: e1a01000 mov r1, r0 <== NOT EXECUTED 1e5a0: e59f004c ldr r0, [pc, #76] ; 1e5f4 <rtems_rfs_rtems_file_lseek+0x138><== NOT EXECUTED 1e5a4: eb0007be bl 204a4 <printf> <== NOT EXECUTED 1e5a8: eaffffd3 b 1e4fc <rtems_rfs_rtems_file_lseek+0x40> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1e5ac: e3a00004 mov r0, #4 <== NOT EXECUTED 1e5b0: e3a01000 mov r1, #0 <== NOT EXECUTED 1e5b4: ebffd09d bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1e5b8: e3500000 cmp r0, #0 <== NOT EXECUTED 1e5bc: 0affffeb beq 1e570 <rtems_rfs_rtems_file_lseek+0xb4> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
1e5c0: e1a00004 mov r0, r4 <== NOT EXECUTED 1e5c4: ebffa290 bl 700c <rtems_status_text> <== NOT EXECUTED 1e5c8: e1a01000 mov r1, r0 <== NOT EXECUTED 1e5cc: e59f0024 ldr r0, [pc, #36] ; 1e5f8 <rtems_rfs_rtems_file_lseek+0x13c><== NOT EXECUTED 1e5d0: eb0007b3 bl 204a4 <printf> <== NOT EXECUTED 1e5d4: eaffffe5 b 1e570 <rtems_rfs_rtems_file_lseek+0xb4> <== 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);
1e5d8: eb0003ed bl 1f594 <__errno> <== NOT EXECUTED 1e5dc: e5806000 str r6, [r0] <== NOT EXECUTED
iop->offset = old_offset;
1e5e0: e89d00c0 ldm sp, {r6, r7} <== NOT EXECUTED
new_offset = -1;
1e5e4: e1a0800a mov r8, sl <== NOT EXECUTED
int rc = rtems_rfs_file_seek (file, pos, &pos);
if (rc)
{
rtems_rfs_rtems_error ("file_lseek: lseek", rc);
iop->offset = old_offset;
1e5e8: e98400c0 stmib r4, {r6, r7} <== NOT EXECUTED
new_offset = -1;
1e5ec: e1a0900b mov r9, fp <== NOT EXECUTED 1e5f0: eaffffd6 b 1e550 <rtems_rfs_rtems_file_lseek+0x94> <== NOT EXECUTED
0001e6d0 <rtems_rfs_rtems_file_open>:
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
1e6d0: e5903024 ldr r3, [r0, #36] ; 0x24
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
1e6d4: e92d4070 push {r4, r5, r6, lr}
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
1e6d8: e5934008 ldr r4, [r3, #8]
.fstat_h = rtems_rfs_rtems_fstat, .ftruncate_h = rtems_rfs_rtems_file_ftruncate, .fsync_h = rtems_rfs_rtems_fdatasync, .fdatasync_h = rtems_rfs_rtems_fdatasync, .fcntl_h = rtems_filesystem_default_fcntl };
1e6dc: e5943080 ldr r3, [r4, #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);
1e6e0: e3a01000 mov r1, #0
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
1e6e4: e24dd004 sub sp, sp, #4 1e6e8: e1a05000 mov r5, r0 1e6ec: e1a02001 mov r2, r1 1e6f0: e5930000 ldr r0, [r3] 1e6f4: ebffb53e bl bbf4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
1e6f8: e2506000 subs r6, r0, #0
1e6fc: 1a00001e bne 1e77c <rtems_rfs_rtems_file_open+0xac>
rtems_rfs_rtems_lock (fs);
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
1e700: e1a00004 mov r0, r4 1e704: e5951018 ldr r1, [r5, #24] 1e708: e3a02000 mov r2, #0 1e70c: e1a0300d mov r3, sp 1e710: ebfff49a bl 1b980 <rtems_rfs_file_open>
if (rc > 0)
1e714: e2506000 subs r6, r0, #0
1e718: da000028 ble 1e7c0 <rtems_rfs_rtems_file_open+0xf0>
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1e71c: e5945080 ldr r5, [r4, #128] ; 0x80 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
1e720: e1a00004 mov r0, r4 <== NOT EXECUTED 1e724: ebffef1f bl 1a3a8 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
1e728: e5950000 ldr r0, [r5] <== NOT EXECUTED 1e72c: ebffb579 bl bd18 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
1e730: e2504000 subs r4, r0, #0 <== NOT EXECUTED 1e734: 1a000005 bne 1e750 <rtems_rfs_rtems_file_open+0x80> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("file-open: open", rc);
1e738: eb000395 bl 1f594 <__errno> <== NOT EXECUTED 1e73c: e5806000 str r6, [r0] <== NOT EXECUTED 1e740: e3e04000 mvn r4, #0 <== NOT EXECUTED
rtems_rfs_rtems_set_iop_file_handle (iop, file);
rtems_rfs_rtems_unlock (fs);
return 0;
}
1e744: e1a00004 mov r0, r4
1e748: e28dd004 add sp, sp, #4
1e74c: e8bd8070 pop {r4, r5, r6, pc}
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1e750: e3a00004 mov r0, #4 <== NOT EXECUTED 1e754: e3a01000 mov r1, #0 <== NOT EXECUTED 1e758: ebffd034 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1e75c: e3500000 cmp r0, #0 <== NOT EXECUTED 1e760: 0afffff4 beq 1e738 <rtems_rfs_rtems_file_open+0x68> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
1e764: e1a00004 mov r0, r4 <== NOT EXECUTED 1e768: ebffa227 bl 700c <rtems_status_text> <== NOT EXECUTED 1e76c: e1a01000 mov r1, r0 <== NOT EXECUTED 1e770: e59f00a0 ldr r0, [pc, #160] ; 1e818 <rtems_rfs_rtems_file_open+0x148><== NOT EXECUTED 1e774: eb00074a bl 204a4 <printf> <== NOT EXECUTED 1e778: eaffffee b 1e738 <rtems_rfs_rtems_file_open+0x68> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1e77c: e3a00004 mov r0, #4 <== NOT EXECUTED 1e780: e3a01000 mov r1, #0 <== NOT EXECUTED 1e784: ebffd029 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1e788: e3500000 cmp r0, #0 <== NOT EXECUTED 1e78c: 0affffdb beq 1e700 <rtems_rfs_rtems_file_open+0x30> <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
1e790: e1a00006 mov r0, r6 <== NOT EXECUTED 1e794: ebffa21c bl 700c <rtems_status_text> <== NOT EXECUTED 1e798: e1a01000 mov r1, r0 <== NOT EXECUTED 1e79c: e59f0078 ldr r0, [pc, #120] ; 1e81c <rtems_rfs_rtems_file_open+0x14c><== NOT EXECUTED 1e7a0: eb00073f bl 204a4 <printf> <== NOT EXECUTED
rtems_rfs_rtems_lock (fs);
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
1e7a4: e1a00004 mov r0, r4 <== NOT EXECUTED 1e7a8: e5951018 ldr r1, [r5, #24] <== NOT EXECUTED 1e7ac: e3a02000 mov r2, #0 <== NOT EXECUTED 1e7b0: e1a0300d mov r3, sp <== NOT EXECUTED 1e7b4: ebfff471 bl 1b980 <rtems_rfs_file_open> <== NOT EXECUTED
if (rc > 0)
1e7b8: e2506000 subs r6, r0, #0 <== NOT EXECUTED 1e7bc: caffffd6 bgt 1e71c <rtems_rfs_rtems_file_open+0x4c> <== 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);
1e7c0: e59d3000 ldr r3, [sp]
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1e7c4: e5946080 ldr r6, [r4, #128] ; 0x80
rtems_rfs_buffers_release (fs);
1e7c8: e1a00004 mov r0, r4 1e7cc: e585301c str r3, [r5, #28] 1e7d0: ebffeef4 bl 1a3a8 <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);
1e7d4: e5960000 ldr r0, [r6] 1e7d8: ebffb54e bl bd18 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
1e7dc: e2504000 subs r4, r0, #0
1e7e0: 0affffd7 beq 1e744 <rtems_rfs_rtems_file_open+0x74>
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1e7e4: e3a00004 mov r0, #4 <== NOT EXECUTED 1e7e8: e3a01000 mov r1, #0 <== NOT EXECUTED 1e7ec: ebffd00f bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1e7f0: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return 0;
1e7f4: 01a04000 moveq r4, r0 <== NOT EXECUTED 1e7f8: 0affffd1 beq 1e744 <rtems_rfs_rtems_file_open+0x74> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
1e7fc: e1a00004 mov r0, r4 <== NOT EXECUTED 1e800: ebffa201 bl 700c <rtems_status_text> <== NOT EXECUTED 1e804: e1a01000 mov r1, r0 <== NOT EXECUTED 1e808: e59f0008 ldr r0, [pc, #8] ; 1e818 <rtems_rfs_rtems_file_open+0x148><== NOT EXECUTED 1e80c: eb000724 bl 204a4 <printf> <== NOT EXECUTED 1e810: e3a04000 mov r4, #0 <== NOT EXECUTED 1e814: eaffffca b 1e744 <rtems_rfs_rtems_file_open+0x74> <== NOT EXECUTED
0001e1e8 <rtems_rfs_rtems_file_read>:
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
1e1e8: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
1e1ec: e590401c ldr r4, [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));
1e1f0: e594301c ldr r3, [r4, #28]
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1e1f4: e5933098 ldr r3, [r3, #152] ; 0x98
.fstat_h = rtems_rfs_rtems_fstat, .ftruncate_h = rtems_rfs_rtems_file_ftruncate, .fsync_h = rtems_rfs_rtems_fdatasync, .fdatasync_h = rtems_rfs_rtems_fdatasync, .fcntl_h = rtems_filesystem_default_fcntl };
1e1f8: e5933080 ldr r3, [r3, #128] ; 0x80
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
1e1fc: e1a07001 mov r7, r1
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
1e200: e3a01000 mov r1, #0 1e204: e24dd00c sub sp, sp, #12 1e208: e1a0a000 mov sl, r0 1e20c: e1a05002 mov r5, r2 1e210: e5930000 ldr r0, [r3] 1e214: e1a02001 mov r2, r1 1e218: ebffb675 bl bbf4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
1e21c: e2506000 subs r6, r0, #0
1e220: 1a00005b bne 1e394 <rtems_rfs_rtems_file_read+0x1ac>
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
1e224: e594101c ldr r1, [r4, #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;
1e228: e99a000c ldmib sl, {r2, r3}
1e22c: e5910098 ldr r0, [r1, #152] ; 0x98
1e230: e2811084 add r1, r1, #132 ; 0x84
1e234: e88d000c stm sp, {r2, r3}
1e238: ebffeb2e bl 18ef8 <rtems_rfs_block_get_size>
if (pos < rtems_rfs_file_size (file))
1e23c: e89d000c ldm sp, {r2, r3}
1e240: e1530001 cmp r3, r1
1e244: 01520000 cmpeq r2, r0
1e248: 23a02000 movcs r2, #0
1e24c: 23a03000 movcs r3, #0
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;
1e250: 23a08000 movcs r8, #0
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
1e254: 2a00003f bcs 1e358 <rtems_rfs_rtems_file_read+0x170>
{
while (count)
1e258: e3550000 cmp r5, #0 1e25c: 03a02000 moveq r2, #0 1e260: 03a03000 moveq r3, #0 1e264: 01a08005 moveq r8, r5
1e268: 0a00003a beq 1e358 <rtems_rfs_rtems_file_read+0x170>
1e26c: e3a08000 mov r8, #0 1e270: ea000002 b 1e280 <rtems_rfs_rtems_file_read+0x98> 1e274: e3550000 cmp r5, #0
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
count -= size;
read += size;
1e278: e0868008 add r8, r6, r8
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
1e27c: 0a000031 beq 1e348 <rtems_rfs_rtems_file_read+0x160>
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
1e280: e28d1008 add r1, sp, #8 1e284: e3a02001 mov r2, #1 1e288: e1a00004 mov r0, r4 1e28c: ebfff742 bl 1bf9c <rtems_rfs_file_io_start>
if (rc > 0)
1e290: e2506000 subs r6, r0, #0
1e294: ca000049 bgt 1e3c0 <rtems_rfs_rtems_file_read+0x1d8>
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
break;
}
if (size == 0)
1e298: e59d6008 ldr r6, [sp, #8] 1e29c: e3560000 cmp r6, #0
1e2a0: 0a000028 beq 1e348 <rtems_rfs_rtems_file_read+0x160>
break;
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
1e2a4: e594200c ldr r2, [r4, #12]
}
if (size == 0)
break;
if (size > count)
1e2a8: e1560005 cmp r6, r5
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
1e2ac: e5943014 ldr r3, [r4, #20] 1e2b0: e592101c ldr r1, [r2, #28]
if (size == 0)
break;
if (size > count)
size = count;
1e2b4: 81a06005 movhi r6, r5
memcpy (data, rtems_rfs_file_data (file), size);
1e2b8: e0811003 add r1, r1, r3 1e2bc: e1a00007 mov r0, r7 1e2c0: e1a02006 mov r2, r6
if (size == 0)
break;
if (size > count)
size = count;
1e2c4: 858d5008 strhi r5, [sp, #8]
}
if (size == 0)
break;
if (size > count)
1e2c8: 90665005 rsbls r5, r6, r5
size = count;
1e2cc: 83a05000 movhi r5, #0
memcpy (data, rtems_rfs_file_data (file), size);
1e2d0: eb00077f bl 200d4 <memcpy>
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
1e2d4: e1a00004 mov r0, r4 1e2d8: e1a01006 mov r1, r6 1e2dc: e3a02001 mov r2, #1 1e2e0: ebfff7b3 bl 1c1b4 <rtems_rfs_file_io_end>
if (rc > 0)
1e2e4: e2509000 subs r9, r0, #0
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
1e2e8: e0877006 add r7, r7, r6
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
if (rc > 0)
1e2ec: daffffe0 ble 1e274 <rtems_rfs_rtems_file_read+0x8c>
{
read = rtems_rfs_rtems_error ("file-read: read: io-end", rc);
1e2f0: eb0004a7 bl 1f594 <__errno> <== NOT EXECUTED 1e2f4: e5809000 str r9, [r0] <== NOT EXECUTED
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
1e2f8: e3e08000 mvn r8, #0 <== NOT EXECUTED
}
if (read >= 0)
iop->offset = pos + read;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
1e2fc: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 1e300: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1e304: e5904080 ldr r4, [r0, #128] ; 0x80 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
1e308: ebfff026 bl 1a3a8 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
1e30c: e5940000 ldr r0, [r4] <== NOT EXECUTED 1e310: ebffb680 bl bd18 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
1e314: e2504000 subs r4, r0, #0 <== NOT EXECUTED 1e318: 0a00001a beq 1e388 <rtems_rfs_rtems_file_read+0x1a0> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1e31c: e3a00004 mov r0, #4 <== NOT EXECUTED 1e320: e3a01000 mov r1, #0 <== NOT EXECUTED 1e324: ebffd141 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1e328: e3500000 cmp r0, #0 <== NOT EXECUTED 1e32c: 0a000015 beq 1e388 <rtems_rfs_rtems_file_read+0x1a0> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
1e330: e1a00004 mov r0, r4 <== NOT EXECUTED 1e334: ebffa334 bl 700c <rtems_status_text> <== NOT EXECUTED 1e338: e1a01000 mov r1, r0 <== NOT EXECUTED 1e33c: e59f008c ldr r0, [pc, #140] ; 1e3d0 <rtems_rfs_rtems_file_read+0x1e8><== NOT EXECUTED 1e340: eb000857 bl 204a4 <printf> <== NOT EXECUTED 1e344: ea00000f b 1e388 <rtems_rfs_rtems_file_read+0x1a0> <== NOT EXECUTED
break;
}
}
}
if (read >= 0)
1e348: e3580000 cmp r8, #0
1e34c: ba000005 blt 1e368 <rtems_rfs_rtems_file_read+0x180>
1e350: e1a02008 mov r2, r8 1e354: e1a03fc8 asr r3, r8, #31
iop->offset = pos + read;
1e358: e89d0003 ldm sp, {r0, r1}
1e35c: e0922000 adds r2, r2, r0
1e360: e0a33001 adc r3, r3, r1
1e364: e98a000c stmib sl, {r2, r3}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
1e368: e594301c ldr r3, [r4, #28] 1e36c: e5930098 ldr r0, [r3, #152] ; 0x98
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1e370: e5904080 ldr r4, [r0, #128] ; 0x80
rtems_rfs_buffers_release (fs);
1e374: ebfff00b bl 1a3a8 <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);
1e378: e5940000 ldr r0, [r4] 1e37c: ebffb665 bl bd18 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
1e380: e2504000 subs r4, r0, #0
1e384: 1affffe4 bne 1e31c <rtems_rfs_rtems_file_read+0x134>
return read;
}
1e388: e1a00008 mov r0, r8
1e38c: e28dd00c add sp, sp, #12
1e390: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1e394: e3a00004 mov r0, #4 <== NOT EXECUTED 1e398: e3a01000 mov r1, #0 <== NOT EXECUTED 1e39c: ebffd123 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1e3a0: e3500000 cmp r0, #0 <== NOT EXECUTED 1e3a4: 0affff9e beq 1e224 <rtems_rfs_rtems_file_read+0x3c> <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
1e3a8: e1a00006 mov r0, r6 <== NOT EXECUTED 1e3ac: ebffa316 bl 700c <rtems_status_text> <== NOT EXECUTED 1e3b0: e1a01000 mov r1, r0 <== NOT EXECUTED 1e3b4: e59f0018 ldr r0, [pc, #24] ; 1e3d4 <rtems_rfs_rtems_file_read+0x1ec><== NOT EXECUTED 1e3b8: eb000839 bl 204a4 <printf> <== NOT EXECUTED 1e3bc: eaffff98 b 1e224 <rtems_rfs_rtems_file_read+0x3c> <== NOT EXECUTED
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
if (rc > 0)
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
1e3c0: eb000473 bl 1f594 <__errno> <== NOT EXECUTED
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
1e3c4: e3e08000 mvn r8, #0 <== NOT EXECUTED
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
if (rc > 0)
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
1e3c8: e5806000 str r6, [r0] <== NOT EXECUTED 1e3cc: eaffffca b 1e2fc <rtems_rfs_rtems_file_read+0x114> <== NOT EXECUTED
0001e820 <rtems_rfs_rtems_file_write>:
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
1e820: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
1e824: 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));
1e828: e594301c ldr r3, [r4, #28]
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1e82c: e5933098 ldr r3, [r3, #152] ; 0x98
.fstat_h = rtems_rfs_rtems_fstat, .ftruncate_h = rtems_rfs_rtems_file_ftruncate, .fsync_h = rtems_rfs_rtems_fdatasync, .fdatasync_h = rtems_rfs_rtems_fdatasync, .fcntl_h = rtems_filesystem_default_fcntl };
1e830: e5933080 ldr r3, [r3, #128] ; 0x80
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
1e834: e1a06001 mov r6, r1
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
1e838: e3a01000 mov r1, #0 1e83c: e24dd00c sub sp, sp, #12 1e840: e1a07000 mov r7, r0 1e844: e1a05002 mov r5, r2 1e848: e5930000 ldr r0, [r3] 1e84c: e1a02001 mov r2, r1 1e850: ebffb4e7 bl bbf4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
1e854: e2508000 subs r8, r0, #0
1e858: 1a000072 bne 1ea28 <rtems_rfs_rtems_file_write+0x208>
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
file_size = rtems_rfs_file_size (file);
1e85c: 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;
1e860: e997000c ldmib r7, {r2, r3}
1e864: e5910098 ldr r0, [r1, #152] ; 0x98
1e868: e2811084 add r1, r1, #132 ; 0x84
1e86c: e88d000c stm sp, {r2, r3}
1e870: ebffe9a0 bl 18ef8 <rtems_rfs_block_get_size>
file_size = rtems_rfs_file_size (file); if (pos > file_size)
1e874: e89d000c ldm sp, {r2, r3}
1e878: e1a08000 mov r8, r0
1e87c: e1a09001 mov r9, r1
1e880: e1590003 cmp r9, r3
1e884: 01580002 cmpeq r8, r2
1e888: 3a000071 bcc 1ea54 <rtems_rfs_rtems_file_write+0x234>
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
rtems_rfs_file_set_bpos (file, pos);
}
else if (pos < file_size && (iop->flags & LIBIO_FLAGS_APPEND) != 0)
1e88c: e1530009 cmp r3, r9 1e890: 01520008 cmpeq r2, r8
1e894: 3a00004c bcc 1e9cc <rtems_rfs_rtems_file_write+0x1ac>
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
}
}
while (count)
1e898: e3550000 cmp r5, #0 1e89c: 03a02000 moveq r2, #0 1e8a0: 03a03000 moveq r3, #0 1e8a4: 01a06005 moveq r6, r5
1e8a8: 0a000038 beq 1e990 <rtems_rfs_rtems_file_write+0x170>
1e8ac: e1a0a006 mov sl, r6 1e8b0: e3a06000 mov r6, #0 1e8b4: ea000002 b 1e8c4 <rtems_rfs_rtems_file_write+0xa4> 1e8b8: e0555008 subs r5, r5, r8
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
count -= size;
write += size;
1e8bc: e0866008 add r6, r6, r8
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
}
}
while (count)
1e8c0: 0a00002e beq 1e980 <rtems_rfs_rtems_file_write+0x160>
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
1e8c4: e28d1008 add r1, sp, #8 1e8c8: e3a02000 mov r2, #0 1e8cc: e1a00004 mov r0, r4
}
}
while (count)
{
size_t size = count;
1e8d0: e58d5008 str r5, [sp, #8]
rc = rtems_rfs_file_io_start (file, &size, false);
1e8d4: ebfff5b0 bl 1bf9c <rtems_rfs_file_io_start>
if (rc)
1e8d8: e2508000 subs r8, r0, #0
}
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
1e8dc: e1a0100a mov r1, sl
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
if (rc)
1e8e0: 1a000067 bne 1ea84 <rtems_rfs_rtems_file_write+0x264>
}
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
1e8e4: e594000c ldr r0, [r4, #12]
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
1e8e8: e59d2008 ldr r2, [sp, #8]
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
1e8ec: e5943014 ldr r3, [r4, #20] 1e8f0: e590001c ldr r0, [r0, #28]
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
1e8f4: e1520005 cmp r2, r5
size = count;
1e8f8: 81a02005 movhi r2, r5
memcpy (rtems_rfs_file_data (file), data, size);
1e8fc: e0800003 add r0, r0, r3
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
size = count;
1e900: 858d5008 strhi r5, [sp, #8]
memcpy (rtems_rfs_file_data (file), data, size);
1e904: eb0005f2 bl 200d4 <memcpy>
data += size;
1e908: e59d8008 ldr r8, [sp, #8]
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
1e90c: e1a00004 mov r0, r4 1e910: e1a01008 mov r1, r8 1e914: e3a02000 mov r2, #0 1e918: ebfff625 bl 1c1b4 <rtems_rfs_file_io_end>
if (rc)
1e91c: e2509000 subs r9, r0, #0
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
1e920: e08aa008 add sl, sl, r8
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
if (rc)
1e924: 0affffe3 beq 1e8b8 <rtems_rfs_rtems_file_write+0x98>
{
write = rtems_rfs_rtems_error ("file-write: write close", rc);
1e928: eb000319 bl 1f594 <__errno> <== NOT EXECUTED 1e92c: e5809000 str r9, [r0] <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
}
}
while (count)
1e930: e3e06000 mvn r6, #0 <== NOT EXECUTED
}
if (write >= 0)
iop->offset = pos + write;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
1e934: e594301c ldr r3, [r4, #28] 1e938: e5930098 ldr r0, [r3, #152] ; 0x98
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1e93c: e5904080 ldr r4, [r0, #128] ; 0x80
rtems_rfs_buffers_release (fs);
1e940: ebffee98 bl 1a3a8 <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);
1e944: e5940000 ldr r0, [r4] 1e948: ebffb4f2 bl bd18 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
1e94c: e2504000 subs r4, r0, #0
1e950: 0a00001a beq 1e9c0 <rtems_rfs_rtems_file_write+0x1a0>
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1e954: e3a00004 mov r0, #4 <== NOT EXECUTED 1e958: e3a01000 mov r1, #0 <== NOT EXECUTED 1e95c: ebffcfb3 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1e960: e3500000 cmp r0, #0 <== NOT EXECUTED 1e964: 0a000015 beq 1e9c0 <rtems_rfs_rtems_file_write+0x1a0> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
1e968: e1a00004 mov r0, r4 <== NOT EXECUTED 1e96c: ebffa1a6 bl 700c <rtems_status_text> <== NOT EXECUTED 1e970: e1a01000 mov r1, r0 <== NOT EXECUTED 1e974: e59f0144 ldr r0, [pc, #324] ; 1eac0 <rtems_rfs_rtems_file_write+0x2a0><== NOT EXECUTED 1e978: eb0006c9 bl 204a4 <printf> <== NOT EXECUTED 1e97c: ea00000f b 1e9c0 <rtems_rfs_rtems_file_write+0x1a0> <== NOT EXECUTED
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
if (write >= 0)
1e980: e3560000 cmp r6, #0
1e984: ba000005 blt 1e9a0 <rtems_rfs_rtems_file_write+0x180>
1e988: e1a02006 mov r2, r6 1e98c: e1a03fc6 asr r3, r6, #31
iop->offset = pos + write;
1e990: e89d0003 ldm sp, {r0, r1}
1e994: e0900002 adds r0, r0, r2
1e998: e0a11003 adc r1, r1, r3
1e99c: e9870003 stmib r7, {r0, r1}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
1e9a0: e594301c ldr r3, [r4, #28] 1e9a4: e5930098 ldr r0, [r3, #152] ; 0x98
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1e9a8: e5904080 ldr r4, [r0, #128] ; 0x80
rtems_rfs_buffers_release (fs);
1e9ac: ebffee7d bl 1a3a8 <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);
1e9b0: e5940000 ldr r0, [r4] 1e9b4: ebffb4d7 bl bd18 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
1e9b8: e2504000 subs r4, r0, #0
1e9bc: 1affffe4 bne 1e954 <rtems_rfs_rtems_file_write+0x134>
return write;
}
1e9c0: e1a00006 mov r0, r6
1e9c4: e28dd00c add sp, sp, #12
1e9c8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
rtems_rfs_file_set_bpos (file, pos);
}
else if (pos < file_size && (iop->flags & LIBIO_FLAGS_APPEND) != 0)
1e9cc: e597300c ldr r3, [r7, #12] 1e9d0: e3130c02 tst r3, #512 ; 0x200
1e9d4: 0affffaf beq 1e898 <rtems_rfs_rtems_file_write+0x78>
{
pos = file_size;
rc = rtems_rfs_file_seek (file, pos, &pos);
1e9d8: e1a01008 mov r1, r8 1e9dc: e1a00004 mov r0, r4 1e9e0: e1a02009 mov r2, r9 1e9e4: 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;
1e9e8: e88d0300 stm sp, {r8, r9}
rc = rtems_rfs_file_seek (file, pos, &pos);
1e9ec: ebfff688 bl 1c414 <rtems_rfs_file_seek>
if (rc)
1e9f0: e2508000 subs r8, r0, #0
1e9f4: 0affffa7 beq 1e898 <rtems_rfs_rtems_file_write+0x78>
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
1e9f8: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 1e9fc: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
1ea00: e5904080 ldr r4, [r0, #128] ; 0x80 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
1ea04: ebffee67 bl 1a3a8 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
1ea08: e5940000 ldr r0, [r4] <== NOT EXECUTED 1ea0c: ebffb4c1 bl bd18 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
1ea10: e2504000 subs r4, r0, #0 <== NOT EXECUTED 1ea14: 1a00001e bne 1ea94 <rtems_rfs_rtems_file_write+0x274> <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
1ea18: eb0002dd bl 1f594 <__errno> <== NOT EXECUTED 1ea1c: e3e06000 mvn r6, #0 <== NOT EXECUTED 1ea20: e5808000 str r8, [r0] <== NOT EXECUTED 1ea24: eaffffe5 b 1e9c0 <rtems_rfs_rtems_file_write+0x1a0> <== NOT EXECUTED
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1ea28: e3a00004 mov r0, #4 <== NOT EXECUTED 1ea2c: e3a01000 mov r1, #0 <== NOT EXECUTED 1ea30: ebffcf7e bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1ea34: e3500000 cmp r0, #0 <== NOT EXECUTED 1ea38: 0affff87 beq 1e85c <rtems_rfs_rtems_file_write+0x3c> <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
1ea3c: e1a00008 mov r0, r8 <== NOT EXECUTED 1ea40: ebffa171 bl 700c <rtems_status_text> <== NOT EXECUTED 1ea44: e1a01000 mov r1, r0 <== NOT EXECUTED 1ea48: e59f0074 ldr r0, [pc, #116] ; 1eac4 <rtems_rfs_rtems_file_write+0x2a4><== NOT EXECUTED 1ea4c: eb000694 bl 204a4 <printf> <== NOT EXECUTED 1ea50: eaffff81 b 1e85c <rtems_rfs_rtems_file_write+0x3c> <== NOT EXECUTED
/*
* 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);
1ea54: e1a01002 mov r1, r2 1ea58: e1a00004 mov r0, r4 1ea5c: e1a02003 mov r2, r3 1ea60: ebfff6a9 bl 1c50c <rtems_rfs_file_set_size>
if (rc)
1ea64: e2508000 subs r8, r0, #0
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
1ea68: e594301c ldr r3, [r4, #28]
* 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)
1ea6c: 1affffe2 bne 1e9fc <rtems_rfs_rtems_file_write+0x1dc>
{
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);
1ea70: e5930098 ldr r0, [r3, #152] ; 0x98
1ea74: e89d0006 ldm sp, {r1, r2}
1ea78: e2843010 add r3, r4, #16
1ea7c: ebffe8ed bl 18e38 <rtems_rfs_block_get_bpos>
1ea80: eaffff84 b 1e898 <rtems_rfs_rtems_file_write+0x78>
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
if (rc)
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
1ea84: eb0002c2 bl 1f594 <__errno>
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
}
}
while (count)
1ea88: e3e06000 mvn r6, #0
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
if (rc)
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
1ea8c: e5808000 str r8, [r0] 1ea90: eaffffa7 b 1e934 <rtems_rfs_rtems_file_write+0x114>
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
1ea94: e3a00004 mov r0, #4 <== NOT EXECUTED 1ea98: e3a01000 mov r1, #0 <== NOT EXECUTED 1ea9c: ebffcf63 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1eaa0: e3500000 cmp r0, #0 <== NOT EXECUTED 1eaa4: 0affffdb beq 1ea18 <rtems_rfs_rtems_file_write+0x1f8> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
1eaa8: e1a00004 mov r0, r4 <== NOT EXECUTED 1eaac: ebffa156 bl 700c <rtems_status_text> <== NOT EXECUTED 1eab0: e1a01000 mov r1, r0 <== NOT EXECUTED 1eab4: e59f0004 ldr r0, [pc, #4] ; 1eac0 <rtems_rfs_rtems_file_write+0x2a0><== NOT EXECUTED 1eab8: eb000679 bl 204a4 <printf> <== NOT EXECUTED 1eabc: eaffffd5 b 1ea18 <rtems_rfs_rtems_file_write+0x1f8> <== NOT EXECUTED
000124a8 <rtems_rfs_rtems_fstat>:
}
int
rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
124a8: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
124ac: e5902014 ldr r2, [r0, #20] 124b0: e5925008 ldr r5, [r2, #8]
}
int
rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
124b4: e1a03000 mov r3, r0 124b8: e24dd028 sub sp, sp, #40 ; 0x28 124bc: 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);
124c0: e1a00005 mov r0, r5 124c4: e5931008 ldr r1, [r3, #8] 124c8: e1a0200d mov r2, sp 124cc: e3a03001 mov r3, #1 124d0: ebfffa7c bl 10ec8 <rtems_rfs_inode_open>
if (rc)
124d4: e2506000 subs r6, r0, #0
124d8: 1a00005d bne 12654 <rtems_rfs_rtems_fstat+0x1ac>
* @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);
124dc: e59d300c ldr r3, [sp, #12] 124e0: e5d32003 ldrb r2, [r3, #3] 124e4: e5d30002 ldrb r0, [r3, #2]
return rtems_rfs_rtems_error ("stat: opening inode", rc);
}
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
124e8: e1820400 orr r0, r2, r0, lsl #8 124ec: e2002a0f and r2, r0, #61440 ; 0xf000 124f0: e3520a02 cmp r2, #8192 ; 0x2000 124f4: 13520a06 cmpne r2, #24576 ; 0x6000
124f8: 0a00003d beq 125f4 <rtems_rfs_rtems_fstat+0x14c>
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);
124fc: e5953010 ldr r3, [r5, #16] 12500: e1a02fc3 asr r2, r3, #31 12504: e5843000 str r3, [r4]
buf->st_ino = rtems_rfs_inode_ino (&inode);
12508: 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);
1250c: e5842004 str r2, [r4, #4]
buf->st_ino = rtems_rfs_inode_ino (&inode);
12510: e5843008 str r3, [r4, #8]
buf->st_mode = rtems_rfs_rtems_mode (mode);
12514: eb0000c4 bl 1282c <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);
12518: e59d300c ldr r3, [sp, #12] 1251c: e584000c str r0, [r4, #12] 12520: e5d31000 ldrb r1, [r3] 12524: e5d32001 ldrb r2, [r3, #1] 12528: e1822401 orr r2, r2, r1, lsl #8
if (links == 0xffff)
links = 0;
1252c: e59f1204 ldr r1, [pc, #516] ; 12738 <rtems_rfs_rtems_fstat+0x290> 12530: e1520001 cmp r2, r1 12534: 03a02000 moveq r2, #0
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
12538: 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;
1253c: e5d31006 ldrb r1, [r3, #6] 12540: e5d32007 ldrb r2, [r3, #7] 12544: e1822401 orr r2, r2, r1, lsl #8
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
12548: e1c421b2 strh r2, [r4, #18]
* @return uint16_t The group id (gid).
*/
static inline uint16_t
rtems_rfs_inode_get_gid (rtems_rfs_inode_handle* handle)
{
return (rtems_rfs_read_u32 (&handle->node->owner) >> 16) & 0xffff;
1254c: e5d31005 ldrb r1, [r3, #5] 12550: e5d32004 ldrb r2, [r3, #4] 12554: e1a03801 lsl r3, r1, #16 12558: e1833c02 orr r3, r3, r2, lsl #24 1255c: e1a03823 lsr r3, r3, #16
/*
* 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));
12560: e59d1008 ldr r1, [sp, #8] 12564: e1c431b4 strh r3, [r4, #20] 12568: e1a00005 mov r0, r5 1256c: eb0028a4 bl 1c804 <rtems_rfs_file_get_shared>
if (shared)
12570: e2501000 subs r1, r0, #0
12574: 0a00003a beq 12664 <rtems_rfs_rtems_fstat+0x1bc>
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
12578: e594e00c ldr lr, [r4, #12]
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
1257c: e2810090 add r0, r1, #144 ; 0x90
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
12580: e591c08c ldr ip, [r1, #140] ; 0x8c
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
12584: e8900005 ldm r0, {r0, r2}
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
12588: e5913084 ldr r3, [r1, #132] ; 0x84
if (S_ISLNK (buf->st_mode))
1258c: e20eea0f and lr, lr, #61440 ; 0xf000 12590: e35e0a0a cmp lr, #40960 ; 0xa000
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
12594: e584c028 str ip, [r4, #40] ; 0x28
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
12598: e5840030 str r0, [r4, #48] ; 0x30
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
1259c: e5842038 str r2, [r4, #56] ; 0x38
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
125a0: e5843044 str r3, [r4, #68] ; 0x44
if (S_ISLNK (buf->st_mode))
125a4: 0a000025 beq 12640 <rtems_rfs_rtems_fstat+0x198>
*/
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);
125a8: e1a00005 mov r0, r5 125ac: e2811084 add r1, r1, #132 ; 0x84 125b0: eb001a50 bl 18ef8 <rtems_rfs_block_get_size>
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
else
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
125b4: e5840020 str r0, [r4, #32] 125b8: e5841024 str r1, [r4, #36] ; 0x24
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);
125bc: e5953008 ldr r3, [r5, #8]
rc = rtems_rfs_inode_close (fs, &inode);
125c0: 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);
125c4: e5843040 str r3, [r4, #64] ; 0x40
rc = rtems_rfs_inode_close (fs, &inode);
125c8: e1a0100d mov r1, sp 125cc: ebfffab7 bl 110b0 <rtems_rfs_inode_close>
if (rc > 0)
125d0: e2504000 subs r4, r0, #0
{
return rtems_rfs_rtems_error ("stat: closing inode", rc);
}
return 0;
125d4: d3a03000 movle r3, #0
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
125d8: da000002 ble 125e8 <rtems_rfs_rtems_fstat+0x140>
{
return rtems_rfs_rtems_error ("stat: closing inode", rc);
125dc: eb0033ec bl 1f594 <__errno> <== NOT EXECUTED 125e0: e5804000 str r4, [r0] <== NOT EXECUTED 125e4: e3e03000 mvn r3, #0 <== NOT EXECUTED
}
return 0;
}
125e8: e1a00003 mov r0, r3
125ec: e28dd028 add sp, sp, #40 ; 0x28
125f0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
* @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]);
125f4: e5d38021 ldrb r8, [r3, #33] ; 0x21 <== NOT EXECUTED 125f8: e5d3201d ldrb r2, [r3, #29] <== NOT EXECUTED 125fc: e5d3701c ldrb r7, [r3, #28] <== NOT EXECUTED 12600: e5d3a020 ldrb sl, [r3, #32] <== NOT EXECUTED 12604: e5d36023 ldrb r6, [r3, #35] ; 0x23 <== NOT EXECUTED 12608: e5d3e01f ldrb lr, [r3, #31] <== NOT EXECUTED 1260c: e1a08808 lsl r8, r8, #16 <== NOT EXECUTED 12610: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED 12614: e5d3c022 ldrb ip, [r3, #34] ; 0x22 <== NOT EXECUTED 12618: e5d3101e ldrb r1, [r3, #30] <== NOT EXECUTED 1261c: e1822c07 orr r2, r2, r7, lsl #24 <== NOT EXECUTED 12620: e1883c0a orr r3, r8, sl, lsl #24 <== NOT EXECUTED 12624: e1833006 orr r3, r3, r6 <== NOT EXECUTED 12628: e182200e orr r2, r2, lr <== NOT EXECUTED 1262c: e183340c orr r3, r3, ip, lsl #8 <== NOT EXECUTED 12630: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
{
buf->st_rdev =
12634: e5842018 str r2, [r4, #24] <== NOT EXECUTED 12638: e584301c str r3, [r4, #28] <== NOT EXECUTED 1263c: eaffffae b 124fc <rtems_rfs_rtems_fstat+0x54> <== NOT EXECUTED
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
12640: e1d138b8 ldrh r3, [r1, #136] ; 0x88 <== NOT EXECUTED 12644: e5843020 str r3, [r4, #32] <== NOT EXECUTED 12648: e3a03000 mov r3, #0 <== NOT EXECUTED 1264c: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED 12650: eaffffd9 b 125bc <rtems_rfs_rtems_fstat+0x114> <== NOT EXECUTED
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
{
return rtems_rfs_rtems_error ("stat: opening inode", rc);
12654: eb0033ce bl 1f594 <__errno> <== NOT EXECUTED 12658: e3e03000 mvn r3, #0 <== NOT EXECUTED 1265c: e5806000 str r6, [r0] <== NOT EXECUTED 12660: eaffffe0 b 125e8 <rtems_rfs_rtems_fstat+0x140> <== NOT EXECUTED
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
12664: e59d300c ldr r3, [sp, #12] 12668: e5d32011 ldrb r2, [r3, #17] 1266c: e5d3e010 ldrb lr, [r3, #16] 12670: e5d3c013 ldrb ip, [r3, #19] 12674: e1a02802 lsl r2, r2, #16 12678: e5d30012 ldrb r0, [r3, #18] 1267c: e1822c0e orr r2, r2, lr, lsl #24 12680: e182200c orr r2, r2, ip 12684: 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);
12688: 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);
1268c: e5d32015 ldrb r2, [r3, #21] 12690: e5d3e014 ldrb lr, [r3, #20] 12694: e5d3c017 ldrb ip, [r3, #23] 12698: e1a02802 lsl r2, r2, #16 1269c: e5d30016 ldrb r0, [r3, #22] 126a0: e1822c0e orr r2, r2, lr, lsl #24 126a4: e182200c orr r2, r2, ip 126a8: e1822400 orr r2, r2, r0, lsl #8
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
126ac: 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);
126b0: e5d32019 ldrb r2, [r3, #25] 126b4: e5d3e018 ldrb lr, [r3, #24] 126b8: e5d3c01b ldrb ip, [r3, #27] 126bc: e1a02802 lsl r2, r2, #16 126c0: e5d3001a ldrb r0, [r3, #26] 126c4: e1822c0e orr r2, r2, lr, lsl #24 126c8: e182200c orr r2, r2, ip 126cc: e1822400 orr r2, r2, r0, lsl #8
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
126d0: 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);
126d4: e5d3200d ldrb r2, [r3, #13] 126d8: e5d3600c ldrb r6, [r3, #12] 126dc: e5d3e00f ldrb lr, [r3, #15] 126e0: e1a02802 lsl r2, r2, #16
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
if (S_ISLNK (buf->st_mode))
126e4: e594000c ldr r0, [r4, #12] 126e8: e5d3c00e ldrb ip, [r3, #14] 126ec: e1822c06 orr r2, r2, r6, lsl #24 126f0: e182200e orr r2, r2, lr 126f4: e2000a0f and r0, r0, #61440 ; 0xf000 126f8: e182240c orr r2, r2, ip, lsl #8 126fc: e3500a0a cmp r0, #40960 ; 0xa000
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
12700: e5842044 str r2, [r4, #68] ; 0x44
if (S_ISLNK (buf->st_mode))
12704: 1a000005 bne 12720 <rtems_rfs_rtems_fstat+0x278>
* @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);
12708: e5d3200a ldrb r2, [r3, #10] 1270c: e5d3300b ldrb r3, [r3, #11]
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
12710: e1833402 orr r3, r3, r2, lsl #8 12714: e5843020 str r3, [r4, #32] 12718: e5841024 str r1, [r4, #36] ; 0x24 1271c: eaffffa6 b 125bc <rtems_rfs_rtems_fstat+0x114>
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
12720: e1a00005 mov r0, r5 12724: e1a0100d mov r1, sp 12728: ebfffc1d bl 117a4 <rtems_rfs_inode_get_size> 1272c: e5840020 str r0, [r4, #32] 12730: e5841024 str r1, [r4, #36] ; 0x24 12734: eaffffa0 b 125bc <rtems_rfs_rtems_fstat+0x114>
000121a8 <rtems_rfs_rtems_initialise>:
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
121a8: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
121ac: e2514000 subs r4, r1, #0
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
121b0: e24dd008 sub sp, sp, #8
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
121b4: e3a07005 mov r7, #5
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
121b8: e1a05000 mov r5, r0
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
121bc: 0a00005f beq 12340 <rtems_rfs_rtems_initialise+0x198>
121c0: e3a06000 mov r6, #0 <== NOT EXECUTED
{
printf ("options=%s\n", options);
121c4: e1a01004 mov r1, r4 <== NOT EXECUTED 121c8: e59f0214 ldr r0, [pc, #532] ; 123e4 <rtems_rfs_rtems_initialise+0x23c><== NOT EXECUTED 121cc: eb0038b4 bl 204a4 <printf> <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
121d0: e59f1210 ldr r1, [pc, #528] ; 123e8 <rtems_rfs_rtems_initialise+0x240><== NOT EXECUTED 121d4: e3a0200c mov r2, #12 <== NOT EXECUTED 121d8: e1a00004 mov r0, r4 <== NOT EXECUTED 121dc: eb003d9c bl 21854 <strncmp> <== NOT EXECUTED 121e0: e3500000 cmp r0, #0 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
121e4: e59f1200 ldr r1, [pc, #512] ; 123ec <rtems_rfs_rtems_initialise+0x244><== NOT EXECUTED 121e8: e3a0200e mov r2, #14 <== NOT EXECUTED 121ec: e1a00004 mov r0, r4 <== NOT EXECUTED
while (options)
{
printf ("options=%s\n", options);
if (strncmp (options, "hold-bitmaps",
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
121f0: 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",
121f4: 0a00000d beq 12230 <rtems_rfs_rtems_initialise+0x88> <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
121f8: eb003d95 bl 21854 <strncmp> <== NOT EXECUTED 121fc: e3500000 cmp r0, #0 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
12200: e59f11e8 ldr r1, [pc, #488] ; 123f0 <rtems_rfs_rtems_initialise+0x248><== NOT EXECUTED 12204: e3a0200d mov r2, #13 <== NOT EXECUTED 12208: e1a00004 mov r0, r4 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
1220c: 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",
12210: 0a000006 beq 12230 <rtems_rfs_rtems_initialise+0x88> <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
12214: eb003d8e bl 21854 <strncmp> <== NOT EXECUTED 12218: e2501000 subs r1, r0, #0 <== NOT EXECUTED 1221c: 1a000042 bne 1232c <rtems_rfs_rtems_initialise+0x184> <== NOT EXECUTED
sizeof ("max-held-bufs") - 1) == 0)
{
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
12220: e284000e add r0, r4, #14 <== NOT EXECUTED 12224: e1a02001 mov r2, r1 <== NOT EXECUTED 12228: eb003e4c bl 21b60 <strtoul> <== NOT EXECUTED 1222c: e1a07000 mov r7, r0 <== NOT EXECUTED
}
else
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
options = strchr (options, ',');
12230: e1a00004 mov r0, r4 <== NOT EXECUTED 12234: e3a0102c mov r1, #44 ; 0x2c <== NOT EXECUTED 12238: eb003a79 bl 20c24 <strchr> <== NOT EXECUTED
if (options)
1223c: e3500000 cmp r0, #0 <== NOT EXECUTED 12240: 0a000002 beq 12250 <rtems_rfs_rtems_initialise+0xa8> <== NOT EXECUTED
{
++options;
if (*options == '\0')
12244: e5d03001 ldrb r3, [r0, #1] <== NOT EXECUTED 12248: e3530000 cmp r3, #0 <== NOT EXECUTED 1224c: 1a000010 bne 12294 <rtems_rfs_rtems_initialise+0xec> <== NOT EXECUTED
options = NULL;
}
}
rtems = malloc (sizeof (rtems_rfs_rtems_private));
12250: e3a00004 mov r0, #4 12254: ebffd576 bl 7834 <malloc>
if (!rtems)
12258: e2504000 subs r4, r0, #0
1225c: 0a00005b beq 123d0 <rtems_rfs_rtems_initialise+0x228>
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
12260: e3a08000 mov r8, #0 12264: e5848000 str r8, [r4]
rc = rtems_rfs_mutex_create (&rtems->access);
12268: eb002e21 bl 1daf4 <rtems_rfs_mutex_create>
if (rc > 0)
1226c: e250a000 subs sl, r0, #0
12270: da00000a ble 122a0 <rtems_rfs_rtems_initialise+0xf8>
{
free (rtems);
12274: e1a00004 mov r0, r4 <== NOT EXECUTED 12278: ebffd3ee bl 7238 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
1227c: eb0034c4 bl 1f594 <__errno> <== NOT EXECUTED 12280: e580a000 str sl, [r0] <== NOT EXECUTED 12284: e3e04000 mvn r4, #0 <== NOT EXECUTED
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
rtems_rfs_rtems_unlock (fs);
return 0;
}
12288: e1a00004 mov r0, r4
1228c: e28dd008 add sp, sp, #8
12290: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
12294: e2904001 adds r4, r0, #1 <== NOT EXECUTED 12298: 1affffc9 bne 121c4 <rtems_rfs_rtems_initialise+0x1c> <== NOT EXECUTED 1229c: eaffffeb b 12250 <rtems_rfs_rtems_initialise+0xa8> <== 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);
122a0: e1a01008 mov r1, r8 122a4: e1a02008 mov r2, r8 122a8: e5940000 ldr r0, [r4] 122ac: ebffe650 bl bbf4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
122b0: e2508000 subs r8, r0, #0
122b4: 1a00000e bne 122f4 <rtems_rfs_rtems_initialise+0x14c>
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
122b8: e5950038 ldr r0, [r5, #56] ; 0x38 122bc: e1a02006 mov r2, r6 122c0: e28dc004 add ip, sp, #4 122c4: e1a01004 mov r1, r4 122c8: e1a03007 mov r3, r7 122cc: e58dc000 str ip, [sp] 122d0: eb002968 bl 1c878 <rtems_rfs_fs_open>
if (rc)
122d4: e2506000 subs r6, r0, #0
122d8: 0a00001a beq 12348 <rtems_rfs_rtems_initialise+0x1a0>
{
free (rtems);
122dc: e1a00004 mov r0, r4 <== NOT EXECUTED 122e0: ebffd3d4 bl 7238 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", rc);
122e4: eb0034aa bl 1f594 <__errno> <== NOT EXECUTED 122e8: e3e04000 mvn r4, #0 <== NOT EXECUTED 122ec: e5806000 str r6, [r0] <== NOT EXECUTED 122f0: eaffffe4 b 12288 <rtems_rfs_rtems_initialise+0xe0> <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
122f4: e3a00004 mov r0, #4 <== NOT EXECUTED 122f8: e3a01000 mov r1, #0 <== NOT EXECUTED 122fc: eb00014b bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 12300: e3500000 cmp r0, #0 <== NOT EXECUTED 12304: 1a00002b bne 123b8 <rtems_rfs_rtems_initialise+0x210> <== NOT EXECUTED
}
rc = rtems_rfs_mutex_lock (&rtems->access);
if (rc > 0)
{
rtems_rfs_mutex_destroy (&rtems->access);
12308: e1a00004 mov r0, r4 <== NOT EXECUTED 1230c: eb002e14 bl 1db64 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
free (rtems);
12310: e1a00004 mov r0, r4 <== NOT EXECUTED 12314: ebffd3c7 bl 7238 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
12318: eb00349d bl 1f594 <__errno> <== NOT EXECUTED 1231c: e3a03005 mov r3, #5 <== NOT EXECUTED 12320: e5803000 str r3, [r0] <== NOT EXECUTED 12324: e3e04000 mvn r4, #0 <== NOT EXECUTED 12328: eaffffd6 b 12288 <rtems_rfs_rtems_initialise+0xe0> <== NOT EXECUTED
sizeof ("max-held-bufs") - 1) == 0)
{
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
}
else
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
1232c: eb003498 bl 1f594 <__errno> <== NOT EXECUTED 12330: e3a03016 mov r3, #22 <== NOT EXECUTED 12334: e5803000 str r3, [r0] <== NOT EXECUTED 12338: e3e04000 mvn r4, #0 <== NOT EXECUTED 1233c: eaffffd1 b 12288 <rtems_rfs_rtems_initialise+0xe0> <== NOT EXECUTED
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;
12340: e1a06004 mov r6, r4 12344: eaffffc1 b 12250 <rtems_rfs_rtems_initialise+0xa8>
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
12348: e59d0004 ldr r0, [sp, #4]
mt_entry->ops = &rtems_rfs_ops;
1234c: e59f20a0 ldr r2, [pc, #160] ; 123f4 <rtems_rfs_rtems_initialise+0x24c>
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
12350: e5953024 ldr r3, [r5, #36] ; 0x24
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
12354: e5904080 ldr r4, [r0, #128] ; 0x80
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
mt_entry->ops = &rtems_rfs_ops;
12358: e585200c str r2, [r5, #12]
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
1235c: e3a02001 mov r2, #1
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
12360: e5850008 str r0, [r5, #8]
mt_entry->ops = &rtems_rfs_ops; mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
12364: e5832008 str r2, [r3, #8]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
12368: e59f2088 ldr r2, [pc, #136] ; 123f8 <rtems_rfs_rtems_initialise+0x250> 1236c: e5832010 str r2, [r3, #16]
rtems_rfs_buffers_release (fs);
12370: eb00200c bl 1a3a8 <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);
12374: e5940000 ldr r0, [r4] 12378: ebffe666 bl bd18 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
1237c: e2504000 subs r4, r0, #0
12380: 0affffc0 beq 12288 <rtems_rfs_rtems_initialise+0xe0>
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
12384: e3a00004 mov r0, #4 <== NOT EXECUTED 12388: e3a01000 mov r1, #0 <== NOT EXECUTED 1238c: eb000127 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 12390: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return 0;
12394: 01a04000 moveq r4, r0 <== NOT EXECUTED 12398: 0affffba beq 12288 <rtems_rfs_rtems_initialise+0xe0> <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
1239c: e1a00004 mov r0, r4 <== NOT EXECUTED 123a0: ebffd319 bl 700c <rtems_status_text> <== NOT EXECUTED 123a4: e1a01000 mov r1, r0 <== NOT EXECUTED 123a8: e59f004c ldr r0, [pc, #76] ; 123fc <rtems_rfs_rtems_initialise+0x254><== NOT EXECUTED 123ac: eb00383c bl 204a4 <printf> <== NOT EXECUTED 123b0: e1a04006 mov r4, r6 <== NOT EXECUTED 123b4: eaffffb3 b 12288 <rtems_rfs_rtems_initialise+0xe0> <== NOT EXECUTED
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
printf ("rtems-rfs: mutex: obtain failed: %s\n",
123b8: e1a00008 mov r0, r8 <== NOT EXECUTED 123bc: ebffd312 bl 700c <rtems_status_text> <== NOT EXECUTED 123c0: e1a01000 mov r1, r0 <== NOT EXECUTED 123c4: e59f0034 ldr r0, [pc, #52] ; 12400 <rtems_rfs_rtems_initialise+0x258><== NOT EXECUTED 123c8: eb003835 bl 204a4 <printf> <== NOT EXECUTED 123cc: eaffffcd b 12308 <rtems_rfs_rtems_initialise+0x160> <== NOT EXECUTED
}
}
rtems = malloc (sizeof (rtems_rfs_rtems_private));
if (!rtems)
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
123d0: eb00346f bl 1f594 <__errno> <== NOT EXECUTED 123d4: e3a0300c mov r3, #12 <== NOT EXECUTED 123d8: e5803000 str r3, [r0] <== NOT EXECUTED 123dc: e3e04000 mvn r4, #0 <== NOT EXECUTED 123e0: eaffffa8 b 12288 <rtems_rfs_rtems_initialise+0xe0> <== NOT EXECUTED
000118e8 <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)
{
118e8: e92d4010 push {r4, lr}
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (targetloc);
118ec: e591c014 ldr ip, [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);
118f0: e590e008 ldr lr, [r0, #8] 118f4: e59c0008 ldr r0, [ip, #8] 118f8: e591c008 ldr ip, [r1, #8]
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)
{
118fc: e24dd008 sub sp, sp, #8
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);
11900: e1a01002 mov r1, r2 11904: e58dc000 str ip, [sp] 11908: e1a02003 mov r2, r3 1190c: e3a0c000 mov ip, #0 11910: e1a0300e mov r3, lr 11914: e58dc004 str ip, [sp, #4] 11918: eb002ded bl 1d0d4 <rtems_rfs_link>
if (rc)
1191c: e2504000 subs r4, r0, #0
{
return rtems_rfs_rtems_error ("link: linking", rc);
}
return 0;
11920: 01a03004 moveq r3, 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)
11924: 0a000002 beq 11934 <rtems_rfs_rtems_link+0x4c>
{
return rtems_rfs_rtems_error ("link: linking", rc);
11928: eb003719 bl 1f594 <__errno> <== NOT EXECUTED 1192c: e5804000 str r4, [r0] <== NOT EXECUTED 11930: e3e03000 mvn r3, #0 <== NOT EXECUTED
}
return 0;
}
11934: e1a00003 mov r0, r3
11938: e28dd008 add sp, sp, #8
1193c: e8bd8010 pop {r4, pc}
00012404 <rtems_rfs_rtems_lock_by_mt_entry>:
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
12404: e5903008 ldr r3, [r0, #8]
/* FIXME: Return value? */
rtems_rfs_fs_close(fs);
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
}
12408: e5933080 ldr r3, [r3, #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);
1240c: e3a01000 mov r1, #0
static void
rtems_rfs_rtems_lock_by_mt_entry (
const rtems_filesystem_mount_table_entry_t *mt_entry
)
{
12410: e92d4010 push {r4, lr}
12414: e5930000 ldr r0, [r3]
12418: e1a02001 mov r2, r1
1241c: ebffe5f4 bl bbf4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
12420: e2504000 subs r4, r0, #0
12424: 08bd8010 popeq {r4, pc}
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
12428: e3a00004 mov r0, #4 <== NOT EXECUTED
1242c: e3a01000 mov r1, #0 <== NOT EXECUTED
12430: eb0000fe bl 12830 <rtems_rfs_trace> <== NOT EXECUTED
12434: e3500000 cmp r0, #0 <== NOT EXECUTED
12438: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
1243c: e1a00004 mov r0, r4 <== NOT EXECUTED 12440: ebffd2f1 bl 700c <rtems_status_text> <== NOT EXECUTED 12444: e1a01000 mov r1, r0 <== NOT EXECUTED 12448: e59f0004 ldr r0, [pc, #4] ; 12454 <rtems_rfs_rtems_lock_by_mt_entry+0x50><== NOT EXECUTED
rtems_rfs_file_system* fs = mt_entry->fs_info;
rtems_rfs_rtems_lock (fs);
}
1244c: e8bd4010 pop {r4, lr} <== NOT EXECUTED
12450: ea003813 b 204a4 <printf> <== NOT EXECUTED
00011da0 <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)
{
11da0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
11da4: e1a06003 mov r6, r3
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parentloc);
11da8: 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)
{
11dac: e24dd040 sub sp, sp, #64 ; 0x40 11db0: e1a0c000 mov ip, r0
uid = 0;
gid = 0;
#endif
rc = rtems_rfs_inode_create (fs, parent, name, namelen,
rtems_rfs_rtems_imode (mode),
11db4: e1a00006 mov r0, r6
rtems_rfs_rtems_mknod (const rtems_filesystem_location_info_t *parentloc,
const char *name,
size_t namelen,
mode_t mode,
dev_t dev)
{
11db8: e1a07002 mov r7, r2 11dbc: e1a08001 mov r8, r1
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parentloc);
11dc0: e5934008 ldr r4, [r3, #8]
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parentloc);
11dc4: e59cb008 ldr fp, [ip, #8]
rtems_rfs_rtems_mknod (const rtems_filesystem_location_info_t *parentloc,
const char *name,
size_t namelen,
mode_t mode,
dev_t dev)
{
11dc8: e59da064 ldr sl, [sp, #100] ; 0x64 11dcc: e59d9068 ldr r9, [sp, #104] ; 0x68
uid = 0;
gid = 0;
#endif
rc = rtems_rfs_inode_create (fs, parent, name, namelen,
rtems_rfs_rtems_imode (mode),
11dd0: eb000292 bl 12820 <rtems_rfs_rtems_imode>
#else
uid = 0;
gid = 0;
#endif
rc = rtems_rfs_inode_create (fs, parent, name, namelen,
11dd4: e3a05001 mov r5, #1
11dd8: e3a0c000 mov ip, #0
11ddc: e58d0000 str r0, [sp]
11de0: e1a03007 mov r3, r7
11de4: e98d1020 stmib sp, {r5, ip}
11de8: e58dc00c str ip, [sp, #12]
11dec: e1a00004 mov r0, r4
11df0: e28dc03c add ip, sp, #60 ; 0x3c
11df4: e1a0100b mov r1, fp
11df8: e1a02008 mov r2, r8
11dfc: e58dc010 str ip, [sp, #16]
11e00: ebfffd92 bl 11450 <rtems_rfs_inode_create>
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
11e04: e2507000 subs r7, r0, #0
11e08: da000005 ble 11e24 <rtems_rfs_rtems_mknod+0x84>
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc > 0)
{
return rtems_rfs_rtems_error ("mknod: inode open", rc);
11e0c: eb0035e0 bl 1f594 <__errno> 11e10: e5807000 str r7, [r0] 11e14: e3e03000 mvn r3, #0
{
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
}
return 0;
}
11e18: e1a00003 mov r0, r3
11e1c: e28dd040 add sp, sp, #64 ; 0x40
11e20: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if (rc > 0)
{
return rtems_rfs_rtems_error ("mknod: inode create", rc);
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
11e24: e1a00004 mov r0, r4 11e28: e59d103c ldr r1, [sp, #60] ; 0x3c 11e2c: e28d2014 add r2, sp, #20 11e30: e1a03005 mov r3, r5 11e34: ebfffc23 bl 10ec8 <rtems_rfs_inode_open>
if (rc > 0)
11e38: e2507000 subs r7, r0, #0
11e3c: cafffff2 bgt 11e0c <rtems_rfs_rtems_mknod+0x6c>
{
return rtems_rfs_rtems_error ("mknod: inode open", rc);
}
if (S_ISDIR(mode) || S_ISREG(mode))
11e40: e2066a0f and r6, r6, #61440 ; 0xf000 11e44: e3560901 cmp r6, #16384 ; 0x4000 11e48: 13560902 cmpne r6, #32768 ; 0x8000
11e4c: 0a000012 beq 11e9c <rtems_rfs_rtems_mknod+0xfc>
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
11e50: e3560a02 cmp r6, #8192 ; 0x2000 <== NOT EXECUTED 11e54: 13560a06 cmpne r6, #24576 ; 0x6000 <== NOT EXECUTED 11e58: 1a000019 bne 11ec4 <rtems_rfs_rtems_mknod+0x124> <== 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);
11e5c: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 11e60: e1a06c2a lsr r6, sl, #24 <== NOT EXECUTED 11e64: e1a0e82a lsr lr, sl, #16 <== NOT EXECUTED 11e68: e1a0c42a lsr ip, sl, #8 <== NOT EXECUTED 11e6c: e1a00c29 lsr r0, r9, #24 <== NOT EXECUTED 11e70: e1a01829 lsr r1, r9, #16 <== NOT EXECUTED 11e74: e1a02429 lsr r2, r9, #8 <== NOT EXECUTED 11e78: e5c3601c strb r6, [r3, #28] <== NOT EXECUTED 11e7c: e5c3e01d strb lr, [r3, #29] <== NOT EXECUTED 11e80: e5c3c01e strb ip, [r3, #30] <== NOT EXECUTED 11e84: e5c3a01f strb sl, [r3, #31] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
11e88: e5cd5024 strb r5, [sp, #36] ; 0x24 <== NOT EXECUTED
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
11e8c: e5c30020 strb r0, [r3, #32] <== NOT EXECUTED 11e90: e5c31021 strb r1, [r3, #33] ; 0x21 <== NOT EXECUTED 11e94: e5c32022 strb r2, [r3, #34] ; 0x22 <== NOT EXECUTED 11e98: e5c39023 strb r9, [r3, #35] ; 0x23 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
}
rc = rtems_rfs_inode_close (fs, &inode);
11e9c: e1a00004 mov r0, r4 11ea0: e28d1014 add r1, sp, #20 11ea4: ebfffc81 bl 110b0 <rtems_rfs_inode_close>
if (rc > 0)
11ea8: e2504000 subs r4, r0, #0
{
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
}
return 0;
11eac: d3a03000 movle r3, #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)
11eb0: daffffd8 ble 11e18 <rtems_rfs_rtems_mknod+0x78>
{
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
11eb4: eb0035b6 bl 1f594 <__errno> <== NOT EXECUTED 11eb8: e3e03000 mvn r3, #0 <== NOT EXECUTED 11ebc: e5804000 str r4, [r0] <== NOT EXECUTED 11ec0: eaffffd4 b 11e18 <rtems_rfs_rtems_mknod+0x78> <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 0, major);
rtems_rfs_inode_set_block (&inode, 1, minor);
}
else
{
rtems_rfs_inode_close (fs, &inode);
11ec4: e28d1014 add r1, sp, #20 <== NOT EXECUTED 11ec8: e1a00004 mov r0, r4 <== NOT EXECUTED 11ecc: ebfffc77 bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
11ed0: eb0035af bl 1f594 <__errno> <== NOT EXECUTED 11ed4: e3a03016 mov r3, #22 <== NOT EXECUTED 11ed8: e5803000 str r3, [r0] <== NOT EXECUTED 11edc: e3e03000 mvn r3, #0 <== NOT EXECUTED 11ee0: eaffffcc b 11e18 <rtems_rfs_rtems_mknod+0x78> <== NOT EXECUTED
00011d28 <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)
{
11d28: e92d4070 push {r4, r5, r6, lr}
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
11d2c: e5902014 ldr r2, [r0, #20] 11d30: 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)
{
11d34: e1a03000 mov r3, r0 11d38: 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);
11d3c: e5931008 ldr r1, [r3, #8] 11d40: e1a00004 mov r0, r4 11d44: e1a0200d mov r2, sp 11d48: e3a03001 mov r3, #1 11d4c: ebfffc5d bl 10ec8 <rtems_rfs_inode_open>
if (rc > 0)
11d50: e2506000 subs r6, r0, #0
11d54: da000005 ble 11d70 <rtems_rfs_rtems_node_type+0x48>
{
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
11d58: eb00360d bl 1f594 <__errno> <== NOT EXECUTED 11d5c: e5806000 str r6, [r0] <== NOT EXECUTED 11d60: e3e05000 mvn r5, #0 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
}
return type;
}
11d64: e1a00005 mov r0, r5
11d68: e28dd028 add sp, sp, #40 ; 0x28
11d6c: e8bd8070 pop {r4, r5, r6, pc}
if (rc > 0)
{
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
}
type = rtems_rfs_rtems_node_type_by_inode (&inode);
11d70: e1a0000d mov r0, sp 11d74: ebfffe9d bl 117f0 <rtems_rfs_rtems_node_type_by_inode>
rc = rtems_rfs_inode_close (fs, &inode);
11d78: 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);
11d7c: e1a05000 mov r5, r0
rc = rtems_rfs_inode_close (fs, &inode);
11d80: e1a00004 mov r0, r4 11d84: ebfffcc9 bl 110b0 <rtems_rfs_inode_close>
if (rc > 0)
11d88: e2504000 subs r4, r0, #0
11d8c: dafffff4 ble 11d64 <rtems_rfs_rtems_node_type+0x3c>
{
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
11d90: eb0035ff bl 1f594 <__errno> <== NOT EXECUTED 11d94: e3e05000 mvn r5, #0 <== NOT EXECUTED 11d98: e5804000 str r4, [r0] <== NOT EXECUTED 11d9c: eafffff0 b 11d64 <rtems_rfs_rtems_node_type+0x3c> <== NOT EXECUTED
00011a2c <rtems_rfs_rtems_readlink>:
static ssize_t
rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
11a2c: e92d4010 push {r4, lr}
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
11a30: e5903014 ldr r3, [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);
11a34: e590e008 ldr lr, [r0, #8]
static ssize_t
rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
11a38: e24dd008 sub sp, sp, #8 11a3c: e1a0c001 mov ip, 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);
11a40: e5930008 ldr r0, [r3, #8] 11a44: e1a0100e mov r1, lr
static ssize_t
rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
11a48: e1a03002 mov r3, r2
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);
11a4c: e1a0200c mov r2, ip 11a50: e28dc004 add ip, sp, #4 11a54: e58dc000 str ip, [sp] 11a58: eb002fac bl 1d910 <rtems_rfs_symlink_read>
if (rc)
11a5c: e2504000 subs r4, r0, #0
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
}
return (ssize_t) length;
11a60: 059d3004 ldreq r3, [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)
11a64: 1a000002 bne 11a74 <rtems_rfs_rtems_readlink+0x48>
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
}
return (ssize_t) length;
}
11a68: e1a00003 mov r0, r3
11a6c: e28dd008 add sp, sp, #8
11a70: e8bd8010 pop {r4, pc}
printf ("rtems-rfs-rtems: readlink: in: ino:%" PRId32 "\n", ino);
rc = rtems_rfs_symlink_read (fs, ino, buf, bufsize, &length);
if (rc)
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
11a74: eb0036c6 bl 1f594 <__errno> <== NOT EXECUTED 11a78: e3e03000 mvn r3, #0 <== NOT EXECUTED 11a7c: e5804000 str r4, [r0] <== NOT EXECUTED 11a80: eafffff8 b 11a68 <rtems_rfs_rtems_readlink+0x3c> <== NOT EXECUTED
00011940 <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)
{
11940: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
11944: e1a0c001 mov ip, r1 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
11948: e5911014 ldr r1, [r1, #20] <== 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);
1194c: e592e008 ldr lr, [r2, #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);
11950: e5915008 ldr r5, [r1, #8] <== NOT EXECUTED
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)
{
11954: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
int rc;
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);
11958: e59c4008 ldr r4, [ip, #8] <== 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);
1195c: e5907008 ldr r7, [r0, #8] <== NOT EXECUTED
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);
11960: e59c600c ldr r6, [ip, #12] <== 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);
11964: e1a01003 mov r1, r3 <== NOT EXECUTED 11968: e3a0c001 mov ip, #1 <== NOT EXECUTED 1196c: e1a00005 mov r0, r5 <== NOT EXECUTED 11970: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 11974: e1a0300e mov r3, lr <== NOT EXECUTED 11978: e58d4000 str r4, [sp] <== NOT EXECUTED 1197c: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 11980: eb002dd3 bl 1d0d4 <rtems_rfs_link> <== NOT EXECUTED
if (rc)
11984: e2508000 subs r8, r0, #0 <== NOT EXECUTED 11988: 0a000005 beq 119a4 <bsp_section_bss_size+0x10> <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: linking", rc);
1198c: eb003700 bl 1f594 <__errno> <== NOT EXECUTED 11990: e5808000 str r8, [r0] <== NOT EXECUTED 11994: e3e03000 mvn r3, #0 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: unlinking", rc);
}
return 0;
}
11998: e1a00003 mov r0, r3 <== NOT EXECUTED
1199c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
119a0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
/*
* Unlink all inodes even directories with the dir option as false because a
* directory may not be empty.
*/
rc = rtems_rfs_unlink (fs, old_parent, ino, doff,
119a4: e1a02004 mov r2, r4 <== NOT EXECUTED 119a8: e1a03006 mov r3, r6 <== NOT EXECUTED 119ac: e3a0c002 mov ip, #2 <== NOT EXECUTED 119b0: e1a00005 mov r0, r5 <== NOT EXECUTED 119b4: e1a01007 mov r1, r7 <== NOT EXECUTED 119b8: e58dc000 str ip, [sp] <== NOT EXECUTED 119bc: eb002e35 bl 1d298 <rtems_rfs_unlink> <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
119c0: e2504000 subs r4, r0, #0 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: unlinking", rc);
}
return 0;
119c4: 01a03004 moveq r3, 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)
119c8: 0afffff2 beq 11998 <bsp_section_bss_size+0x4> <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: unlinking", rc);
119cc: eb0036f0 bl 1f594 <__errno> <== NOT EXECUTED 119d0: e3e03000 mvn r3, #0 <== NOT EXECUTED 119d4: e5804000 str r4, [r0] <== NOT EXECUTED 119d8: eaffffee b 11998 <bsp_section_bss_size+0x4> <== NOT EXECUTED
0001276c <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
1276c: 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);
12770: e591300c ldr r3, [r1, #12] 12774: e5d31002 ldrb r1, [r3, #2] 12778: e5d33003 ldrb r3, [r3, #3] 1277c: e1831401 orr r1, r3, r1, lsl #8
uint16_t mode = rtems_rfs_inode_get_mode (inode); loc->handlers = NULL; if (RTEMS_RFS_S_ISDIR (mode))
12780: e2013a0f and r3, r1, #61440 ; 0xf000
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
12784: e1a02000 mov r2, r0
uint16_t mode = rtems_rfs_inode_get_mode (inode); loc->handlers = NULL; if (RTEMS_RFS_S_ISDIR (mode))
12788: e3530901 cmp r3, #16384 ; 0x4000
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
1278c: e3a00000 mov r0, #0 12790: e5820010 str r0, [r2, #16]
if (RTEMS_RFS_S_ISDIR (mode))
12794: 0a000010 beq 127dc <rtems_rfs_rtems_set_handlers+0x70>
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
12798: e3530a02 cmp r3, #8192 ; 0x2000 1279c: 13530a06 cmpne r3, #24576 ; 0x6000 127a0: 13a04000 movne r4, #0 127a4: 03a04001 moveq r4, #1
127a8: 0a000007 beq 127cc <rtems_rfs_rtems_set_handlers+0x60>
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
127ac: e3530a0a cmp r3, #40960 ; 0xa000
127b0: 0a000011 beq 127fc <rtems_rfs_rtems_set_handlers+0x90>
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
127b4: e3530902 cmp r3, #32768 ; 0x8000
127b8: 0a00000b beq 127ec <rtems_rfs_rtems_set_handlers+0x80>
loc->handlers = rtems_rfs_rtems_handlers (file);
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
127bc: e59f0048 ldr r0, [pc, #72] ; 1280c <rtems_rfs_rtems_set_handlers+0xa0><== NOT EXECUTED 127c0: eb003737 bl 204a4 <printf> <== NOT EXECUTED
return false;
127c4: e1a00004 mov r0, r4 <== NOT EXECUTED
} return true; }
127c8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
127cc: e59f303c ldr r3, [pc, #60] ; 12810 <rtems_rfs_rtems_set_handlers+0xa4><== NOT EXECUTED
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
127d0: e3a00001 mov r0, #1 <== NOT EXECUTED
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
127d4: e5823010 str r3, [r2, #16] <== NOT EXECUTED
127d8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
rtems_rfs_inode_handle* inode)
{
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
127dc: e59f3030 ldr r3, [pc, #48] ; 12814 <rtems_rfs_rtems_set_handlers+0xa8>
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
127e0: e3a00001 mov r0, #1
rtems_rfs_inode_handle* inode)
{
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
127e4: e5823010 str r3, [r2, #16]
127e8: e8bd8010 pop {r4, pc}
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
loc->handlers = rtems_rfs_rtems_handlers (file);
127ec: e59f3024 ldr r3, [pc, #36] ; 12818 <rtems_rfs_rtems_set_handlers+0xac>
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
127f0: e3a00001 mov r0, #1
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
loc->handlers = rtems_rfs_rtems_handlers (file);
127f4: e5823010 str r3, [r2, #16]
127f8: e8bd8010 pop {r4, pc}
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
loc->handlers = rtems_rfs_rtems_handlers (link);
127fc: e59f3018 ldr r3, [pc, #24] ; 1281c <rtems_rfs_rtems_set_handlers+0xb0>
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
12800: e3a00001 mov r0, #1
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
loc->handlers = rtems_rfs_rtems_handlers (link);
12804: e5823010 str r3, [r2, #16]
12808: e8bd8010 pop {r4, pc}
00011848 <rtems_rfs_rtems_statvfs>:
* @return int
*/
static int
rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
11848: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
1184c: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 11850: 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)
{
11854: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 11858: 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);
1185c: e28d2004 add r2, sp, #4 <== NOT EXECUTED 11860: e1a0100d mov r1, sp <== NOT EXECUTED 11864: e1a00005 mov r0, r5 <== NOT EXECUTED 11868: ebfffd3a bl 10d58 <rtems_rfs_group_usage> <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
1186c: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs); sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
11870: e5951004 ldr r1, [r5, #4] <== 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);
11874: e283701c add r7, r3, #28 <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
11878: e59d3000 ldr r3, [sp] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree; sb->f_files = rtems_rfs_fs_inodes (fs);
1187c: e5952014 ldr r2, [r5, #20] <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
11880: e0631001 rsb r1, r3, r1 <== NOT EXECUTED
sb->f_bavail = sb->f_bfree; sb->f_files = rtems_rfs_fs_inodes (fs); sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
11884: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 11888: e0633002 rsb r3, r3, r2 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
1188c: e595a008 ldr sl, [r5, #8] <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs); sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
11890: e8970180 ldm r7, {r7, r8} <== NOT EXECUTED
sb->f_bavail = sb->f_bfree; sb->f_files = rtems_rfs_fs_inodes (fs); sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes; sb->f_favail = sb->f_ffree; sb->f_fsid = RTEMS_RFS_SB_MAGIC; sb->f_flag = rtems_rfs_fs_flags (fs);
11894: e5956000 ldr r6, [r5] <== NOT EXECUTED
sb->f_namemax = rtems_rfs_fs_max_name (fs);
11898: e595c01c ldr ip, [r5, #28] <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs); sb->f_blocks = rtems_rfs_fs_media_blocks (fs); sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks; sb->f_bavail = sb->f_bfree; sb->f_files = rtems_rfs_fs_inodes (fs); sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
1189c: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
sb->f_favail = sb->f_ffree;
118a0: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
118a4: e59f3038 ldr r3, [pc, #56] ; 118e4 <rtems_rfs_rtems_statvfs+0x9c><== 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);
118a8: e3a00000 mov r0, #0 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
118ac: e584a000 str sl, [r4] <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
118b0: e5848004 str r8, [r4, #4] <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
118b4: e5847008 str r7, [r4, #8] <== NOT EXECUTED 118b8: e584000c str r0, [r4, #12] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
118bc: e5841010 str r1, [r4, #16] <== NOT EXECUTED 118c0: e5840014 str r0, [r4, #20] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
118c4: e5841018 str r1, [r4, #24] <== NOT EXECUTED 118c8: e584001c str r0, [r4, #28] <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs);
118cc: e5842020 str r2, [r4, #32] <== NOT EXECUTED
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes; sb->f_favail = sb->f_ffree; sb->f_fsid = RTEMS_RFS_SB_MAGIC;
118d0: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
118d4: e5846030 str r6, [r4, #48] ; 0x30 <== NOT EXECUTED
sb->f_namemax = rtems_rfs_fs_max_name (fs);
118d8: e584c034 str ip, [r4, #52] ; 0x34 <== NOT EXECUTED
return 0;
}
118dc: e28dd008 add sp, sp, #8 <== NOT EXECUTED
118e0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
00011a84 <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)
{
11a84: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
11a88: e1a07003 mov r7, r3
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
11a8c: e5903014 ldr r3, [r0, #20]
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)
{
11a90: e24dd010 sub sp, sp, #16 11a94: e1a0c000 mov ip, r0
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),
11a98: e1a00007 mov r0, r7
const char* node_name,
size_t node_name_len,
const char* target)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
11a9c: e59c4008 ldr r4, [ip, #8]
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);
11aa0: e5938008 ldr r8, [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)
{
11aa4: e1a09001 mov r9, r1 11aa8: e1a0a002 mov sl, 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),
11aac: eb003f50 bl 217f4 <strlen> 11ab0: e1a06000 mov r6, r0
geteuid(), getegid(), parent);
11ab4: eb001170 bl 1607c <geteuid> 11ab8: e1a05000 mov r5, r0 11abc: eb001169 bl 16068 <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,
11ac0: e1a03007 mov r3, r7 11ac4: e58d0008 str r0, [sp, #8] 11ac8: e1a01009 mov r1, r9 11acc: e1a0200a mov r2, sl 11ad0: e1a00008 mov r0, r8 11ad4: e58d400c str r4, [sp, #12] 11ad8: e58d6000 str r6, [sp] 11adc: e58d5004 str r5, [sp, #4] 11ae0: eb002ee2 bl 1d670 <rtems_rfs_symlink>
target, strlen (target),
geteuid(), getegid(), parent);
if (rc)
11ae4: e2504000 subs r4, r0, #0
{
return rtems_rfs_rtems_error ("symlink: linking", rc);
}
return 0;
11ae8: 01a03004 moveq r3, r4
int rc;
rc = rtems_rfs_symlink (fs, node_name, node_name_len,
target, strlen (target),
geteuid(), getegid(), parent);
if (rc)
11aec: 0a000002 beq 11afc <rtems_rfs_rtems_symlink+0x78>
{
return rtems_rfs_rtems_error ("symlink: linking", rc);
11af0: eb0036a7 bl 1f594 <__errno> <== NOT EXECUTED 11af4: e5804000 str r4, [r0] <== NOT EXECUTED 11af8: e3e03000 mvn r3, #0 <== NOT EXECUTED
}
return 0;
}
11afc: e1a00003 mov r0, r3
11b00: e28dd010 add sp, sp, #16
11b04: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
00012458 <rtems_rfs_rtems_unlock_by_mt_entry>:
static void
rtems_rfs_rtems_unlock_by_mt_entry (
const rtems_filesystem_mount_table_entry_t *mt_entry
)
{
rtems_rfs_file_system* fs = mt_entry->fs_info;
12458: e5900008 ldr r0, [r0, #8]
static void
rtems_rfs_rtems_unlock_by_mt_entry (
const rtems_filesystem_mount_table_entry_t *mt_entry
)
{
1245c: e92d4010 push {r4, lr}
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
12460: e5904080 ldr r4, [r0, #128] ; 0x80
rtems_rfs_buffers_release (fs);
12464: eb001fcf bl 1a3a8 <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);
12468: e5940000 ldr r0, [r4] 1246c: ebffe629 bl bd18 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
12470: e2504000 subs r4, r0, #0
12474: 08bd8010 popeq {r4, pc}
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
12478: e3a00004 mov r0, #4 <== NOT EXECUTED
1247c: e3a01000 mov r1, #0 <== NOT EXECUTED
12480: eb0000ea bl 12830 <rtems_rfs_trace> <== NOT EXECUTED
12484: e3500000 cmp r0, #0 <== NOT EXECUTED
12488: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
1248c: e1a00004 mov r0, r4 <== NOT EXECUTED 12490: ebffd2dd bl 700c <rtems_status_text> <== NOT EXECUTED 12494: e1a01000 mov r1, r0 <== NOT EXECUTED 12498: e59f0004 ldr r0, [pc, #4] ; 124a4 <rtems_rfs_rtems_unlock_by_mt_entry+0x4c><== NOT EXECUTED
rtems_rfs_file_system* fs = mt_entry->fs_info;
rtems_rfs_rtems_unlock (fs);
}
1249c: e8bd4010 pop {r4, lr} <== NOT EXECUTED
124a0: ea0037ff b 204a4 <printf> <== NOT EXECUTED
00011b08 <rtems_rfs_rtems_utime>:
static int
rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
11b08: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
11b0c: e1a03000 mov r3, r0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
11b10: e5900014 ldr r0, [r0, #20] <== NOT EXECUTED 11b14: e5906008 ldr r6, [r0, #8] <== NOT EXECUTED
static int
rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
11b18: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED 11b1c: e1a05001 mov r5, r1 <== NOT EXECUTED 11b20: e1a04002 mov r4, r2 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_rfs_inode_handle inode;
int rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
11b24: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED 11b28: e1a00006 mov r0, r6 <== NOT EXECUTED 11b2c: e1a0200d mov r2, sp <== NOT EXECUTED 11b30: e3a03001 mov r3, #1 <== NOT EXECUTED 11b34: ebfffce3 bl 10ec8 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
11b38: e2507000 subs r7, r0, #0 <== NOT EXECUTED 11b3c: 0a000005 beq 11b58 <rtems_rfs_rtems_utime+0x50> <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: read inode", rc);
11b40: eb003693 bl 1f594 <__errno> <== NOT EXECUTED 11b44: e5807000 str r7, [r0] <== NOT EXECUTED 11b48: e3e03000 mvn r3, #0 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: closing inode", rc);
}
return 0;
}
11b4c: e1a00003 mov r0, r3 <== NOT EXECUTED
11b50: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
11b54: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
11b58: e59d300c ldr r3, [sp, #12] <== 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);
11b5c: e1a00c24 lsr r0, r4, #24 <== NOT EXECUTED 11b60: e1a01824 lsr r1, r4, #16 <== NOT EXECUTED 11b64: e1a02424 lsr r2, r4, #8 <== 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);
11b68: e1a0e825 lsr lr, r5, #16 <== NOT EXECUTED 11b6c: e1a0c425 lsr ip, r5, #8 <== NOT EXECUTED 11b70: e1a07c25 lsr r7, r5, #24 <== NOT EXECUTED 11b74: e5c37010 strb r7, [r3, #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);
11b78: e5c30014 strb r0, [r3, #20] <== NOT EXECUTED 11b7c: e5c31015 strb r1, [r3, #21] <== NOT EXECUTED 11b80: 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);
11b84: e5c3e011 strb lr, [r3, #17] <== NOT EXECUTED 11b88: e5c3c012 strb ip, [r3, #18] <== NOT EXECUTED 11b8c: 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);
11b90: 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);
11b94: e1a00006 mov r0, r6 <== NOT EXECUTED
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
11b98: e3a03001 mov r3, #1 <== NOT EXECUTED 11b9c: e1a0100d mov r1, sp <== NOT EXECUTED 11ba0: e5cd3010 strb r3, [sp, #16] <== NOT EXECUTED 11ba4: ebfffd41 bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc)
11ba8: e2504000 subs r4, r0, #0 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: closing inode", rc);
}
return 0;
11bac: 01a03004 moveq r3, 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)
11bb0: 0affffe5 beq 11b4c <rtems_rfs_rtems_utime+0x44> <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: closing inode", rc);
11bb4: eb003676 bl 1f594 <__errno> <== NOT EXECUTED 11bb8: e3e03000 mvn r3, #0 <== NOT EXECUTED 11bbc: e5804000 str r4, [r0] <== NOT EXECUTED 11bc0: eaffffe1 b 11b4c <rtems_rfs_rtems_utime+0x44> <== NOT EXECUTED
0000f844 <rtems_rfs_rup_quotient>:
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
f844: e3500000 cmp r0, #0 <== NOT EXECUTED
* Return a rounded up integer quotient given a dividend and divisor. That is:
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
f848: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if (dividend == 0)
f84c: 0a000003 beq f860 <rtems_rfs_rup_quotient+0x1c> <== NOT EXECUTED
return 1;
return ((dividend - 1) / divisor) + 1;
f850: e2400001 sub r0, r0, #1 <== NOT EXECUTED
f854: ebffc893 bl 1aa8 <__aeabi_uidiv> <== NOT EXECUTED
f858: e2800001 add r0, r0, #1 <== NOT EXECUTED
f85c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
f860: e3a00001 mov r0, #1 <== NOT EXECUTED
return ((dividend - 1) / divisor) + 1; }
f864: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00019c0c <rtems_rfs_scan_chain>:
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
19c0c: e92d40f0 push {r4, r5, r6, r7, lr}
19c10: e1a05000 mov r5, r0
19c14: e1a07001 mov r7, r1
rtems_rfs_buffer* buffer;
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
19c18: e3a00080 mov r0, #128 ; 0x80 19c1c: e3a01000 mov r1, #0
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
19c20: e1a06002 mov r6, r2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
19c24: e5954008 ldr r4, [r5, #8]
rtems_rfs_buffer* buffer;
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
19c28: ebffe300 bl 12830 <rtems_rfs_trace> 19c2c: e3500000 cmp r0, #0
19c30: 0a000004 beq 19c48 <rtems_rfs_scan_chain+0x3c>
19c34: ea000028 b 19cdc <rtems_rfs_scan_chain+0xd0> <== NOT EXECUTED
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
19c38: e5943034 ldr r3, [r4, #52] ; 0x34 19c3c: e1530006 cmp r3, r6
19c40: 0a00000d beq 19c7c <rtems_rfs_scan_chain+0x70>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Previous(
Chain_Node *the_node
)
{
return the_node->previous;
19c44: 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))
19c48: e1540005 cmp r4, r5
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
19c4c: e3a00080 mov r0, #128 ; 0x80 19c50: 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))
19c54: 0a000019 beq 19cc0 <rtems_rfs_scan_chain+0xb4>
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
19c58: ebffe2f4 bl 12830 <rtems_rfs_trace> 19c5c: e3500000 cmp r0, #0
19c60: 0afffff4 beq 19c38 <rtems_rfs_scan_chain+0x2c>
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
19c64: e5941034 ldr r1, [r4, #52] ; 0x34 <== NOT EXECUTED 19c68: e59f0080 ldr r0, [pc, #128] ; 19cf0 <rtems_rfs_scan_chain+0xe4><== NOT EXECUTED 19c6c: eb001a0c bl 204a4 <printf> <== NOT EXECUTED
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
19c70: e5943034 ldr r3, [r4, #52] ; 0x34 <== NOT EXECUTED 19c74: e1530006 cmp r3, r6 <== NOT EXECUTED 19c78: 1afffff1 bne 19c44 <rtems_rfs_scan_chain+0x38> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
19c7c: e3a00080 mov r0, #128 ; 0x80 19c80: e3a01000 mov r1, #0 19c84: ebffe2e9 bl 12830 <rtems_rfs_trace> 19c88: e3500000 cmp r0, #0
printf (": found block=%" PRIuPTR "\n",
19c8c: 159f0060 ldrne r0, [pc, #96] ; 19cf4 <rtems_rfs_scan_chain+0xe8> 19c90: 15941034 ldrne r1, [r4, #52] ; 0x34 19c94: 1b001a02 blne 204a4 <printf>
((intptr_t)(buffer->user)));
(*count)--;
19c98: e5973000 ldr r3, [r7] 19c9c: e2433001 sub r3, r3, #1 19ca0: e5873000 str r3, [r7]
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
19ca4: e1a00004 mov r0, r4 19ca8: ebfff46f bl 16e6c <_Chain_Extract>
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
19cac: e3a03000 mov r3, #0 19cb0: e5843004 str r3, [r4, #4] 19cb4: e5843000 str r3, [r4]
rtems_chain_extract (node);
rtems_chain_set_off_chain (node);
return buffer;
19cb8: e1a00004 mov r0, r4
19cbc: e8bd80f0 pop {r4, r5, r6, r7, pc}
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
19cc0: ebffe2da bl 12830 <rtems_rfs_trace>
19cc4: e3500000 cmp r0, #0
19cc8: 08bd80f0 popeq {r4, r5, r6, r7, pc}
printf (": not found\n");
19ccc: e59f0024 ldr r0, [pc, #36] ; 19cf8 <rtems_rfs_scan_chain+0xec><== NOT EXECUTED 19cd0: eb001a8b bl 20704 <puts> <== NOT EXECUTED
return NULL;
19cd4: e3a00000 mov r0, #0 <== NOT EXECUTED
}
19cd8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
rtems_chain_node* node;
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);
19cdc: e5971000 ldr r1, [r7] <== NOT EXECUTED 19ce0: e1a02006 mov r2, r6 <== NOT EXECUTED 19ce4: e59f0010 ldr r0, [pc, #16] ; 19cfc <rtems_rfs_scan_chain+0xf0><== NOT EXECUTED 19ce8: eb0019ed bl 204a4 <printf> <== NOT EXECUTED 19cec: eaffffd5 b 19c48 <rtems_rfs_scan_chain+0x3c> <== NOT EXECUTED
0001d670 <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
1d670: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1d674: e1a07000 mov r7, r0
1d678: e24dd0a4 sub sp, sp, #164 ; 0xa4
1d67c: e1a05001 mov r5, r1
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
1d680: e3a00000 mov r0, #0 1d684: e3a01002 mov r1, #2
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
1d688: e1a0a002 mov sl, r2 1d68c: e1a06003 mov r6, r3 1d690: e59d40c8 ldr r4, [sp, #200] ; 0xc8 1d694: e59db0d4 ldr fp, [sp, #212] ; 0xd4 1d698: e1dd8cbc ldrh r8, [sp, #204] ; 0xcc 1d69c: e1dd9db0 ldrh r9, [sp, #208] ; 0xd0
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
1d6a0: ebffd462 bl 12830 <rtems_rfs_trace> 1d6a4: e3500000 cmp r0, #0
1d6a8: 1a000006 bne 1d6c8 <rtems_rfs_symlink+0x58>
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
1d6ac: e5973008 ldr r3, [r7, #8] 1d6b0: e1540003 cmp r4, r3
return ENAMETOOLONG;
1d6b4: 23a0805b movcs r8, #91 ; 0x5b
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
1d6b8: 3a00001d bcc 1d734 <rtems_rfs_symlink+0xc4>
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
1d6bc: e1a00008 mov r0, r8
1d6c0: e28dd0a4 add sp, sp, #164 ; 0xa4
1d6c4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
1d6c8: e59f0234 ldr r0, [pc, #564] ; 1d904 <rtems_rfs_symlink+0x294><== NOT EXECUTED 1d6cc: e1a0100b mov r1, fp <== NOT EXECUTED 1d6d0: eb000b73 bl 204a4 <printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
1d6d4: e35a0000 cmp sl, #0 <== NOT EXECUTED 1d6d8: da000007 ble 1d6fc <rtems_rfs_symlink+0x8c> <== NOT EXECUTED 1d6dc: e3a03000 mov r3, #0 <== NOT EXECUTED
printf ("%c", name[c]);
1d6e0: e7d50003 ldrb r0, [r5, r3] <== 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++)
1d6e4: e2833001 add r3, r3, #1 <== NOT EXECUTED
printf ("%c", name[c]);
1d6e8: e58d3014 str r3, [sp, #20] <== NOT EXECUTED 1d6ec: eb000bd6 bl 2064c <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++)
1d6f0: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 1d6f4: e153000a cmp r3, sl <== NOT EXECUTED 1d6f8: 1afffff8 bne 1d6e0 <rtems_rfs_symlink+0x70> <== NOT EXECUTED
printf ("%c", name[c]);
printf (" link:");
1d6fc: e59f0204 ldr r0, [pc, #516] ; 1d908 <rtems_rfs_symlink+0x298><== NOT EXECUTED 1d700: eb000b67 bl 204a4 <printf> <== NOT EXECUTED
for (c = 0; c < link_length; c++)
1d704: e3540000 cmp r4, #0 <== NOT EXECUTED 1d708: daffffe7 ble 1d6ac <rtems_rfs_symlink+0x3c> <== NOT EXECUTED 1d70c: e3a0a000 mov sl, #0 <== NOT EXECUTED
printf ("%c", link[c]);
1d710: e7d6000a ldrb r0, [r6, sl] <== 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++)
1d714: e28aa001 add sl, sl, #1 <== NOT EXECUTED
printf ("%c", link[c]);
1d718: eb000bcb bl 2064c <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++)
1d71c: e15a0004 cmp sl, r4 <== NOT EXECUTED 1d720: 1afffffa bne 1d710 <rtems_rfs_symlink+0xa0> <== NOT EXECUTED
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
1d724: e5973008 ldr r3, [r7, #8] <== NOT EXECUTED 1d728: e1540003 cmp r4, r3 <== NOT EXECUTED
return ENAMETOOLONG;
1d72c: 23a0805b movcs r8, #91 ; 0x5b <== NOT EXECUTED
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
1d730: 2affffe1 bcs 1d6bc <rtems_rfs_symlink+0x4c> <== NOT EXECUTED
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
1d734: e1a00005 mov r0, r5 1d738: eb00102d bl 217f4 <strlen> 1d73c: e59fc1c8 ldr ip, [pc, #456] ; 1d90c <rtems_rfs_symlink+0x29c> 1d740: e1a03000 mov r3, r0 1d744: e58dc000 str ip, [sp] 1d748: e3a0a001 mov sl, #1 1d74c: e28dc09c add ip, sp, #156 ; 0x9c 1d750: e1a00007 mov r0, r7 1d754: e1a0100b mov r1, fp 1d758: e1a02005 mov r2, r5 1d75c: e58d8008 str r8, [sp, #8] 1d760: e58da004 str sl, [sp, #4] 1d764: e58d900c str r9, [sp, #12] 1d768: e58dc010 str ip, [sp, #16] 1d76c: ebffcf37 bl 11450 <rtems_rfs_inode_create>
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
1d770: e2508000 subs r8, r0, #0
1d774: caffffd0 bgt 1d6bc <rtems_rfs_symlink+0x4c>
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
1d778: e1a00007 mov r0, r7 1d77c: e59d109c ldr r1, [sp, #156] ; 0x9c 1d780: e28d2068 add r2, sp, #104 ; 0x68 1d784: e1a0300a mov r3, sl 1d788: ebffcdce bl 10ec8 <rtems_rfs_inode_open>
if (rc > 0)
1d78c: e2508000 subs r8, r0, #0
1d790: caffffc9 bgt 1d6bc <rtems_rfs_symlink+0x4c> /* * 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)
1d794: e3540013 cmp r4, #19
1d798: 8a000020 bhi 1d820 <rtems_rfs_symlink+0x1b0>
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
1d79c: e59d0074 ldr r0, [sp, #116] ; 0x74 1d7a0: e3a01000 mov r1, #0 1d7a4: e3a02014 mov r2, #20 1d7a8: e280001c add r0, r0, #28 1d7ac: eb000acb bl 202e0 <memset>
memcpy (inode.node->data.name, link, link_length);
1d7b0: e59d0074 ldr r0, [sp, #116] ; 0x74 1d7b4: e1a02004 mov r2, r4 1d7b8: e1a01006 mov r1, r6 1d7bc: e280001c add r0, r0, #28 1d7c0: eb000a43 bl 200d4 <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);
1d7c4: e59d2074 ldr r2, [sp, #116] ; 0x74 1d7c8: e3a03000 mov r3, #0 1d7cc: e5c2300c strb r3, [r2, #12] 1d7d0: e59d2074 ldr r2, [sp, #116] ; 0x74 1d7d4: e5c2300d strb r3, [r2, #13] 1d7d8: e59d2074 ldr r2, [sp, #116] ; 0x74 1d7dc: e5c2300e strb r3, [r2, #14] 1d7e0: e59d2074 ldr r2, [sp, #116] ; 0x74 1d7e4: e5c2300f strb r3, [r2, #15]
*/
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);
1d7e8: e59d3074 ldr r3, [sp, #116] ; 0x74
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rtems_rfs_inode_set_block_offset (&inode, link_length);
1d7ec: e1a04804 lsl r4, r4, #16 1d7f0: e1a02c24 lsr r2, r4, #24 1d7f4: e5c3200a strb r2, [r3, #10] 1d7f8: e59d3074 ldr r3, [sp, #116] ; 0x74 1d7fc: e1a04824 lsr r4, r4, #16 1d800: e5c3400b strb r4, [r3, #11]
rc = rtems_rfs_inode_close (fs, &inode);
1d804: e1a00007 mov r0, r7
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1d808: e3a03001 mov r3, #1 1d80c: e28d1068 add r1, sp, #104 ; 0x68 1d810: e5cd3078 strb r3, [sp, #120] ; 0x78 1d814: ebffce25 bl 110b0 <rtems_rfs_inode_close> 1d818: e1a08000 mov r8, r0
return rc;
1d81c: eaffffa6 b 1d6bc <rtems_rfs_symlink+0x4c>
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);
1d820: e1a00007 mov r0, r7 <== NOT EXECUTED 1d824: e28d1068 add r1, sp, #104 ; 0x68 <== NOT EXECUTED 1d828: e28d2018 add r2, sp, #24 <== NOT EXECUTED 1d82c: ebffedc1 bl 18f38 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
1d830: e2508000 subs r8, r0, #0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
1d834: e1a00007 mov r0, r7 <== 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)
1d838: da000002 ble 1d848 <rtems_rfs_symlink+0x1d8> <== NOT EXECUTED
}
rc = rtems_rfs_block_map_close (fs, &map);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
1d83c: e28d1068 add r1, sp, #104 ; 0x68 <== NOT EXECUTED 1d840: ebffce1a bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
1d844: eaffff9c b 1d6bc <rtems_rfs_symlink+0x4c> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
1d848: e28d1018 add r1, sp, #24 <== NOT EXECUTED 1d84c: e1a0200a mov r2, sl <== NOT EXECUTED 1d850: e28d30a0 add r3, sp, #160 ; 0xa0 <== NOT EXECUTED 1d854: ebffef0a bl 19484 <rtems_rfs_block_map_grow> <== NOT EXECUTED
if (rc > 0)
1d858: e2508000 subs r8, r0, #0 <== NOT EXECUTED 1d85c: da000006 ble 1d87c <rtems_rfs_symlink+0x20c> <== NOT EXECUTED
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
if (rc > 0)
{
rtems_rfs_block_map_close (fs, &map);
1d860: e28d1018 add r1, sp, #24 <== NOT EXECUTED 1d864: e1a00007 mov r0, r7 <== NOT EXECUTED 1d868: ebffee0c bl 190a0 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
1d86c: e1a00007 mov r0, r7 <== NOT EXECUTED 1d870: e28d1068 add r1, sp, #104 ; 0x68 <== NOT EXECUTED 1d874: ebffce0d bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
1d878: eaffff8f b 1d6bc <rtems_rfs_symlink+0x4c> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
1d87c: e3a05000 mov r5, #0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
1d880: e1a00007 mov r0, r7 <== NOT EXECUTED 1d884: e28d1090 add r1, sp, #144 ; 0x90 <== NOT EXECUTED 1d888: e59d20a0 ldr r2, [sp, #160] ; 0xa0 <== NOT EXECUTED 1d88c: e1a03005 mov r3, r5 <== NOT EXECUTED 1d890: e5cd5090 strb r5, [sp, #144] ; 0x90 <== NOT EXECUTED
handle->bnum = 0;
1d894: e58d5094 str r5, [sp, #148] ; 0x94 <== NOT EXECUTED
handle->buffer = NULL;
1d898: e58d5098 str r5, [sp, #152] ; 0x98 <== NOT EXECUTED 1d89c: ebfff190 bl 19ee4 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
1d8a0: e2508000 subs r8, r0, #0 <== NOT EXECUTED 1d8a4: caffffed bgt 1d860 <rtems_rfs_symlink+0x1f0> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
1d8a8: e59d3098 ldr r3, [sp, #152] ; 0x98 <== NOT EXECUTED 1d8ac: e593801c ldr r8, [r3, #28] <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
1d8b0: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED 1d8b4: e1a00008 mov r0, r8 <== NOT EXECUTED 1d8b8: e5972008 ldr r2, [r7, #8] <== NOT EXECUTED 1d8bc: eb000a87 bl 202e0 <memset> <== NOT EXECUTED
memcpy (data, link, link_length);
1d8c0: e1a02004 mov r2, r4 <== NOT EXECUTED 1d8c4: e1a00008 mov r0, r8 <== NOT EXECUTED 1d8c8: e1a01006 mov r1, r6 <== NOT EXECUTED 1d8cc: eb000a00 bl 200d4 <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);
1d8d0: e28d1090 add r1, sp, #144 ; 0x90 <== NOT EXECUTED 1d8d4: e1a00007 mov r0, r7 <== NOT EXECUTED 1d8d8: ebfff108 bl 19d00 <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);
1d8dc: e1a00007 mov r0, r7 <== NOT EXECUTED 1d8e0: e28d1018 add r1, sp, #24 <== NOT EXECUTED
handle->dirty = false;
1d8e4: e5cd5090 strb r5, [sp, #144] ; 0x90 <== NOT EXECUTED
handle->bnum = 0;
1d8e8: e58d5094 str r5, [sp, #148] ; 0x94 <== NOT EXECUTED
handle->buffer = NULL;
1d8ec: e58d5098 str r5, [sp, #152] ; 0x98 <== NOT EXECUTED 1d8f0: ebffedea bl 190a0 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
1d8f4: e2508000 subs r8, r0, #0 <== NOT EXECUTED 1d8f8: daffffba ble 1d7e8 <rtems_rfs_symlink+0x178> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
1d8fc: e1a00007 mov r0, r7 <== NOT EXECUTED 1d900: eaffffcd b 1d83c <rtems_rfs_symlink+0x1cc> <== NOT EXECUTED
0001d910 <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)
{
1d910: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
1d914: e1a04000 mov r4, r0
1d918: e24dd08c sub sp, sp, #140 ; 0x8c
1d91c: e1a05001 mov r5, r1
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
1d920: e3a00000 mov r0, #0 1d924: 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)
{
1d928: e1a07002 mov r7, r2 1d92c: e1a06003 mov r6, r3 1d930: e59d80a8 ldr r8, [sp, #168] ; 0xa8
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
1d934: ebffd3bd bl 12830 <rtems_rfs_trace> 1d938: e3500000 cmp r0, #0
1d93c: 1a000013 bne 1d990 <rtems_rfs_symlink_read+0x80>
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
rc = rtems_rfs_inode_open (fs, link, &inode, true);
1d940: e1a00004 mov r0, r4 1d944: e1a01005 mov r1, r5 1d948: e28d2054 add r2, sp, #84 ; 0x54 1d94c: e3a03001 mov r3, #1 1d950: ebffcd5c bl 10ec8 <rtems_rfs_inode_open>
if (rc)
1d954: e250a000 subs sl, r0, #0
1d958: 1a000009 bne 1d984 <rtems_rfs_symlink_read+0x74>
* @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);
1d95c: e59d1060 ldr r1, [sp, #96] ; 0x60 1d960: e5d13002 ldrb r3, [r1, #2]
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
1d964: e1a03403 lsl r3, r3, #8 1d968: e2033a0f and r3, r3, #61440 ; 0xf000 1d96c: e3530a0a cmp r3, #40960 ; 0xa000
1d970: 0a00000a beq 1d9a0 <rtems_rfs_symlink_read+0x90>
{
rtems_rfs_inode_close (fs, &inode);
1d974: e1a00004 mov r0, r4 <== NOT EXECUTED 1d978: e28d1054 add r1, sp, #84 ; 0x54 <== NOT EXECUTED 1d97c: ebffcdcb bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
return EINVAL;
1d980: e3a0a016 mov sl, #22 <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
1d984: e1a0000a mov r0, sl
1d988: e28dd08c add sp, sp, #140 ; 0x8c
1d98c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
{
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
1d990: e1a01005 mov r1, r5 <== NOT EXECUTED 1d994: e59f0154 ldr r0, [pc, #340] ; 1daf0 <rtems_rfs_symlink_read+0x1e0><== NOT EXECUTED 1d998: eb000ac1 bl 204a4 <printf> <== NOT EXECUTED 1d99c: eaffffe7 b 1d940 <rtems_rfs_symlink_read+0x30> <== 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);
1d9a0: e5d1300b ldrb r3, [r1, #11] 1d9a4: e5d1200a ldrb r2, [r1, #10]
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
1d9a8: 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;
1d9ac: e1520006 cmp r2, r6 1d9b0: 21a02006 movcs r2, r6 1d9b4: 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);
1d9b8: e5d1300d ldrb r3, [r1, #13] 1d9bc: e5d1000c ldrb r0, [r1, #12] 1d9c0: e1a03803 lsl r3, r3, #16 1d9c4: e5d1c00f ldrb ip, [r1, #15] 1d9c8: e1833c00 orr r3, r3, r0, lsl #24 1d9cc: e5d1000e ldrb r0, [r1, #14] 1d9d0: e183300c orr r3, r3, ip
if (size < *length)
{
*length = size;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
1d9d4: e1930400 orrs r0, r3, r0, lsl #8
1d9d8: 1a000007 bne 1d9fc <rtems_rfs_symlink_read+0xec>
{
memcpy (path, inode.node->data.name, *length);
1d9dc: e1a00007 mov r0, r7 1d9e0: e281101c add r1, r1, #28 1d9e4: eb0009ba bl 200d4 <memcpy>
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
1d9e8: e1a00004 mov r0, r4 1d9ec: e28d1054 add r1, sp, #84 ; 0x54 1d9f0: ebffcdae bl 110b0 <rtems_rfs_inode_close> 1d9f4: e1a0a000 mov sl, r0
return rc;
1d9f8: eaffffe1 b 1d984 <rtems_rfs_symlink_read+0x74>
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);
1d9fc: e1a00004 mov r0, r4 <== NOT EXECUTED 1da00: e28d1054 add r1, sp, #84 ; 0x54 <== NOT EXECUTED 1da04: e28d2004 add r2, sp, #4 <== NOT EXECUTED 1da08: ebffed4a bl 18f38 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
1da0c: e250a000 subs sl, r0, #0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
1da10: e1a00004 mov r0, r4 <== NOT EXECUTED
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
char* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
if (rc > 0)
1da14: da000002 ble 1da24 <rtems_rfs_symlink_read+0x114> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
if (rc > 0)
{
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
1da18: e28d1054 add r1, sp, #84 ; 0x54 <== NOT EXECUTED 1da1c: ebffcda3 bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
1da20: eaffffd7 b 1d984 <rtems_rfs_symlink_read+0x74> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
1da24: e28dc088 add ip, sp, #136 ; 0x88 <== NOT EXECUTED 1da28: e28d1004 add r1, sp, #4 <== NOT EXECUTED 1da2c: e3a02000 mov r2, #0 <== NOT EXECUTED 1da30: e3a03000 mov r3, #0 <== NOT EXECUTED 1da34: e58dc000 str ip, [sp] <== NOT EXECUTED 1da38: ebffee65 bl 193d4 <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
1da3c: e250a000 subs sl, r0, #0 <== NOT EXECUTED 1da40: da000006 ble 1da60 <rtems_rfs_symlink_read+0x150> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
1da44: e28d1004 add r1, sp, #4 <== NOT EXECUTED 1da48: e1a00004 mov r0, r4 <== NOT EXECUTED 1da4c: ebffed93 bl 190a0 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
1da50: e1a00004 mov r0, r4 <== NOT EXECUTED 1da54: e28d1054 add r1, sp, #84 ; 0x54 <== NOT EXECUTED 1da58: ebffcd94 bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
1da5c: eaffffc8 b 1d984 <rtems_rfs_symlink_read+0x74> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
1da60: e3a05000 mov r5, #0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
1da64: e1a00004 mov r0, r4 <== NOT EXECUTED 1da68: e28d107c add r1, sp, #124 ; 0x7c <== NOT EXECUTED 1da6c: e59d2088 ldr r2, [sp, #136] ; 0x88 <== NOT EXECUTED 1da70: e1a03005 mov r3, r5 <== NOT EXECUTED 1da74: e5cd507c strb r5, [sp, #124] ; 0x7c <== NOT EXECUTED
handle->bnum = 0;
1da78: e58d5080 str r5, [sp, #128] ; 0x80 <== NOT EXECUTED
handle->buffer = NULL;
1da7c: e58d5084 str r5, [sp, #132] ; 0x84 <== NOT EXECUTED 1da80: ebfff117 bl 19ee4 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
1da84: e250a000 subs sl, r0, #0 <== NOT EXECUTED 1da88: da000004 ble 1daa0 <rtems_rfs_symlink_read+0x190> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
1da8c: e1a00004 mov r0, r4 <== NOT EXECUTED 1da90: e28d1004 add r1, sp, #4 <== NOT EXECUTED 1da94: ebffed81 bl 190a0 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
1da98: e1a00004 mov r0, r4 <== NOT EXECUTED 1da9c: eaffffdd b 1da18 <rtems_rfs_symlink_read+0x108> <== NOT EXECUTED
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
memcpy (path, data, *length);
1daa0: e59d3084 ldr r3, [sp, #132] ; 0x84 <== NOT EXECUTED 1daa4: e5982000 ldr r2, [r8] <== NOT EXECUTED 1daa8: e593101c ldr r1, [r3, #28] <== NOT EXECUTED 1daac: e1a00007 mov r0, r7 <== NOT EXECUTED 1dab0: eb000987 bl 200d4 <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);
1dab4: e28d107c add r1, sp, #124 ; 0x7c <== NOT EXECUTED 1dab8: e1a00004 mov r0, r4 <== NOT EXECUTED 1dabc: ebfff08f bl 19d00 <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);
1dac0: e1a00004 mov r0, r4 <== NOT EXECUTED 1dac4: e28d1004 add r1, sp, #4 <== NOT EXECUTED
handle->dirty = false;
1dac8: e5cd507c strb r5, [sp, #124] ; 0x7c <== NOT EXECUTED
handle->bnum = 0;
1dacc: e58d5080 str r5, [sp, #128] ; 0x80 <== NOT EXECUTED
handle->buffer = NULL;
1dad0: e58d5084 str r5, [sp, #132] ; 0x84 <== NOT EXECUTED 1dad4: ebffed71 bl 190a0 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
1dad8: e250a000 subs sl, r0, #0 <== NOT EXECUTED 1dadc: daffffc1 ble 1d9e8 <rtems_rfs_symlink_read+0xd8> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
1dae0: e1a00004 mov r0, r4 <== NOT EXECUTED 1dae4: e28d1054 add r1, sp, #84 ; 0x54 <== NOT EXECUTED 1dae8: ebffcd70 bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
1daec: eaffffa4 b 1d984 <rtems_rfs_symlink_read+0x74> <== NOT EXECUTED
00012878 <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;
12878: e59fc018 ldr ip, [pc, #24] ; 12898 <rtems_rfs_trace_clear_mask+0x20><== NOT EXECUTED
1287c: e89c000c ldm ip, {r2, r3} <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
12880: e1c20000 bic r0, r2, r0 <== NOT EXECUTED
12884: e1c31001 bic r1, r3, r1 <== NOT EXECUTED
12888: e88c0003 stm ip, {r0, r1} <== NOT EXECUTED
return state; }
1288c: e1a00002 mov r0, r2 <== NOT EXECUTED 12890: e1a01003 mov r1, r3 <== NOT EXECUTED 12894: e12fff1e bx lr <== NOT EXECUTED
00012854 <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;
12854: e59fc018 ldr ip, [pc, #24] ; 12874 <rtems_rfs_trace_set_mask+0x20><== NOT EXECUTED
12858: e89c000c ldm ip, {r2, r3} <== NOT EXECUTED
rtems_rfs_trace_flags |= mask;
1285c: e1800002 orr r0, r0, r2 <== NOT EXECUTED
12860: e1811003 orr r1, r1, r3 <== NOT EXECUTED
12864: e88c0003 stm ip, {r0, r1} <== NOT EXECUTED
return state; }
12868: e1a00002 mov r0, r2 <== NOT EXECUTED 1286c: e1a01003 mov r1, r3 <== NOT EXECUTED 12870: e12fff1e bx lr <== NOT EXECUTED
0001289c <rtems_rfs_trace_shell_command>:
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
1289c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
128a0: e24dd0b8 sub sp, sp, #184 ; 0xb8 <== NOT EXECUTED
128a4: e1a09000 mov r9, r0 <== NOT EXECUTED
128a8: e58d1018 str r1, [sp, #24] <== NOT EXECUTED
const char* table[] =
128ac: e28d001c add r0, sp, #28 <== NOT EXECUTED 128b0: e59f127c ldr r1, [pc, #636] ; 12b34 <rtems_rfs_trace_shell_command+0x298><== NOT EXECUTED 128b4: e3a0209c mov r2, #156 ; 0x9c <== NOT EXECUTED 128b8: eb003605 bl 200d4 <memcpy> <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
128bc: e3590001 cmp r9, #1 <== NOT EXECUTED 128c0: da000049 ble 129ec <rtems_rfs_trace_shell_command+0x150> <== NOT EXECUTED
{
if (argv[arg][0] == '-')
128c4: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 128c8: e5936004 ldr r6, [r3, #4] <== NOT EXECUTED 128cc: e5d63000 ldrb r3, [r6] <== NOT EXECUTED 128d0: e353002d cmp r3, #45 ; 0x2d <== NOT EXECUTED 128d4: 0a00007b beq 12ac8 <rtems_rfs_trace_shell_command+0x22c> <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
return 0;
default:
printf ("error: unknown option\n");
return 1;
128d8: e59fb258 ldr fp, [pc, #600] ; 12b38 <rtems_rfs_trace_shell_command+0x29c><== NOT EXECUTED
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
128dc: e3a02000 mov r2, #0 <== NOT EXECUTED 128e0: e3a03000 mov r3, #0 <== NOT EXECUTED 128e4: e58d2008 str r2, [sp, #8] <== NOT EXECUTED 128e8: e58d300c str r3, [sp, #12] <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
return 0;
default:
printf ("error: unknown option\n");
return 1;
128ec: e89b0018 ldm fp, {r3, r4} <== NOT EXECUTED
128f0: e88d0018 stm sp, {r3, r4} <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
128f4: e59d4018 ldr r4, [sp, #24] <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
128f8: e3a08001 mov r8, #1 <== NOT EXECUTED
"file-close",
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
128fc: e3a02000 mov r2, #0 <== NOT EXECUTED 12900: e3a03000 mov r3, #0 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
12904: e284a004 add sl, r4, #4 <== NOT EXECUTED
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
12908: e1a07008 mov r7, r8 <== NOT EXECUTED
"file-close",
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
1290c: e58d2010 str r2, [sp, #16] <== NOT EXECUTED 12910: e58d3014 str r3, [sp, #20] <== NOT EXECUTED 12914: ea000013 b 12968 <rtems_rfs_trace_shell_command+0xcc> <== NOT EXECUTED
}
else
{
if (strcmp (argv[arg], "set") == 0)
set = true;
if (strcmp (argv[arg], "clear") == 0)
12918: e89d000c ldm sp, {r2, r3} <== NOT EXECUTED
1291c: e28d5010 add r5, sp, #16 <== NOT EXECUTED
12920: e8950030 ldm r5, {r4, r5} <== NOT EXECUTED
12924: e1822004 orr r2, r2, r4 <== NOT EXECUTED
12928: e1833005 orr r3, r3, r5 <== NOT EXECUTED
1292c: e28d5008 add r5, sp, #8 <== NOT EXECUTED
12930: e8950030 ldm r5, {r4, r5} <== NOT EXECUTED
12934: e1c24004 bic r4, r2, r4 <== NOT EXECUTED
12938: e1c35005 bic r5, r3, r5 <== NOT EXECUTED
1293c: e88d0030 stm sp, {r4, r5} <== NOT EXECUTED
set = false;
12940: e1a07000 mov r7, r0 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
12944: e2888001 add r8, r8, #1 <== NOT EXECUTED
}
}
}
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
12948: e89d0030 ldm sp, {r4, r5} <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
1294c: e1580009 cmp r8, r9 <== NOT EXECUTED
}
}
}
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
12950: e88b0030 stm fp, {r4, r5} <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
12954: 0a000024 beq 129ec <rtems_rfs_trace_shell_command+0x150> <== NOT EXECUTED
{
if (argv[arg][0] == '-')
12958: e5ba6004 ldr r6, [sl, #4]! <== NOT EXECUTED 1295c: e5d63000 ldrb r3, [r6] <== NOT EXECUTED 12960: e353002d cmp r3, #45 ; 0x2d <== NOT EXECUTED 12964: 0a000057 beq 12ac8 <rtems_rfs_trace_shell_command+0x22c> <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
12968: e59f11cc ldr r1, [pc, #460] ; 12b3c <rtems_rfs_trace_shell_command+0x2a0><== NOT EXECUTED 1296c: e1a00006 mov r0, r6 <== NOT EXECUTED 12970: eb003920 bl 20df8 <strcmp> <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
12974: e59f11c4 ldr r1, [pc, #452] ; 12b40 <rtems_rfs_trace_shell_command+0x2a4><== NOT EXECUTED
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
set = true;
12978: e3500000 cmp r0, #0 <== NOT EXECUTED
if (strcmp (argv[arg], "clear") == 0)
1297c: e1a00006 mov r0, r6 <== NOT EXECUTED
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
set = true;
12980: 03a07001 moveq r7, #1 <== NOT EXECUTED
if (strcmp (argv[arg], "clear") == 0)
12984: eb00391b bl 20df8 <strcmp> <== NOT EXECUTED 12988: e3500000 cmp r0, #0 <== NOT EXECUTED 1298c: 0affffe1 beq 12918 <rtems_rfs_trace_shell_command+0x7c> <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
12990: e1a00006 mov r0, r6 <== NOT EXECUTED 12994: e59f11a8 ldr r1, [pc, #424] ; 12b44 <rtems_rfs_trace_shell_command+0x2a8><== NOT EXECUTED 12998: eb003916 bl 20df8 <strcmp> <== NOT EXECUTED 1299c: e3500000 cmp r0, #0 <== NOT EXECUTED
{
if (set)
129a0: 128d4018 addne r4, sp, #24 <== NOT EXECUTED
{
if (strcmp (argv[arg], "set") == 0)
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
129a4: 13a05000 movne r5, #0 <== NOT EXECUTED 129a8: 1a000015 bne 12a04 <rtems_rfs_trace_shell_command+0x168> <== NOT EXECUTED
{
if (set)
129ac: e3570000 cmp r7, #0 <== NOT EXECUTED
129b0: 0a00003c beq 12aa8 <rtems_rfs_trace_shell_command+0x20c> <== NOT EXECUTED
129b4: e28d3008 add r3, sp, #8 <== NOT EXECUTED
129b8: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
129bc: e1e03003 mvn r3, r3 <== NOT EXECUTED
129c0: e1e02002 mvn r2, r2 <== NOT EXECUTED
129c4: e88d000c stm sp, {r2, r3} <== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
129c8: e3e04000 mvn r4, #0 <== NOT EXECUTED 129cc: e3e03000 mvn r3, #0 <== NOT EXECUTED 129d0: e58d3010 str r3, [sp, #16] <== NOT EXECUTED 129d4: e58d4014 str r4, [sp, #20] <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
129d8: e2888001 add r8, r8, #1 <== NOT EXECUTED
}
}
}
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
129dc: e89d0030 ldm sp, {r4, r5} <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
129e0: e1580009 cmp r8, r9 <== NOT EXECUTED
}
}
}
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
129e4: e88b0030 stm fp, {r4, r5} <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
129e8: 1affffda bne 12958 <rtems_rfs_trace_shell_command+0xbc> <== NOT EXECUTED
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
}
}
return 0;
129ec: e3a00000 mov r0, #0 <== NOT EXECUTED
}
129f0: e28dd0b8 add sp, sp, #184 ; 0xb8 <== NOT EXECUTED
129f4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
else
clear_value = RTEMS_RFS_TRACE_ALL;
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
129f8: e2855001 add r5, r5, #1 <== NOT EXECUTED 129fc: e3550027 cmp r5, #39 ; 0x27 <== NOT EXECUTED 12a00: 0a000024 beq 12a98 <rtems_rfs_trace_shell_command+0x1fc> <== NOT EXECUTED
{
if (strcmp (argv[arg], table[t]) == 0)
12a04: e1a00006 mov r0, r6 <== NOT EXECUTED 12a08: e5b41004 ldr r1, [r4, #4]! <== NOT EXECUTED 12a0c: eb0038f9 bl 20df8 <strcmp> <== NOT EXECUTED 12a10: e3500000 cmp r0, #0 <== NOT EXECUTED 12a14: 1afffff7 bne 129f8 <rtems_rfs_trace_shell_command+0x15c> <== NOT EXECUTED
{
if (set)
12a18: e3570000 cmp r7, #0 <== NOT EXECUTED
set_value = 1ULL << t;
12a1c: e2653020 rsb r3, r5, #32 <== NOT EXECUTED
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
{
if (set)
12a20: 0a000013 beq 12a74 <rtems_rfs_trace_shell_command+0x1d8> <== NOT EXECUTED
set_value = 1ULL << t;
12a24: e3a04001 mov r4, #1 <== NOT EXECUTED
12a28: e1a03334 lsr r3, r4, r3 <== NOT EXECUTED
12a2c: e58d3014 str r3, [sp, #20] <== NOT EXECUTED
12a30: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED
12a34: e2553020 subs r3, r5, #32 <== NOT EXECUTED
12a38: 51a00314 lslpl r0, r4, r3 <== NOT EXECUTED
12a3c: e1a05514 lsl r5, r4, r5 <== NOT EXECUTED
12a40: e58d0014 str r0, [sp, #20] <== NOT EXECUTED
12a44: e58d5010 str r5, [sp, #16] <== NOT EXECUTED
12a48: e28d3010 add r3, sp, #16 <== NOT EXECUTED
12a4c: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
12a50: e89d0030 ldm sp, {r4, r5} <== NOT EXECUTED
else
clear_value = RTEMS_RFS_TRACE_ALL;
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
12a54: e1822004 orr r2, r2, r4 <== NOT EXECUTED
12a58: e1833005 orr r3, r3, r5 <== NOT EXECUTED
12a5c: e28d5008 add r5, sp, #8 <== NOT EXECUTED
12a60: e8950030 ldm r5, {r4, r5} <== NOT EXECUTED
12a64: e1c24004 bic r4, r2, r4 <== NOT EXECUTED
12a68: e1c35005 bic r5, r3, r5 <== NOT EXECUTED
12a6c: e88d0030 stm sp, {r4, r5} <== NOT EXECUTED
12a70: eaffffb3 b 12944 <rtems_rfs_trace_shell_command+0xa8> <== NOT EXECUTED
if (strcmp (argv[arg], table[t]) == 0)
{
if (set)
set_value = 1ULL << t;
else
clear_value = 1ULL << t;
12a74: e3a01001 mov r1, #1 <== NOT EXECUTED 12a78: e1a03331 lsr r3, r1, r3 <== NOT EXECUTED 12a7c: e58d300c str r3, [sp, #12] <== NOT EXECUTED 12a80: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 12a84: e2553020 subs r3, r5, #32 <== NOT EXECUTED 12a88: 51a02311 lslpl r2, r1, r3 <== NOT EXECUTED 12a8c: e1a05511 lsl r5, r1, r5 <== NOT EXECUTED 12a90: e58d200c str r2, [sp, #12] <== NOT EXECUTED 12a94: e58d5008 str r5, [sp, #8] <== NOT EXECUTED
else
clear_value = RTEMS_RFS_TRACE_ALL;
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
12a98: e89d000c ldm sp, {r2, r3} <== NOT EXECUTED
12a9c: e28d5010 add r5, sp, #16 <== NOT EXECUTED
12aa0: e8950030 ldm r5, {r4, r5} <== NOT EXECUTED
12aa4: eaffffea b 12a54 <rtems_rfs_trace_shell_command+0x1b8> <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
12aa8: e3a03000 mov r3, #0 <== NOT EXECUTED
12aac: e3a02000 mov r2, #0 <== NOT EXECUTED
12ab0: e88d000c stm sp, {r2, r3} <== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
else
clear_value = RTEMS_RFS_TRACE_ALL;
12ab4: e3e04000 mvn r4, #0 <== NOT EXECUTED 12ab8: e3e03000 mvn r3, #0 <== NOT EXECUTED 12abc: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 12ac0: e58d400c str r4, [sp, #12] <== NOT EXECUTED 12ac4: eaffff9e b 12944 <rtems_rfs_trace_shell_command+0xa8> <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
12ac8: e5d63001 ldrb r3, [r6, #1] <== NOT EXECUTED 12acc: e3530068 cmp r3, #104 ; 0x68 <== NOT EXECUTED 12ad0: 0a000005 beq 12aec <rtems_rfs_trace_shell_command+0x250> <== NOT EXECUTED 12ad4: e353006c cmp r3, #108 ; 0x6c <== NOT EXECUTED 12ad8: 0a000009 beq 12b04 <rtems_rfs_trace_shell_command+0x268> <== NOT EXECUTED
printf ("%s: valid flags to set or clear are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
return 0;
default:
printf ("error: unknown option\n");
12adc: e59f0064 ldr r0, [pc, #100] ; 12b48 <rtems_rfs_trace_shell_command+0x2ac><== NOT EXECUTED 12ae0: eb003707 bl 20704 <puts> <== NOT EXECUTED
return 1;
12ae4: e3a00001 mov r0, #1 <== NOT EXECUTED 12ae8: eaffffc0 b 129f0 <rtems_rfs_trace_shell_command+0x154> <== NOT EXECUTED
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
12aec: e59d4018 ldr r4, [sp, #24] <== NOT EXECUTED 12af0: e59f0054 ldr r0, [pc, #84] ; 12b4c <rtems_rfs_trace_shell_command+0x2b0><== NOT EXECUTED 12af4: e5941000 ldr r1, [r4] <== NOT EXECUTED 12af8: eb003669 bl 204a4 <printf> <== NOT EXECUTED
return 0;
12afc: e3a00000 mov r0, #0 <== NOT EXECUTED 12b00: eaffffba b 129f0 <rtems_rfs_trace_shell_command+0x154> <== NOT EXECUTED
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
12b04: e59d5018 ldr r5, [sp, #24] <== NOT EXECUTED 12b08: e59f0040 ldr r0, [pc, #64] ; 12b50 <rtems_rfs_trace_shell_command+0x2b4><== NOT EXECUTED 12b0c: e5951000 ldr r1, [r5] <== NOT EXECUTED 12b10: eb003663 bl 204a4 <printf> <== NOT EXECUTED 12b14: e28d4018 add r4, sp, #24 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
12b18: e28d50b4 add r5, sp, #180 ; 0xb4 <== NOT EXECUTED
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++)
printf (" %s\n", table[t]);
12b1c: e5b41004 ldr r1, [r4, #4]! <== NOT EXECUTED 12b20: e59f002c ldr r0, [pc, #44] ; 12b54 <rtems_rfs_trace_shell_command+0x2b8><== NOT EXECUTED 12b24: eb00365e bl 204a4 <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++)
12b28: e1540005 cmp r4, r5 <== NOT EXECUTED 12b2c: 1afffffa bne 12b1c <rtems_rfs_trace_shell_command+0x280> <== NOT EXECUTED 12b30: eaffffad b 129ec <rtems_rfs_trace_shell_command+0x150> <== NOT EXECUTED
0001d298 <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)
{
1d298: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
1d29c: e1a04000 mov r4, r0
1d2a0: e24dd050 sub sp, sp, #80 ; 0x50
1d2a4: e1a06001 mov r6, r1
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1d2a8: e3a00402 mov r0, #33554432 ; 0x2000000 1d2ac: 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)
{
1d2b0: e1a05002 mov r5, r2 1d2b4: e1a08003 mov r8, r3 1d2b8: e59d9070 ldr r9, [sp, #112] ; 0x70
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1d2bc: ebffd55b bl 12830 <rtems_rfs_trace> 1d2c0: e3500000 cmp r0, #0
1d2c4: 1a00003f bne 1d3c8 <rtems_rfs_unlink+0x130>
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
1d2c8: e1a00004 mov r0, r4 1d2cc: e1a01005 mov r1, r5 1d2d0: e28d2028 add r2, sp, #40 ; 0x28 1d2d4: e3a03001 mov r3, #1 1d2d8: ebffcefa bl 10ec8 <rtems_rfs_inode_open>
if (rc)
1d2dc: e250a000 subs sl, r0, #0
1d2e0: 1a000013 bne 1d334 <rtems_rfs_unlink+0x9c>
* @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);
1d2e4: e59d3034 ldr r3, [sp, #52] ; 0x34 1d2e8: e5d37002 ldrb r7, [r3, #2]
/*
* If a directory process the unlink mode.
*/
dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
1d2ec: e1a07407 lsl r7, r7, #8 1d2f0: e2077a0f and r7, r7, #61440 ; 0xf000 1d2f4: e2473901 sub r3, r7, #16384 ; 0x4000 1d2f8: e2737000 rsbs r7, r3, #0 1d2fc: e0a77003 adc r7, r7, r3
if (dir)
1d300: e3570000 cmp r7, #0
1d304: 0a00000f beq 1d348 <rtems_rfs_unlink+0xb0>
{
switch (dir_mode)
1d308: e3590000 cmp r9, #0
1d30c: 1a00000b bne 1d340 <rtems_rfs_unlink+0xa8>
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1d310: e3a00402 mov r0, #33554432 ; 0x2000000 <== NOT EXECUTED 1d314: e3a01000 mov r1, #0 <== NOT EXECUTED 1d318: ebffd544 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1d31c: e3500000 cmp r0, #0 <== NOT EXECUTED 1d320: 1a00004d bne 1d45c <rtems_rfs_unlink+0x1c4> <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
1d324: e1a00004 mov r0, r4 <== NOT EXECUTED 1d328: e28d1028 add r1, sp, #40 ; 0x28 <== NOT EXECUTED 1d32c: ebffcf5f bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
return EISDIR;
1d330: e3a0a015 mov sl, #21 <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
1d334: e1a0000a mov r0, sl
1d338: e28dd050 add sp, sp, #80 ; 0x50
1d33c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
*/
dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
if (dir)
{
switch (dir_mode)
1d340: e3590001 cmp r9, #1
1d344: 0a000033 beq 1d418 <rtems_rfs_unlink+0x180>
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
1d348: e1a00004 mov r0, r4 1d34c: e1a01006 mov r1, r6 1d350: e1a0200d mov r2, sp 1d354: e3a03001 mov r3, #1 1d358: ebffceda bl 10ec8 <rtems_rfs_inode_open>
if (rc)
1d35c: e250a000 subs sl, r0, #0
1d360: 1a00001d bne 1d3dc <rtems_rfs_unlink+0x144>
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
1d364: e1a00004 mov r0, r4 1d368: e1a0100d mov r1, sp 1d36c: e1a02005 mov r2, r5 1d370: e1a03008 mov r3, r8 1d374: ebfff6f6 bl 1af54 <rtems_rfs_dir_del_entry>
if (rc > 0)
1d378: e250a000 subs sl, r0, #0
1d37c: da000039 ble 1d468 <rtems_rfs_unlink+0x1d0>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1d380: e3a00402 mov r0, #33554432 ; 0x2000000 <== NOT EXECUTED 1d384: e3a01000 mov r1, #0 <== NOT EXECUTED 1d388: ebffd528 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1d38c: e3500000 cmp r0, #0 <== NOT EXECUTED 1d390: 0a000005 beq 1d3ac <rtems_rfs_unlink+0x114> <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
1d394: e1a0000a mov r0, sl <== NOT EXECUTED 1d398: eb0010ef bl 2175c <strerror> <== NOT EXECUTED 1d39c: e1a0100a mov r1, sl <== NOT EXECUTED 1d3a0: e1a02000 mov r2, r0 <== NOT EXECUTED 1d3a4: e59f0298 ldr r0, [pc, #664] ; 1d644 <rtems_rfs_unlink+0x3ac><== NOT EXECUTED 1d3a8: eb000c3d bl 204a4 <printf> <== NOT EXECUTED
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
1d3ac: e1a0100d mov r1, sp <== NOT EXECUTED 1d3b0: e1a00004 mov r0, r4 <== NOT EXECUTED 1d3b4: ebffcf3d bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
1d3b8: e1a00004 mov r0, r4 <== NOT EXECUTED 1d3bc: e28d1028 add r1, sp, #40 ; 0x28 <== NOT EXECUTED 1d3c0: ebffcf3a bl 110b0 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
1d3c4: eaffffda b 1d334 <rtems_rfs_unlink+0x9c> <== NOT EXECUTED
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
1d3c8: e1a01006 mov r1, r6 <== NOT EXECUTED 1d3cc: e1a02005 mov r2, r5 <== NOT EXECUTED 1d3d0: e59f0270 ldr r0, [pc, #624] ; 1d648 <rtems_rfs_unlink+0x3b0><== NOT EXECUTED 1d3d4: eb000c32 bl 204a4 <printf> <== NOT EXECUTED 1d3d8: eaffffba b 1d2c8 <rtems_rfs_unlink+0x30> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
if (rc)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1d3dc: e3a00402 mov r0, #33554432 ; 0x2000000 <== NOT EXECUTED 1d3e0: e3a01000 mov r1, #0 <== NOT EXECUTED 1d3e4: ebffd511 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1d3e8: e3500000 cmp r0, #0 <== NOT EXECUTED 1d3ec: 0a000005 beq 1d408 <rtems_rfs_unlink+0x170> <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
1d3f0: e1a0000a mov r0, sl <== NOT EXECUTED 1d3f4: eb0010d8 bl 2175c <strerror> <== NOT EXECUTED 1d3f8: e1a0100a mov r1, sl <== NOT EXECUTED 1d3fc: e1a02000 mov r2, r0 <== NOT EXECUTED 1d400: e59f0244 ldr r0, [pc, #580] ; 1d64c <rtems_rfs_unlink+0x3b4><== NOT EXECUTED 1d404: eb000c26 bl 204a4 <printf> <== NOT EXECUTED
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
1d408: e1a00004 mov r0, r4 1d40c: e28d1028 add r1, sp, #40 ; 0x28 1d410: ebffcf26 bl 110b0 <rtems_rfs_inode_close>
return rc;
1d414: eaffffc6 b 1d334 <rtems_rfs_unlink+0x9c>
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
return EISDIR;
case rtems_rfs_unlink_dir_if_empty:
rc = rtems_rfs_dir_empty (fs, &target_inode);
1d418: e1a00004 mov r0, r4 1d41c: e28d1028 add r1, sp, #40 ; 0x28 1d420: ebfff8c2 bl 1b730 <rtems_rfs_dir_empty>
if (rc > 0)
1d424: e250a000 subs sl, r0, #0
1d428: daffffc6 ble 1d348 <rtems_rfs_unlink+0xb0>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1d42c: e3a00402 mov r0, #33554432 ; 0x2000000 1d430: e3a01000 mov r1, #0 1d434: ebffd4fd bl 12830 <rtems_rfs_trace> 1d438: e3500000 cmp r0, #0
1d43c: 0afffff1 beq 1d408 <rtems_rfs_unlink+0x170>
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
1d440: e1a0000a mov r0, sl <== NOT EXECUTED 1d444: eb0010c4 bl 2175c <strerror> <== NOT EXECUTED 1d448: e1a0100a mov r1, sl <== NOT EXECUTED 1d44c: e1a02000 mov r2, r0 <== NOT EXECUTED 1d450: e59f01f8 ldr r0, [pc, #504] ; 1d650 <rtems_rfs_unlink+0x3b8><== NOT EXECUTED 1d454: eb000c12 bl 204a4 <printf> <== NOT EXECUTED 1d458: eaffffea b 1d408 <rtems_rfs_unlink+0x170> <== NOT EXECUTED
{
switch (dir_mode)
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link is a directory\n");
1d45c: e59f01f0 ldr r0, [pc, #496] ; 1d654 <rtems_rfs_unlink+0x3bc><== NOT EXECUTED 1d460: eb000ca7 bl 20704 <puts> <== NOT EXECUTED 1d464: eaffffae b 1d324 <rtems_rfs_unlink+0x8c> <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
1d468: e59d3034 ldr r3, [sp, #52] ; 0x34 1d46c: e5d36000 ldrb r6, [r3] 1d470: e5d33001 ldrb r3, [r3, #1] 1d474: e1836406 orr r6, r3, r6, lsl #8
if (links == 0xffff)
links = 0;
1d478: e59f31d8 ldr r3, [pc, #472] ; 1d658 <rtems_rfs_unlink+0x3c0>
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1d47c: e3a00402 mov r0, #33554432 ; 0x2000000 1d480: e1560003 cmp r6, r3 1d484: e3a01000 mov r1, #0 1d488: 03a06000 moveq r6, #0 1d48c: ebffd4e7 bl 12830 <rtems_rfs_trace> 1d490: e3500000 cmp r0, #0
1d494: 1a00001d bne 1d510 <rtems_rfs_unlink+0x278>
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
if (links > 1)
1d498: e3560001 cmp r6, #1
1d49c: 9a000031 bls 1d568 <rtems_rfs_unlink+0x2d0>
{
links--;
1d4a0: e2466001 sub r6, r6, #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);
1d4a4: e59d3034 ldr r3, [sp, #52] ; 0x34 1d4a8: e1a06806 lsl r6, r6, #16 1d4ac: e1a02c26 lsr r2, r6, #24 1d4b0: e5c32000 strb r2, [r3] 1d4b4: e59d3034 ldr r3, [sp, #52] ; 0x34 1d4b8: e1a06826 lsr r6, r6, #16 1d4bc: e5c36001 strb r6, [r3, #1]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1d4c0: e3a03001 mov r3, #1 1d4c4: e5cd3038 strb r3, [sp, #56] ; 0x38
links--;
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
1d4c8: e3a01001 mov r1, #1 1d4cc: e1a0000d mov r0, sp 1d4d0: e1a02001 mov r2, r1 1d4d4: ebffcf53 bl 11228 <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
1d4d8: e250a000 subs sl, r0, #0
1d4dc: da000010 ble 1d524 <rtems_rfs_unlink+0x28c>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1d4e0: e3a00402 mov r0, #33554432 ; 0x2000000 <== NOT EXECUTED 1d4e4: e3a01000 mov r1, #0 <== NOT EXECUTED 1d4e8: ebffd4d0 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1d4ec: e3500000 cmp r0, #0 <== NOT EXECUTED 1d4f0: 0affffad beq 1d3ac <rtems_rfs_unlink+0x114> <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
1d4f4: e1a0000a mov r0, sl <== NOT EXECUTED 1d4f8: eb001097 bl 2175c <strerror> <== NOT EXECUTED 1d4fc: e1a0100a mov r1, sl <== NOT EXECUTED 1d500: e1a02000 mov r2, r0 <== NOT EXECUTED 1d504: e59f0150 ldr r0, [pc, #336] ; 1d65c <rtems_rfs_unlink+0x3c4><== NOT EXECUTED 1d508: eb000be5 bl 204a4 <printf> <== NOT EXECUTED 1d50c: eaffffa6 b 1d3ac <rtems_rfs_unlink+0x114> <== NOT EXECUTED
}
links = rtems_rfs_inode_get_links (&target_inode);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
1d510: e1a01005 mov r1, r5 <== NOT EXECUTED 1d514: e1a02006 mov r2, r6 <== NOT EXECUTED 1d518: e59f0140 ldr r0, [pc, #320] ; 1d660 <rtems_rfs_unlink+0x3c8><== NOT EXECUTED 1d51c: eb000be0 bl 204a4 <printf> <== NOT EXECUTED 1d520: eaffffdc b 1d498 <rtems_rfs_unlink+0x200> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
1d524: e1a00004 mov r0, r4 1d528: e1a0100d mov r1, sp 1d52c: ebffcedf bl 110b0 <rtems_rfs_inode_close>
if (rc > 0)
1d530: e250a000 subs sl, r0, #0
1d534: da00001c ble 1d5ac <rtems_rfs_unlink+0x314>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1d538: e3a00402 mov r0, #33554432 ; 0x2000000 <== NOT EXECUTED 1d53c: e3a01000 mov r1, #0 <== NOT EXECUTED 1d540: ebffd4ba bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1d544: e3500000 cmp r0, #0 <== NOT EXECUTED 1d548: 0affffae beq 1d408 <rtems_rfs_unlink+0x170> <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
1d54c: e1a0000a mov r0, sl <== NOT EXECUTED 1d550: eb001081 bl 2175c <strerror> <== NOT EXECUTED 1d554: e1a0100a mov r1, sl <== NOT EXECUTED 1d558: e1a02000 mov r2, r0 <== NOT EXECUTED 1d55c: e59f0100 ldr r0, [pc, #256] ; 1d664 <rtems_rfs_unlink+0x3cc><== NOT EXECUTED 1d560: eb000bcf bl 204a4 <printf> <== NOT EXECUTED 1d564: eaffffa7 b 1d408 <rtems_rfs_unlink+0x170> <== NOT EXECUTED
else
{
/*
* Erasing the inode releases all blocks attached to it.
*/
rc = rtems_rfs_inode_delete (fs, &target_inode);
1d568: e1a00004 mov r0, r4 1d56c: e28d1028 add r1, sp, #40 ; 0x28 1d570: ebffcef5 bl 1114c <rtems_rfs_inode_delete>
if (rc > 0)
1d574: e250a000 subs sl, r0, #0
1d578: da00001c ble 1d5f0 <rtems_rfs_unlink+0x358>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1d57c: e3a00402 mov r0, #33554432 ; 0x2000000 <== NOT EXECUTED 1d580: e3a01000 mov r1, #0 <== NOT EXECUTED 1d584: ebffd4a9 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1d588: e3500000 cmp r0, #0 <== NOT EXECUTED 1d58c: 0affff86 beq 1d3ac <rtems_rfs_unlink+0x114> <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
1d590: e1a0000a mov r0, sl <== NOT EXECUTED 1d594: eb001070 bl 2175c <strerror> <== NOT EXECUTED 1d598: e1a0100a mov r1, sl <== NOT EXECUTED 1d59c: e1a02000 mov r2, r0 <== NOT EXECUTED 1d5a0: e59f00c0 ldr r0, [pc, #192] ; 1d668 <rtems_rfs_unlink+0x3d0><== NOT EXECUTED 1d5a4: eb000bbe bl 204a4 <printf> <== NOT EXECUTED 1d5a8: eaffff7f b 1d3ac <rtems_rfs_unlink+0x114> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
1d5ac: e1a00004 mov r0, r4 1d5b0: e28d1028 add r1, sp, #40 ; 0x28 1d5b4: ebffcebd bl 110b0 <rtems_rfs_inode_close>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
1d5b8: e250a000 subs sl, r0, #0
1d5bc: daffff5c ble 1d334 <rtems_rfs_unlink+0x9c>
1d5c0: e3a00402 mov r0, #33554432 ; 0x2000000 <== NOT EXECUTED 1d5c4: e3a01000 mov r1, #0 <== NOT EXECUTED 1d5c8: ebffd498 bl 12830 <rtems_rfs_trace> <== NOT EXECUTED 1d5cc: e3500000 cmp r0, #0 <== NOT EXECUTED 1d5d0: 0affff57 beq 1d334 <rtems_rfs_unlink+0x9c> <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
1d5d4: e1a0000a mov r0, sl <== NOT EXECUTED 1d5d8: eb00105f bl 2175c <strerror> <== NOT EXECUTED 1d5dc: e1a0100a mov r1, sl <== NOT EXECUTED 1d5e0: e1a02000 mov r2, r0 <== NOT EXECUTED 1d5e4: e59f0080 ldr r0, [pc, #128] ; 1d66c <rtems_rfs_unlink+0x3d4><== NOT EXECUTED 1d5e8: eb000bad bl 204a4 <printf> <== NOT EXECUTED 1d5ec: eaffff50 b 1d334 <rtems_rfs_unlink+0x9c> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
if (dir)
1d5f0: e3570000 cmp r7, #0
1d5f4: 0affffb3 beq 1d4c8 <rtems_rfs_unlink+0x230>
*/
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);
1d5f8: e59d200c ldr r2, [sp, #12] 1d5fc: e5d21000 ldrb r1, [r2] 1d600: e5d23001 ldrb r3, [r2, #1] 1d604: e1833401 orr r3, r3, r1, lsl #8
if (links == 0xffff)
1d608: e59f1048 ldr r1, [pc, #72] ; 1d658 <rtems_rfs_unlink+0x3c0> 1d60c: e1530001 cmp r3, r1
links = 0;
1d610: 03a03000 moveq r3, #0
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
if (links == 0xffff)
1d614: 0a000003 beq 1d628 <rtems_rfs_unlink+0x390>
{
links = rtems_rfs_inode_get_links (&parent_inode);
if (links > 1)
1d618: e3530001 cmp r3, #1
links--;
1d61c: 82433001 subhi r3, r3, #1 1d620: 81a03803 lslhi r3, r3, #16 1d624: 81a03823 lsrhi r3, 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);
1d628: e1a01423 lsr r1, r3, #8 1d62c: e5c21000 strb r1, [r2] 1d630: e59d200c ldr r2, [sp, #12] 1d634: e5c23001 strb r3, [r2, #1]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
1d638: e3a03001 mov r3, #1 1d63c: e5cd3010 strb r3, [sp, #16] 1d640: eaffffa0 b 1d4c8 <rtems_rfs_unlink+0x230>
0002005c <rtems_shell_rfs_format>:
}
int
rtems_shell_rfs_format (int argc, char* argv[])
{
2005c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
20060: e3500001 cmp r0, #1 <== NOT EXECUTED
return 1;
}
int
rtems_shell_rfs_format (int argc, char* argv[])
{
20064: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
rtems_rfs_format_config config;
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
20068: e3a05000 mov r5, #0 <== NOT EXECUTED
return 1;
}
int
rtems_shell_rfs_format (int argc, char* argv[])
{
2006c: e1a06000 mov r6, r0 <== NOT EXECUTED 20070: e1a07001 mov r7, r1 <== NOT EXECUTED
rtems_rfs_format_config config;
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
20074: e58d5000 str r5, [sp] <== NOT EXECUTED 20078: e58d5004 str r5, [sp, #4] <== NOT EXECUTED 2007c: e58d5008 str r5, [sp, #8] <== NOT EXECUTED 20080: e58d500c str r5, [sp, #12] <== NOT EXECUTED 20084: e58d5010 str r5, [sp, #16] <== NOT EXECUTED 20088: e58d5014 str r5, [sp, #20] <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
2008c: da000083 ble 202a0 <rtems_shell_rfs_format+0x244> <== NOT EXECUTED 20090: e3a04001 mov r4, #1 <== NOT EXECUTED
}
config.group_inodes = strtoul (argv[arg], 0, 0);
break;
case 'I':
config.initialise_inodes = true;
20094: e1a08004 mov r8, r4 <== NOT EXECUTED 20098: ea000005 b 200b4 <rtems_shell_rfs_format+0x58> <== NOT EXECUTED
return 1;
}
}
else
{
if (!driver)
2009c: e3550000 cmp r5, #0 <== NOT EXECUTED 200a0: 1a00007a bne 20290 <rtems_shell_rfs_format+0x234> <== NOT EXECUTED 200a4: 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++)
200a8: e2844001 add r4, r4, #1 <== NOT EXECUTED 200ac: e1560004 cmp r6, r4 <== NOT EXECUTED 200b0: da00003a ble 201a0 <rtems_shell_rfs_format+0x144> <== NOT EXECUTED
{
if (argv[arg][0] == '-')
200b4: e7971104 ldr r1, [r7, r4, lsl #2] <== NOT EXECUTED 200b8: e5d13000 ldrb r3, [r1] <== NOT EXECUTED 200bc: e353002d cmp r3, #45 ; 0x2d <== NOT EXECUTED 200c0: 1afffff5 bne 2009c <rtems_shell_rfs_format+0x40> <== NOT EXECUTED
{
switch (argv[arg][1])
200c4: e5d13001 ldrb r3, [r1, #1] <== NOT EXECUTED 200c8: e2433049 sub r3, r3, #73 ; 0x49 <== NOT EXECUTED 200cc: e353002d cmp r3, #45 ; 0x2d <== NOT EXECUTED 200d0: 979ff103 ldrls pc, [pc, r3, lsl #2] <== NOT EXECUTED 200d4: ea000068 b 2027c <rtems_shell_rfs_format+0x220> <== NOT EXECUTED 200d8: 00020274 .word 0x00020274 <== NOT EXECUTED 200dc: 0002027c .word 0x0002027c <== NOT EXECUTED 200e0: 0002027c .word 0x0002027c <== NOT EXECUTED 200e4: 0002027c .word 0x0002027c <== NOT EXECUTED 200e8: 0002027c .word 0x0002027c <== NOT EXECUTED 200ec: 0002027c .word 0x0002027c <== NOT EXECUTED 200f0: 0002027c .word 0x0002027c <== NOT EXECUTED 200f4: 0002027c .word 0x0002027c <== NOT EXECUTED 200f8: 0002027c .word 0x0002027c <== NOT EXECUTED 200fc: 0002027c .word 0x0002027c <== NOT EXECUTED 20100: 0002027c .word 0x0002027c <== NOT EXECUTED 20104: 0002027c .word 0x0002027c <== NOT EXECUTED 20108: 0002027c .word 0x0002027c <== NOT EXECUTED 2010c: 0002027c .word 0x0002027c <== NOT EXECUTED 20110: 0002027c .word 0x0002027c <== NOT EXECUTED 20114: 0002027c .word 0x0002027c <== NOT EXECUTED 20118: 0002027c .word 0x0002027c <== NOT EXECUTED 2011c: 0002027c .word 0x0002027c <== NOT EXECUTED 20120: 0002027c .word 0x0002027c <== NOT EXECUTED 20124: 0002027c .word 0x0002027c <== NOT EXECUTED 20128: 0002027c .word 0x0002027c <== NOT EXECUTED 2012c: 0002027c .word 0x0002027c <== NOT EXECUTED 20130: 0002027c .word 0x0002027c <== NOT EXECUTED 20134: 0002027c .word 0x0002027c <== NOT EXECUTED 20138: 0002027c .word 0x0002027c <== NOT EXECUTED 2013c: 00020250 .word 0x00020250 <== NOT EXECUTED 20140: 0002027c .word 0x0002027c <== NOT EXECUTED 20144: 0002027c .word 0x0002027c <== NOT EXECUTED 20148: 0002027c .word 0x0002027c <== NOT EXECUTED 2014c: 0002027c .word 0x0002027c <== NOT EXECUTED 20150: 0002027c .word 0x0002027c <== NOT EXECUTED 20154: 0002027c .word 0x0002027c <== NOT EXECUTED 20158: 0002022c .word 0x0002022c <== NOT EXECUTED 2015c: 0002027c .word 0x0002027c <== NOT EXECUTED 20160: 0002027c .word 0x0002027c <== NOT EXECUTED 20164: 0002027c .word 0x0002027c <== NOT EXECUTED 20168: 0002027c .word 0x0002027c <== NOT EXECUTED 2016c: 0002027c .word 0x0002027c <== NOT EXECUTED 20170: 00020208 .word 0x00020208 <== NOT EXECUTED 20174: 0002027c .word 0x0002027c <== NOT EXECUTED 20178: 0002027c .word 0x0002027c <== NOT EXECUTED 2017c: 0002027c .word 0x0002027c <== NOT EXECUTED 20180: 000201e4 .word 0x000201e4 <== NOT EXECUTED 20184: 0002027c .word 0x0002027c <== NOT EXECUTED 20188: 0002027c .word 0x0002027c <== NOT EXECUTED 2018c: 00020190 .word 0x00020190 <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
20190: e2844001 add r4, r4, #1 <== NOT EXECUTED 20194: e1560004 cmp r6, r4 <== NOT EXECUTED
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
{
case 'v':
config.verbose = true;
20198: e5cd8015 strb r8, [sp, #21] <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
2019c: caffffc4 bgt 200b4 <rtems_shell_rfs_format+0x58> <== NOT EXECUTED
return 1;
}
}
}
if (!driver) {
201a0: e3550000 cmp r5, #0 <== NOT EXECUTED 201a4: 0a00003d beq 202a0 <rtems_shell_rfs_format+0x244> <== NOT EXECUTED
printf ("error: no driver name provided\n");
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
201a8: e1a00005 mov r0, r5 <== NOT EXECUTED 201ac: e1a0100d mov r1, sp <== NOT EXECUTED 201b0: eb003408 bl 2d1d8 <rtems_rfs_format> <== NOT EXECUTED 201b4: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("error: format of %s failed: %s\n",
driver, strerror (errno));
return 1;
}
return 0;
201b8: a3a00000 movge r0, #0 <== NOT EXECUTED
if (!driver) {
printf ("error: no driver name provided\n");
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
201bc: aa000031 bge 20288 <rtems_shell_rfs_format+0x22c> <== NOT EXECUTED
{
printf ("error: format of %s failed: %s\n",
driver, strerror (errno));
201c0: eb0056ad bl 35c7c <__errno> <== NOT EXECUTED
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
{
printf ("error: format of %s failed: %s\n",
201c4: e5900000 ldr r0, [r0] <== NOT EXECUTED 201c8: eb0071d6 bl 3c928 <strerror> <== NOT EXECUTED 201cc: e1a01005 mov r1, r5 <== NOT EXECUTED 201d0: e1a02000 mov r2, r0 <== NOT EXECUTED 201d4: e59f0114 ldr r0, [pc, #276] ; 202f0 <rtems_shell_rfs_format+0x294><== NOT EXECUTED 201d8: eb00685a bl 3a348 <printf> <== NOT EXECUTED
driver, strerror (errno));
return 1;
201dc: e3a00001 mov r0, #1 <== NOT EXECUTED 201e0: ea000028 b 20288 <rtems_shell_rfs_format+0x22c> <== NOT EXECUTED
case 'v':
config.verbose = true;
break;
case 's':
arg++;
201e4: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (arg >= argc)
201e8: e1560004 cmp r6, r4 <== NOT EXECUTED 201ec: da000033 ble 202c0 <rtems_shell_rfs_format+0x264> <== NOT EXECUTED
{
printf ("error: block size needs an argument\n");
return 1;
}
config.block_size = strtoul (argv[arg], 0, 0);
201f0: e3a01000 mov r1, #0 <== NOT EXECUTED 201f4: e7970104 ldr r0, [r7, r4, lsl #2] <== NOT EXECUTED 201f8: e1a02001 mov r2, r1 <== NOT EXECUTED 201fc: eb0077f9 bl 3e1e8 <strtoul> <== NOT EXECUTED 20200: e58d0000 str r0, [sp] <== NOT EXECUTED
break;
20204: eaffffa7 b 200a8 <rtems_shell_rfs_format+0x4c> <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
break;
case 'o':
arg++;
20208: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (arg >= argc)
2020c: e1560004 cmp r6, r4 <== NOT EXECUTED 20210: da000032 ble 202e0 <rtems_shell_rfs_format+0x284> <== NOT EXECUTED
{
printf ("error: inode percentage overhead needs an argument\n");
return 1;
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
20214: e3a01000 mov r1, #0 <== NOT EXECUTED 20218: e7970104 ldr r0, [r7, r4, lsl #2] <== NOT EXECUTED 2021c: e1a02001 mov r2, r1 <== NOT EXECUTED 20220: eb0077f0 bl 3e1e8 <strtoul> <== NOT EXECUTED 20224: e58d000c str r0, [sp, #12] <== NOT EXECUTED
break;
20228: eaffff9e b 200a8 <rtems_shell_rfs_format+0x4c> <== NOT EXECUTED
}
config.group_blocks = strtoul (argv[arg], 0, 0);
break;
case 'i':
arg++;
2022c: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (arg >= argc)
20230: e1560004 cmp r6, r4 <== NOT EXECUTED 20234: da000025 ble 202d0 <rtems_shell_rfs_format+0x274> <== NOT EXECUTED
{
printf ("error: group inode count needs an argument\n");
return 1;
}
config.group_inodes = strtoul (argv[arg], 0, 0);
20238: e3a01000 mov r1, #0 <== NOT EXECUTED 2023c: e7970104 ldr r0, [r7, r4, lsl #2] <== NOT EXECUTED 20240: e1a02001 mov r2, r1 <== NOT EXECUTED 20244: eb0077e7 bl 3e1e8 <strtoul> <== NOT EXECUTED 20248: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
break;
2024c: eaffff95 b 200a8 <rtems_shell_rfs_format+0x4c> <== NOT EXECUTED
}
config.block_size = strtoul (argv[arg], 0, 0);
break;
case 'b':
arg++;
20250: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (arg >= argc)
20254: e1560004 cmp r6, r4 <== NOT EXECUTED 20258: da000014 ble 202b0 <rtems_shell_rfs_format+0x254> <== NOT EXECUTED
{
printf ("error: group block count needs an argument\n");
return 1;
}
config.group_blocks = strtoul (argv[arg], 0, 0);
2025c: e3a01000 mov r1, #0 <== NOT EXECUTED 20260: e7970104 ldr r0, [r7, r4, lsl #2] <== NOT EXECUTED 20264: e1a02001 mov r2, r1 <== NOT EXECUTED 20268: eb0077de bl 3e1e8 <strtoul> <== NOT EXECUTED 2026c: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
break;
20270: eaffff8c b 200a8 <rtems_shell_rfs_format+0x4c> <== NOT EXECUTED
}
config.group_inodes = strtoul (argv[arg], 0, 0);
break;
case 'I':
config.initialise_inodes = true;
20274: e5cd8014 strb r8, [sp, #20] <== NOT EXECUTED
break;
20278: eaffff8a b 200a8 <rtems_shell_rfs_format+0x4c> <== NOT EXECUTED
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
break;
default:
printf ("error: invalid option: %s\n", argv[arg]);
2027c: e59f0070 ldr r0, [pc, #112] ; 202f4 <rtems_shell_rfs_format+0x298><== NOT EXECUTED 20280: eb006830 bl 3a348 <printf> <== NOT EXECUTED
return 1;
20284: e3a00001 mov r0, #1 <== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
20288: e28dd018 add sp, sp, #24 <== NOT EXECUTED
2028c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
{
if (!driver)
driver = argv[arg];
else
{
printf ("error: only one driver name allowed: %s\n", argv[arg]);
20290: e59f0060 ldr r0, [pc, #96] ; 202f8 <rtems_shell_rfs_format+0x29c><== NOT EXECUTED 20294: eb00682b bl 3a348 <printf> <== NOT EXECUTED
return 1;
20298: e3a00001 mov r0, #1 <== NOT EXECUTED 2029c: eafffff9 b 20288 <rtems_shell_rfs_format+0x22c> <== NOT EXECUTED
}
}
}
if (!driver) {
printf ("error: no driver name provided\n");
202a0: e59f0054 ldr r0, [pc, #84] ; 202fc <rtems_shell_rfs_format+0x2a0><== NOT EXECUTED 202a4: eb0068bf bl 3a5a8 <puts> <== NOT EXECUTED
return 1;
202a8: e3a00001 mov r0, #1 <== NOT EXECUTED 202ac: eafffff5 b 20288 <rtems_shell_rfs_format+0x22c> <== NOT EXECUTED
case 'b':
arg++;
if (arg >= argc)
{
printf ("error: group block count needs an argument\n");
202b0: e59f0048 ldr r0, [pc, #72] ; 20300 <rtems_shell_rfs_format+0x2a4><== NOT EXECUTED 202b4: eb0068bb bl 3a5a8 <puts> <== NOT EXECUTED
return 1;
202b8: e3a00001 mov r0, #1 <== NOT EXECUTED 202bc: eafffff1 b 20288 <rtems_shell_rfs_format+0x22c> <== NOT EXECUTED
case 's':
arg++;
if (arg >= argc)
{
printf ("error: block size needs an argument\n");
202c0: e59f003c ldr r0, [pc, #60] ; 20304 <rtems_shell_rfs_format+0x2a8><== NOT EXECUTED 202c4: eb0068b7 bl 3a5a8 <puts> <== NOT EXECUTED
return 1;
202c8: e3a00001 mov r0, #1 <== NOT EXECUTED 202cc: eaffffed b 20288 <rtems_shell_rfs_format+0x22c> <== NOT EXECUTED
case 'i':
arg++;
if (arg >= argc)
{
printf ("error: group inode count needs an argument\n");
202d0: e59f0030 ldr r0, [pc, #48] ; 20308 <rtems_shell_rfs_format+0x2ac><== NOT EXECUTED 202d4: eb0068b3 bl 3a5a8 <puts> <== NOT EXECUTED
return 1;
202d8: e3a00001 mov r0, #1 <== NOT EXECUTED 202dc: eaffffe9 b 20288 <rtems_shell_rfs_format+0x22c> <== NOT EXECUTED
case 'o':
arg++;
if (arg >= argc)
{
printf ("error: inode percentage overhead needs an argument\n");
202e0: e59f0024 ldr r0, [pc, #36] ; 2030c <rtems_shell_rfs_format+0x2b0><== NOT EXECUTED 202e4: eb0068af bl 3a5a8 <puts> <== NOT EXECUTED
return 1;
202e8: e3a00001 mov r0, #1 <== NOT EXECUTED 202ec: eaffffe5 b 20288 <rtems_shell_rfs_format+0x22c> <== NOT EXECUTED
0000ddfc <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 )
{
ddfc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
de00: e24dd008 sub sp, sp, #8
de04: e59d502c ldr r5, [sp, #44] ; 0x2c
rtems_status_code sc;
if ( blocks_with_buffer <= media_block_count ) {
de08: e1530005 cmp r3, r5
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 )
{
de0c: e1a09000 mov r9, r0
de10: e1a04003 mov r4, r3
de14: e1a06001 mov r6, r1
de18: e1a07002 mov r7, r2
de1c: e59db034 ldr fp, [sp, #52] ; 0x34
de20: e5dd8030 ldrb r8, [sp, #48] ; 0x30
sparse_disk_ioctl,
sparse_disk
);
}
} else {
sc = RTEMS_INVALID_NUMBER;
de24: 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 ) {
de28: 9a000001 bls de34 <rtems_sparse_disk_register+0x38>
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
de2c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
de30: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
const uint8_t fill_pattern )
{
rtems_status_code sc;
rtems_blkdev_bnum i;
if ( NULL == sd )
de34: e3510000 cmp r1, #0
de38: 0a00002b beq deec <rtems_sparse_disk_register+0xf0>
return RTEMS_INVALID_ADDRESS;
uint8_t *data = (uint8_t *) sd;
size_t const key_table_size = blocks_with_buffer
de3c: e1a0c183 lsl ip, 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 );
de40: e28ca01c add sl, ip, #28
de44: e3a01000 mov r1, #0
de48: e1a0200a mov r2, sl
de4c: e1a00006 mov r0, r6
de50: e58dc004 str ip, [sp, #4]
de54: eb003173 bl 1a428 <memset>
sd->fill_pattern = fill_pattern;
memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
de58: e1a01008 mov r1, r8
de5c: e0020497 mul r2, r7, r4
* 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;
de60: e5c68014 strb r8, [r6, #20]
memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),
de64: e086000a add r0, r6, sl
de68: eb00316e bl 1a428 <memset>
sd->fill_pattern,
data_size );
sd->delete_handler = sparse_disk_delete;
de6c: e586b010 str fp, [r6, #16]
sc = rtems_semaphore_create(
de70: e59f007c ldr r0, [pc, #124] ; def4 <rtems_sparse_disk_register+0xf8>
de74: e3a01001 mov r1, #1
de78: e3a02054 mov r2, #84 ; 0x54
de7c: e3a03000 mov r3, #0
de80: e58d6000 str r6, [sp]
de84: ebffe9d2 bl 85d4 <rtems_semaphore_create>
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY,
0,
&sd->mutex
);
if ( sc != RTEMS_SUCCESSFUL ) {
de88: e3500000 cmp r0, #0
de8c: e59dc004 ldr ip, [sp, #4]
de90: 1affffe5 bne de2c <rtems_sparse_disk_register+0x30>
return sc;
}
data += sizeof( rtems_sparse_disk );
de94: e286301c add r3, r6, #28
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 ) {
de98: e3540000 cmp r4, #0
return sc;
}
data += sizeof( rtems_sparse_disk );
sd->blocks_with_buffer = blocks_with_buffer;
de9c: e5864004 str r4, [r6, #4]
sd->key_table = (rtems_sparse_disk_key *) data;
dea0: e5863018 str r3, [r6, #24]
data += key_table_size;
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
dea4: 0a000007 beq dec8 <rtems_sparse_disk_register+0xcc>
data += sizeof( rtems_sparse_disk );
sd->blocks_with_buffer = blocks_with_buffer;
sd->key_table = (rtems_sparse_disk_key *) data;
data += key_table_size;
dea8: e083c00c add ip, r3, ip
deac: e1a03006 mov r3, r6
for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
deb0: e2800001 add r0, r0, #1
deb4: e1500004 cmp r0, r4
sd->key_table[i].data = data;
deb8: e583c020 str ip, [r3, #32]
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 ) {
debc: e08cc007 add ip, ip, r7
dec0: e2833008 add r3, r3, #8
dec4: 1afffff9 bne deb0 <rtems_sparse_disk_register+0xb4>
sparse_disk_delete,
fill_pattern
);
if ( RTEMS_SUCCESSFUL == sc ) {
sc = rtems_blkdev_create(
dec8: e59f3028 ldr r3, [pc, #40] ; def8 <rtems_sparse_disk_register+0xfc>
decc: e1a00009 mov r0, r9
ded0: e1a01007 mov r1, r7
ded4: e1a02005 mov r2, r5
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;
ded8: e586700c str r7, [r6, #12]
sparse_disk_delete,
fill_pattern
);
if ( RTEMS_SUCCESSFUL == sc ) {
sc = rtems_blkdev_create(
dedc: e58d602c str r6, [sp, #44] ; 0x2c
} else {
sc = RTEMS_INVALID_NUMBER;
}
return sc;
}
dee0: e28dd008 add sp, sp, #8
dee4: e8bd4ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, lr}
sparse_disk_delete,
fill_pattern
);
if ( RTEMS_SUCCESSFUL == sc ) {
sc = rtems_blkdev_create(
dee8: ea000ad4 b 10a40 <rtems_blkdev_create>
{
rtems_status_code sc;
rtems_blkdev_bnum i;
if ( NULL == sd )
return RTEMS_INVALID_ADDRESS;
deec: e3a00009 mov r0, #9 <== NOT EXECUTED
def0: eaffffcd b de2c <rtems_sparse_disk_register+0x30> <== NOT EXECUTED
00021d3c <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
21d3c: e92d4830 push {r4, r5, fp, lr}
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
21d40: e59f4074 ldr r4, [pc, #116] ; 21dbc <rtems_stack_checker_is_blown+0x80> 21d44: e5943008 ldr r3, [r4, #8]
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
21d48: e59300b4 ldr r0, [r3, #180] ; 0xb4
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
21d4c: e28db00c add fp, sp, #12
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
21d50: e15b0000 cmp fp, r0
return false;
21d54: 33a05000 movcc r5, #0
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
21d58: 3a000004 bcc 21d70 <rtems_stack_checker_is_blown+0x34>
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
21d5c: e59350b0 ldr r5, [r3, #176] ; 0xb0 21d60: e0805005 add r5, r0, r5
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
21d64: e15b0005 cmp fp, r5 21d68: 83a05000 movhi r5, #0 21d6c: 93a05001 movls r5, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
21d70: e59f3048 ldr r3, [pc, #72] ; 21dc0 <rtems_stack_checker_is_blown+0x84> 21d74: e5933008 ldr r3, [r3, #8] 21d78: 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;
21d7c: 03a01001 moveq r1, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
21d80: 0a000005 beq 21d9c <rtems_stack_checker_is_blown+0x60>
pattern_ok = (!memcmp(
21d84: e59f1038 ldr r1, [pc, #56] ; 21dc4 <rtems_stack_checker_is_blown+0x88> 21d88: e2800008 add r0, r0, #8 21d8c: e3a02010 mov r2, #16 21d90: eb005c4e bl 38ed0 <memcmp> 21d94: e2701001 rsbs r1, r0, #1 21d98: 33a01000 movcc r1, #0
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
21d9c: e3550000 cmp r5, #0
21da0: 0a000003 beq 21db4 <rtems_stack_checker_is_blown+0x78>
21da4: e3510000 cmp r1, #0
21da8: 0a000001 beq 21db4 <rtems_stack_checker_is_blown+0x78>
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
21dac: e3a00000 mov r0, #0
21db0: e8bd8830 pop {r4, r5, fp, pc}
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
21db4: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED 21db8: ebffff98 bl 21c20 <Stack_check_report_blown_task> <== NOT EXECUTED
00021cd8 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
21cd8: e92d4810 push {r4, fp, lr}
Stack_Control *the_stack = &running->Start.Initial_stack;
void *pattern;
bool sp_ok;
bool pattern_ok = true;
pattern = Stack_check_Get_pattern_area(the_stack);
21cdc: e59030b4 ldr r3, [r0, #180] ; 0xb4
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
21ce0: e28db008 add fp, sp, #8
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
21ce4: e15b0003 cmp fp, r3
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
21ce8: e1a04000 mov r4, r0
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
21cec: e59f1044 ldr r1, [pc, #68] ; 21d38 <rtems_stack_checker_switch_extension+0x60>
Stack_Control *the_stack = &running->Start.Initial_stack;
void *pattern;
bool sp_ok;
bool pattern_ok = true;
pattern = Stack_check_Get_pattern_area(the_stack);
21cf0: e2830008 add r0, r3, #8
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
21cf4: 3a000003 bcc 21d08 <rtems_stack_checker_switch_extension+0x30>
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
21cf8: e59420b0 ldr r2, [r4, #176] ; 0xb0 21cfc: e0833002 add r3, r3, r2 21d00: e15b0003 cmp fp, r3
21d04: 9a000005 bls 21d20 <rtems_stack_checker_switch_extension+0x48>
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
21d08: e3a02010 mov r2, #16 <== NOT EXECUTED 21d0c: eb005c6f bl 38ed0 <memcmp> <== NOT EXECUTED 21d10: e2701001 rsbs r1, r0, #1 <== NOT EXECUTED 21d14: 33a01000 movcc r1, #0 <== NOT EXECUTED
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( running, pattern_ok );
21d18: e1a00004 mov r0, r4 21d1c: ebffffbf bl 21c20 <Stack_check_report_blown_task>
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
21d20: e3a02010 mov r2, #16 21d24: eb005c69 bl 38ed0 <memcmp>
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
21d28: e3500000 cmp r0, #0
21d2c: 08bd8810 popeq {r4, fp, pc}
21d30: e3a01000 mov r1, #0
21d34: eafffff7 b 21d18 <rtems_stack_checker_switch_extension+0x40>
0001c858 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
1c858: e92d40f0 push {r4, r5, r6, r7, lr}
unsigned long result;
char *end;
if ( !n )
1c85c: e2516000 subs r6, r1, #0
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
1c860: e1a04000 mov r4, r0 1c864: e24dd004 sub sp, sp, #4 1c868: e1a05002 mov r5, r2 1c86c: e1a07003 mov r7, r3
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
1c870: 03a00009 moveq r0, #9
)
{
unsigned long result;
char *end;
if ( !n )
1c874: 0a000016 beq 1c8d4 <rtems_string_to_unsigned_char+0x7c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
1c878: eb0064ff bl 35c7c <__errno> 1c87c: e3a03000 mov r3, #0 1c880: e5803000 str r3, [r0]
*n = 0;
result = strtoul( s, &end, base );
1c884: e1a02007 mov r2, r7
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
1c888: e5c63000 strb r3, [r6]
result = strtoul( s, &end, base );
1c88c: e1a00004 mov r0, r4 1c890: e1a0100d mov r1, sp 1c894: eb008653 bl 3e1e8 <strtoul>
if ( endptr )
*endptr = end;
1c898: e59d3000 ldr r3, [sp]
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
1c89c: e3550000 cmp r5, #0
*endptr = end;
1c8a0: 15853000 strne r3, [r5]
if ( end == s )
1c8a4: e1540003 cmp r4, r3
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
1c8a8: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
1c8ac: 03a0000b moveq r0, #11
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
1c8b0: 0a000007 beq 1c8d4 <rtems_string_to_unsigned_char+0x7c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1c8b4: eb0064f0 bl 35c7c <__errno> 1c8b8: e5903000 ldr r3, [r0] 1c8bc: e3530022 cmp r3, #34 ; 0x22
1c8c0: 0a00000a beq 1c8f0 <rtems_string_to_unsigned_char+0x98>
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
1c8c4: e35700ff cmp r7, #255 ; 0xff
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
1c8c8: 95c67000 strbls r7, [r6]
return RTEMS_SUCCESSFUL;
1c8cc: 93a00000 movls r0, #0
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
1c8d0: 8a000001 bhi 1c8dc <rtems_string_to_unsigned_char+0x84>
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
1c8d4: e28dd004 add sp, sp, #4
1c8d8: e8bd80f0 pop {r4, r5, r6, r7, pc}
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
errno = ERANGE;
1c8dc: eb0064e6 bl 35c7c <__errno> 1c8e0: e3a03022 mov r3, #34 ; 0x22 1c8e4: e5803000 str r3, [r0]
return RTEMS_INVALID_NUMBER;
1c8e8: e3a0000a mov r0, #10 1c8ec: eafffff8 b 1c8d4 <rtems_string_to_unsigned_char+0x7c>
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
1c8f0: e2473001 sub r3, r7, #1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1c8f4: e3730003 cmn r3, #3
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
1c8f8: 83a0000a movhi r0, #10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1c8fc: 8afffff4 bhi 1c8d4 <rtems_string_to_unsigned_char+0x7c>
1c900: eaffffef b 1c8c4 <rtems_string_to_unsigned_char+0x6c> <== NOT EXECUTED
0000cdb4 <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
cdb4: e92d40f0 push {r4, r5, r6, r7, lr}
unsigned long result;
char *end;
if ( !n )
cdb8: e2516000 subs r6, r1, #0
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
cdbc: e1a04000 mov r4, r0
cdc0: e24dd004 sub sp, sp, #4
cdc4: e1a05002 mov r5, r2
cdc8: e1a07003 mov r7, r3
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
cdcc: 03a00009 moveq r0, #9
)
{
unsigned long result;
char *end;
if ( !n )
cdd0: 0a000014 beq ce28 <rtems_string_to_unsigned_int+0x74>
return RTEMS_INVALID_ADDRESS;
errno = 0;
cdd4: eb000813 bl ee28 <__errno>
cdd8: e3a03000 mov r3, #0
cddc: e5803000 str r3, [r0]
*n = 0;
result = strtoul( s, &end, base );
cde0: e1a02007 mov r2, r7
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
cde4: e5863000 str r3, [r6]
result = strtoul( s, &end, base );
cde8: e1a00004 mov r0, r4
cdec: e1a0100d mov r1, sp
cdf0: eb0014fd bl 121ec <strtoul>
if ( endptr )
*endptr = end;
cdf4: e59d3000 ldr r3, [sp]
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
cdf8: e3550000 cmp r5, #0
*endptr = end;
cdfc: 15853000 strne r3, [r5]
if ( end == s )
ce00: e1540003 cmp r4, r3
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
ce04: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
ce08: 03a0000b moveq r0, #11
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
ce0c: 0a000005 beq ce28 <rtems_string_to_unsigned_int+0x74>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ce10: eb000804 bl ee28 <__errno>
ce14: e5903000 ldr r3, [r0]
ce18: e3530022 cmp r3, #34 ; 0x22
ce1c: 0a000003 beq ce30 <rtems_string_to_unsigned_int+0x7c>
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
ce20: e5867000 str r7, [r6]
return RTEMS_SUCCESSFUL;
ce24: e3a00000 mov r0, #0
}
ce28: e28dd004 add sp, sp, #4
ce2c: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
ce30: e2473001 sub r3, r7, #1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ce34: e3730003 cmn r3, #3
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
ce38: 83a0000a movhi r0, #10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ce3c: 8afffff9 bhi ce28 <rtems_string_to_unsigned_int+0x74>
ce40: eafffff6 b ce20 <rtems_string_to_unsigned_int+0x6c> <== NOT EXECUTED
0000b418 <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
b418: e92d40f0 push {r4, r5, r6, r7, lr}
unsigned long result;
char *end;
if ( !n )
b41c: e2516000 subs r6, r1, #0
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
b420: e1a04000 mov r4, r0
b424: e24dd004 sub sp, sp, #4
b428: e1a05002 mov r5, r2
b42c: e1a07003 mov r7, r3
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
b430: 03a00009 moveq r0, #9
)
{
unsigned long result;
char *end;
if ( !n )
b434: 0a000014 beq b48c <rtems_string_to_unsigned_long+0x74>
return RTEMS_INVALID_ADDRESS;
errno = 0;
b438: eb00aa0f bl 35c7c <__errno>
b43c: e3a03000 mov r3, #0
b440: e5803000 str r3, [r0]
*n = 0;
result = strtoul( s, &end, base );
b444: e1a02007 mov r2, r7
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
b448: e5863000 str r3, [r6]
result = strtoul( s, &end, base );
b44c: e1a00004 mov r0, r4
b450: e1a0100d mov r1, sp
b454: eb00cb63 bl 3e1e8 <strtoul>
if ( endptr )
*endptr = end;
b458: e59d3000 ldr r3, [sp]
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
b45c: e3550000 cmp r5, #0
*endptr = end;
b460: 15853000 strne r3, [r5]
if ( end == s )
b464: e1540003 cmp r4, r3
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
b468: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
b46c: 03a0000b moveq r0, #11
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
b470: 0a000005 beq b48c <rtems_string_to_unsigned_long+0x74>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
b474: eb00aa00 bl 35c7c <__errno>
b478: e5903000 ldr r3, [r0]
b47c: e3530022 cmp r3, #34 ; 0x22
b480: 0a000003 beq b494 <rtems_string_to_unsigned_long+0x7c>
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
b484: e5867000 str r7, [r6]
return RTEMS_SUCCESSFUL;
b488: e3a00000 mov r0, #0
}
b48c: e28dd004 add sp, sp, #4
b490: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
b494: e2473001 sub r3, r7, #1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
b498: e3730003 cmn r3, #3
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
b49c: 83a0000a movhi r0, #10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
b4a0: 8afffff9 bhi b48c <rtems_string_to_unsigned_long+0x74>
b4a4: eafffff6 b b484 <rtems_string_to_unsigned_long+0x6c> <== NOT EXECUTED
0000ce44 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
ce44: e92d43f0 push {r4, r5, r6, r7, r8, r9, lr}
unsigned long long result;
char *end;
if ( !n )
ce48: e2516000 subs r6, r1, #0
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
ce4c: e1a04000 mov r4, r0
ce50: e24dd004 sub sp, sp, #4
ce54: e1a05002 mov r5, r2
ce58: e1a07003 mov r7, r3
unsigned long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ce5c: 03a00009 moveq r0, #9
)
{
unsigned long long result;
char *end;
if ( !n )
ce60: 0a000017 beq cec4 <rtems_string_to_unsigned_long_long+0x80>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ce64: eb0007ef bl ee28 <__errno>
ce68: e3a03000 mov r3, #0
ce6c: e5803000 str r3, [r0]
*n = 0;
ce70: e3a02000 mov r2, #0
ce74: e3a03000 mov r3, #0
ce78: e886000c stm r6, {r2, r3}
result = strtoull( s, &end, base );
ce7c: e1a00004 mov r0, r4
ce80: e1a0100d mov r1, sp
ce84: e1a02007 mov r2, r7
ce88: eb0014e2 bl 12218 <strtoull>
if ( endptr )
*endptr = end;
ce8c: e59d3000 ldr r3, [sp]
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
if ( endptr )
ce90: e3550000 cmp r5, #0
*endptr = end;
ce94: 15853000 strne r3, [r5]
if ( end == s )
ce98: e1540003 cmp r4, r3
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
ce9c: e1a08000 mov r8, r0
cea0: e1a09001 mov r9, r1
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
cea4: 03a0000b moveq r0, #11
result = strtoull( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
cea8: 0a000005 beq cec4 <rtems_string_to_unsigned_long_long+0x80>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ceac: eb0007dd bl ee28 <__errno>
ceb0: e5903000 ldr r3, [r0]
ceb4: e3530022 cmp r3, #34 ; 0x22
ceb8: 0a000003 beq cecc <rtems_string_to_unsigned_long_long+0x88>
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
cebc: e8860300 stm r6, {r8, r9}
return RTEMS_SUCCESSFUL;
cec0: e3a00000 mov r0, #0
}
cec4: e28dd004 add sp, sp, #4
cec8: e8bd83f0 pop {r4, r5, r6, r7, r8, r9, pc}
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
cecc: e3e02000 mvn r2, #0
ced0: e0922008 adds r2, r2, r8
ced4: e3e03000 mvn r3, #0
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ced8: e3e00002 mvn r0, #2
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
cedc: e0a33009 adc r3, r3, r9
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
cee0: e3e01000 mvn r1, #0
cee4: e1510003 cmp r1, r3
cee8: 01500002 cmpeq r0, r2
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
ceec: 33a0000a movcc r0, #10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
cef0: 3afffff3 bcc cec4 <rtems_string_to_unsigned_long_long+0x80>
cef4: eafffff0 b cebc <rtems_string_to_unsigned_long_long+0x78> <== NOT EXECUTED
00001e54 <rtems_tarfs_load>:
int rtems_tarfs_load(
const char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
1e54: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1e58: e24dde1d sub sp, sp, #464 ; 0x1d0
1e5c: e58d0014 str r0, [sp, #20]
1e60: e58d2018 str r2, [sp, #24]
1e64: e1a06001 mov r6, r1
IMFS_jnode_t *node; int rv = 0; int eval_flags = RTEMS_FS_FOLLOW_LINK; rtems_filesystem_eval_path_context_t ctx; rtems_filesystem_location_info_t rootloc; rtems_filesystem_location_info_t *currentloc =
1e68: e3a02018 mov r2, #24
1e6c: e1a01000 mov r1, r0
1e70: e28d0d06 add r0, sp, #384 ; 0x180
1e74: eb00080e bl 3eb4 <rtems_filesystem_eval_path_start>
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(
1e78: e28d1f66 add r1, sp, #408 ; 0x198
1e7c: e1a08000 mov r8, r0
1e80: e28d0f6e add r0, sp, #440 ; 0x1b8
1e84: eb0008ce bl 41c4 <rtems_filesystem_location_copy_and_detach>
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
rootloc.mt_entry->ops != &IMFS_ops
1e88: e59d31cc ldr r3, [sp, #460] ; 0x1cc
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
1e8c: e59f2228 ldr r2, [pc, #552] ; 20bc <rtems_tarfs_load+0x268>
rootloc.mt_entry->ops != &IMFS_ops
1e90: e593300c ldr r3, [r3, #12]
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
1e94: e1530002 cmp r3, r2
static inline void rtems_filesystem_eval_path_set_flags(
rtems_filesystem_eval_path_context_t *ctx,
int flags
)
{
ctx->flags = flags;
1e98: e3a02060 mov r2, #96 ; 0x60
1e9c: e58d2190 str r2, [sp, #400] ; 0x190
1ea0: 0a000003 beq 1eb4 <rtems_tarfs_load+0x60>
rootloc.mt_entry->ops != &IMFS_ops
&& rootloc.mt_entry->ops != &fifoIMFS_ops
1ea4: e59f2214 ldr r2, [pc, #532] ; 20c0 <rtems_tarfs_load+0x26c>
1ea8: e1530002 cmp r3, r2
) {
rv = -1;
1eac: 13e04000 mvnne r4, #0
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
rootloc.mt_entry->ops != &IMFS_ops
&& rootloc.mt_entry->ops != &fifoIMFS_ops
1eb0: 1a00003d bne 1fac <rtems_tarfs_load+0x158>
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
1eb4: e59d2018 ldr r2, [sp, #24]
1eb8: e3520c02 cmp r2, #512 ; 0x200
1ebc: 3a000039 bcc 1fa8 <rtems_tarfs_load+0x154>
1ec0: e3a0a000 mov sl, #0
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
1ec4: e086a00a add sl, r6, sl
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
1ec8: e28a0c01 add r0, sl, #256 ; 0x100
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
1ecc: e3a03c02 mov r3, #512 ; 0x200
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
1ed0: e2800001 add r0, r0, #1
1ed4: e59f11e8 ldr r1, [pc, #488] ; 20c4 <rtems_tarfs_load+0x270>
1ed8: e3a02005 mov r2, #5
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
1edc: e58d300c str r3, [sp, #12]
1ee0: e58d3010 str r3, [sp, #16]
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
1ee4: eb003ebb bl 119d8 <strncmp>
1ee8: e2504000 subs r4, r0, #0
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
1eec: e28d5f47 add r5, sp, #284 ; 0x11c
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
1ef0: 1a00002c bne 1fa8 <rtems_tarfs_load+0x154>
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
1ef4: e3a02063 mov r2, #99 ; 0x63
1ef8: e1a0100a mov r1, sl
1efc: e1a00005 mov r0, r5
1f00: eb003f04 bl 11b18 <strncpy>
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
1f04: e3a01008 mov r1, #8
1f08: e28a0064 add r0, sl, #100 ; 0x64
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
1f0c: e5cd417f strb r4, [sp, #383] ; 0x17f
linkflag = hdr_ptr[156];
1f10: e5da909c ldrb r9, [sl, #156] ; 0x9c
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
1f14: eb00215f bl a498 <_rtems_octal2ulong>
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
1f18: e3a0100c mov r1, #12
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
1f1c: e1a0b000 mov fp, r0
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
1f20: e28a007c add r0, sl, #124 ; 0x7c
1f24: eb00215b bl a498 <_rtems_octal2ulong>
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
1f28: e3a01008 mov r1, #8
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
1f2c: e1a07000 mov r7, r0
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
1f30: e28a0094 add r0, sl, #148 ; 0x94
1f34: eb002157 bl a498 <_rtems_octal2ulong>
1f38: e1a03000 mov r3, r0
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
1f3c: e1a0000a mov r0, sl
1f40: e58d3008 str r3, [sp, #8]
1f44: eb002270 bl a90c <_rtems_tar_header_checksum>
1f48: e59d3008 ldr r3, [sp, #8]
1f4c: e1500003 cmp r0, r3
1f50: 1a000015 bne 1fac <rtems_tarfs_load+0x158>
* Generate an IMFS node depending on the file type.
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
1f54: e3590035 cmp r9, #53 ; 0x35
1f58: 0a00001a beq 1fc8 <rtems_tarfs_load+0x174>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
}
/*
* Create a LINEAR_FILE node
*/
else if (linkflag == REGTYPE) {
1f5c: e3590030 cmp r9, #48 ; 0x30
1f60: 0a00002e beq 2020 <rtems_tarfs_load+0x1cc>
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
1f64: e59d2010 ldr r2, [sp, #16]
1f68: e59d3018 ldr r3, [sp, #24]
1f6c: e2822c02 add r2, r2, #512 ; 0x200
1f70: e1520003 cmp r2, r3
1f74: e58d200c str r2, [sp, #12]
1f78: 8a00000a bhi 1fa8 <rtems_tarfs_load+0x154>
1f7c: e28d200c add r2, sp, #12
1f80: e8920404 ldm r2, {r2, sl}
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
1f84: e086a00a add sl, r6, sl
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
1f88: e28a0c01 add r0, sl, #256 ; 0x100
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
1f8c: e58d2010 str r2, [sp, #16]
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
1f90: e2800001 add r0, r0, #1
1f94: e59f1128 ldr r1, [pc, #296] ; 20c4 <rtems_tarfs_load+0x270>
1f98: e3a02005 mov r2, #5
1f9c: eb003e8d bl 119d8 <strncmp>
1fa0: e2504000 subs r4, r0, #0
1fa4: 0affffd2 beq 1ef4 <rtems_tarfs_load+0xa0>
1fa8: e3a04000 mov r4, #0
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
rtems_filesystem_location_free( &rootloc );
1fac: e28d0f6e add r0, sp, #440 ; 0x1b8
1fb0: eb000242 bl 28c0 <rtems_filesystem_location_free>
rtems_filesystem_eval_path_cleanup( &ctx );
1fb4: e28d0d06 add r0, sp, #384 ; 0x180
1fb8: eb0007c7 bl 3edc <rtems_filesystem_eval_path_cleanup>
return rv;
}
1fbc: e1a00004 mov r0, r4
1fc0: e28dde1d add sp, sp, #464 ; 0x1d0
1fc4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
1fc8: e59d1014 ldr r1, [sp, #20]
1fcc: e28d001c add r0, sp, #28
1fd0: eb003c94 bl 11228 <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
1fd4: e28d001c add r0, sp, #28
1fd8: eb003e66 bl 11978 <strlen>
1fdc: e28d2e1d add r2, sp, #464 ; 0x1d0
1fe0: e0823000 add r3, r2, r0
1fe4: e55331b5 ldrb r3, [r3, #-437] ; 0x1b5
1fe8: e353002f cmp r3, #47 ; 0x2f
1fec: 0a000004 beq 2004 <rtems_tarfs_load+0x1b0>
strcat(full_filename, "/");
1ff0: e28d301c add r3, sp, #28 <== NOT EXECUTED
1ff4: e0830000 add r0, r3, r0 <== NOT EXECUTED
1ff8: e59f10c8 ldr r1, [pc, #200] ; 20c8 <rtems_tarfs_load+0x274><== NOT EXECUTED
1ffc: e3a02002 mov r2, #2 <== NOT EXECUTED
2000: eb00396b bl 105b4 <memcpy> <== NOT EXECUTED
strcat(full_filename, filename);
2004: e1a01005 mov r1, r5
2008: e28d001c add r0, sp, #28
200c: eb003bd3 bl 10f60 <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
2010: e28d001c add r0, sp, #28
2014: e59f10b0 ldr r1, [pc, #176] ; 20cc <rtems_tarfs_load+0x278>
2018: eb0003ae bl 2ed8 <mkdir>
201c: eaffffd0 b 1f64 <rtems_tarfs_load+0x110>
}
/*
* Create a LINEAR_FILE node
*/
else if (linkflag == REGTYPE) {
rtems_filesystem_location_free( currentloc );
2020: e1a00008 mov r0, r8
2024: eb000225 bl 28c0 <rtems_filesystem_location_free>
rtems_filesystem_location_clone( currentloc, &rootloc );
2028: e28d1f6e add r1, sp, #440 ; 0x1b8
202c: e1a00008 mov r0, r8
2030: eb000169 bl 25dc <rtems_filesystem_location_clone>
rtems_filesystem_eval_path_set_path(
2034: e1a00005 mov r0, r5
2038: eb003e4e bl 11978 <strlen>
const char *path,
size_t pathlen
)
{
ctx->path = path;
ctx->pathlen = pathlen;
203c: e58d0184 str r0, [sp, #388] ; 0x184
&ctx,
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
2040: e28d0d06 add r0, sp, #384 ; 0x180
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
ctx->path = path;
2044: e58d5180 str r5, [sp, #384] ; 0x180
2048: eb000716 bl 3ca8 <rtems_filesystem_eval_path_continue>
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
204c: e5983010 ldr r3, [r8, #16]
2050: e59f2078 ldr r2, [pc, #120] ; 20d0 <rtems_tarfs_load+0x27c>
2054: e1530002 cmp r3, r2
2058: 0a000010 beq 20a0 <rtems_tarfs_load+0x24c>
size_t namelen,
mode_t mode,
const IMFS_types_union *info
)
{
const IMFS_fs_info_t *fs_info =
205c: e5983014 ldr r3, [r8, #20]
node = IMFS_create_node(
currentloc,
IMFS_LINEAR_FILE,
rtems_filesystem_eval_path_get_token( &ctx ),
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
2060: e1a0cb8b lsl ip, fp, #23
(const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;
return IMFS_create_node_with_control(
2064: e5933008 ldr r3, [r3, #8]
2068: e1a0cbac lsr ip, ip, #23
206c: e28d2f62 add r2, sp, #392 ; 0x188
2070: e593101c ldr r1, [r3, #28]
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
node = IMFS_create_node(
2074: e38cc902 orr ip, ip, #32768 ; 0x8000
2078: e892000c ldm r2, {r2, r3}
207c: e1a00008 mov r0, r8
2080: e58dc000 str ip, [sp]
2084: e58d4004 str r4, [sp, #4]
2088: eb0022bb bl ab7c <IMFS_create_node_with_control>
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
208c: e59d200c ldr r2, [sp, #12]
2090: e0863002 add r3, r6, r2
rtems_filesystem_eval_path_get_token( &ctx ),
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
2094: e5807050 str r7, [r0, #80] ; 0x50
2098: e5804054 str r4, [r0, #84] ; 0x54
node->info.linearfile.direct = &tar_image[offset];
209c: e5803058 str r3, [r0, #88] ; 0x58
}
nblocks = (((file_size) + 511) & ~511) / 512;
20a0: e2877f7f add r7, r7, #508 ; 0x1fc
20a4: e2877003 add r7, r7, #3
offset += 512 * nblocks;
20a8: e59d300c ldr r3, [sp, #12]
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
}
nblocks = (((file_size) + 511) & ~511) / 512;
20ac: e1a074a7 lsr r7, r7, #9
offset += 512 * nblocks;
20b0: e0837487 add r7, r3, r7, lsl #9
20b4: e58d7010 str r7, [sp, #16]
20b8: eaffffa9 b 1f64 <rtems_tarfs_load+0x110>
0000f9c4 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
f9c4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
f9c8: e2525000 subs r5, r2, #0
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
f9cc: e1a04000 mov r4, r0
f9d0: e1a06001 mov r6, r1
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
f9d4: 03a00009 moveq r0, #9
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
f9d8: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
f9dc: e59f9148 ldr r9, [pc, #328] ; fb2c <rtems_task_mode+0x168>
f9e0: e5997008 ldr r7, [r9, #8]
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
f9e4: e5d7a070 ldrb sl, [r7, #112] ; 0x70
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
f9e8: e59780ec ldr r8, [r7, #236] ; 0xec
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
f9ec: e5973078 ldr r3, [r7, #120] ; 0x78
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
f9f0: e35a0000 cmp sl, #0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
f9f4: e5d8b008 ldrb fp, [r8, #8]
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
f9f8: 03a0ac01 moveq sl, #256 ; 0x100
f9fc: 13a0a000 movne sl, #0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
fa00: e3530000 cmp r3, #0
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
fa04: 138aac02 orrne sl, sl, #512 ; 0x200
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
fa08: e35b0000 cmp fp, #0
fa0c: 03a0bb01 moveq fp, #1024 ; 0x400
fa10: 13a0b000 movne fp, #0
old_mode |= _ISR_Get_level();
fa14: ebffeed4 bl b56c <_CPU_ISR_Get_level>
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
fa18: e18bb000 orr fp, fp, r0
old_mode |= _ISR_Get_level();
fa1c: e18ba00a orr sl, fp, sl
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
fa20: e3160c01 tst r6, #256 ; 0x100
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
old_mode |= _ISR_Get_level();
*previous_mode_set = old_mode;
fa24: e585a000 str sl, [r5]
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
fa28: 0a000003 beq fa3c <rtems_task_mode+0x78>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
fa2c: e3140c01 tst r4, #256 ; 0x100
fa30: 13a03000 movne r3, #0
fa34: 03a03001 moveq r3, #1
fa38: e5c73070 strb r3, [r7, #112] ; 0x70
if ( mask & RTEMS_TIMESLICE_MASK ) {
fa3c: e3160c02 tst r6, #512 ; 0x200
fa40: 1a000028 bne fae8 <rtems_task_mode+0x124>
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
fa44: e3160080 tst r6, #128 ; 0x80
fa48: 1a00002f bne fb0c <rtems_task_mode+0x148>
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
fa4c: e2166b01 ands r6, r6, #1024 ; 0x400
fa50: 0a000012 beq faa0 <rtems_task_mode+0xdc>
#include <rtems/score/tod.h>
#include <rtems/score/wkspace.h>
#include <rtems/score/apiext.h>
#include <rtems/score/sysstate.h>
rtems_status_code rtems_task_mode(
fa54: e3140b01 tst r4, #1024 ; 0x400
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
fa58: e5d82008 ldrb r2, [r8, #8]
#include <rtems/score/tod.h>
#include <rtems/score/wkspace.h>
#include <rtems/score/apiext.h>
#include <rtems/score/sysstate.h>
rtems_status_code rtems_task_mode(
fa5c: 13a03000 movne r3, #0
fa60: 03a03001 moveq r3, #1
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
fa64: e1520003 cmp r2, r3
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
fa68: 03a06000 moveq r6, #0
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
fa6c: 0a00000b beq faa0 <rtems_task_mode+0xdc>
asr->is_enabled = is_asr_enabled;
fa70: e5c83008 strb r3, [r8, #8]
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
fa74: e10f3000 mrs r3, CPSR
fa78: e3832080 orr r2, r3, #128 ; 0x80
fa7c: e129f002 msr CPSR_fc, r2
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
fa80: e5981018 ldr r1, [r8, #24]
information->signals_pending = information->signals_posted;
fa84: e5982014 ldr r2, [r8, #20]
information->signals_posted = _signals;
fa88: e5881014 str r1, [r8, #20]
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
fa8c: e5882018 str r2, [r8, #24]
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
fa90: e129f003 msr CPSR_fc, r3
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
fa94: e5986014 ldr r6, [r8, #20]
fa98: e3560000 cmp r6, #0
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
fa9c: 13a06001 movne r6, #1
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
faa0: e59f3088 ldr r3, [pc, #136] ; fb30 <rtems_task_mode+0x16c>
faa4: e5933000 ldr r3, [r3]
faa8: e3530003 cmp r3, #3
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
faac: 13a00000 movne r0, #0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
fab0: 18bd8ff0 popne {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
Thread_Control *executing;
executing = _Thread_Executing;
if ( are_signals_pending ||
fab4: e3560000 cmp r6, #0
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
fab8: e5993008 ldr r3, [r9, #8]
if ( are_signals_pending ||
fabc: 1a000015 bne fb18 <rtems_task_mode+0x154>
fac0: e59f2064 ldr r2, [pc, #100] ; fb2c <rtems_task_mode+0x168>
fac4: e592200c ldr r2, [r2, #12]
fac8: e1530002 cmp r3, r2
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
facc: 01a00006 moveq r0, r6
fad0: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
fad4: e5d33070 ldrb r3, [r3, #112] ; 0x70
fad8: e3530000 cmp r3, #0
fadc: 1a00000d bne fb18 <rtems_task_mode+0x154>
fae0: e1a00006 mov r0, r6 <== NOT EXECUTED
}
fae4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
*/
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
fae8: e2143c02 ands r3, r4, #512 ; 0x200
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
faec: 159f3040 ldrne r3, [pc, #64] ; fb34 <rtems_task_mode+0x170>
faf0: 15933000 ldrne r3, [r3]
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
faf4: 13a02001 movne r2, #1
faf8: 15872078 strne r2, [r7, #120] ; 0x78
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
fafc: 15873074 strne r3, [r7, #116] ; 0x74
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
fb00: 05873078 streq r3, [r7, #120] ; 0x78
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
fb04: e3160080 tst r6, #128 ; 0x80
fb08: 0affffcf beq fa4c <rtems_task_mode+0x88>
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
fb0c: e2040080 and r0, r4, #128 ; 0x80
fb10: ebffee90 bl b558 <_CPU_ISR_Set_level>
fb14: eaffffcc b fa4c <rtems_task_mode+0x88>
_Thread_Dispatch_necessary = true;
fb18: e3a03001 mov r3, #1
fb1c: e5c93004 strb r3, [r9, #4]
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
fb20: eb000287 bl 10544 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
fb24: e3a00000 mov r0, #0
fb28: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
0000457c <rtems_termios_close>:
rtems_interrupt_enable (level);
}
rtems_status_code
rtems_termios_close (void *arg)
{
457c: e92d4070 push {r4, r5, r6, lr}
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain(
4580: e59f51b0 ldr r5, [pc, #432] ; 4738 <rtems_termios_close+0x1bc>
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
4584: e5903000 ldr r3, [r0]
rtems_status_code sc;
sc = rtems_semaphore_obtain(
4588: e3a01000 mov r1, #0
rtems_interrupt_enable (level);
}
rtems_status_code
rtems_termios_close (void *arg)
{
458c: e1a06000 mov r6, r0
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain(
4590: e1a02001 mov r2, r1
4594: e5950000 ldr r0, [r5]
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
4598: e593402c ldr r4, [r3, #44] ; 0x2c
rtems_status_code sc;
sc = rtems_semaphore_obtain(
459c: eb000814 bl 65f4 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
45a0: e3500000 cmp r0, #0
45a4: 1a00005f bne 4728 <rtems_termios_close+0x1ac>
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
45a8: e5943008 ldr r3, [r4, #8]
45ac: e2433001 sub r3, r3, #1
45b0: e3530000 cmp r3, #0
45b4: e5843008 str r3, [r4, #8]
45b8: 1a00002f bne 467c <rtems_termios_close+0x100>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
45bc: e59420cc ldr r2, [r4, #204] ; 0xcc
45c0: e59f3174 ldr r3, [pc, #372] ; 473c <rtems_termios_close+0x1c0>
45c4: e0833282 add r3, r3, r2, lsl #5
45c8: e5931004 ldr r1, [r3, #4]
45cc: e3510000 cmp r1, #0
45d0: 0a00003d beq 46cc <rtems_termios_close+0x150>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
45d4: e1a00004 mov r0, r4
45d8: e1a0e00f mov lr, pc
45dc: e12fff11 bx r1
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
45e0: e59430b4 ldr r3, [r4, #180] ; 0xb4
45e4: e3530002 cmp r3, #2
45e8: 0a000044 beq 4700 <rtems_termios_close+0x184>
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
45ec: e594309c ldr r3, [r4, #156] ; 0x9c
45f0: e3530000 cmp r3, #0
(*tty->device.lastClose)(tty->major, tty->minor, arg);
45f4: 1284000c addne r0, r4, #12
45f8: 18900003 ldmne r0, {r0, r1}
45fc: 11a02006 movne r2, r6
4600: 11a0e00f movne lr, pc
4604: 112fff13 bxne r3
if (tty->forw == NULL) {
4608: e5943000 ldr r3, [r4]
460c: e3530000 cmp r3, #0
rtems_termios_ttyTail = tty->back;
4610: e5942004 ldr r2, [r4, #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) {
4614: 0a000025 beq 46b0 <rtems_termios_close+0x134>
rtems_termios_ttyTail = tty->back;
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
}
} else {
tty->forw->back = tty->back;
4618: e5832004 str r2, [r3, #4]
461c: e5942004 ldr r2, [r4, #4]
}
if (tty->back == NULL) {
4620: e3520000 cmp r2, #0
4624: 0a00001b beq 4698 <rtems_termios_close+0x11c>
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
} else {
tty->back->forw = tty->forw;
4628: e5823000 str r3, [r2] <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
462c: e5940014 ldr r0, [r4, #20]
4630: eb0007c6 bl 6550 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
4634: e5940018 ldr r0, [r4, #24]
4638: eb0007c4 bl 6550 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
463c: e594008c ldr r0, [r4, #140] ; 0x8c
4640: eb0007c2 bl 6550 <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
4644: e59430a0 ldr r3, [r4, #160] ; 0xa0
4648: e3530000 cmp r3, #0
464c: 0a00000e beq 468c <rtems_termios_close+0x110>
4650: e59430b4 ldr r3, [r4, #180] ; 0xb4
4654: e3530002 cmp r3, #2
4658: 0a00000b beq 468c <rtems_termios_close+0x110>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
free (tty->rawInBuf.theBuf);
465c: e5940058 ldr r0, [r4, #88] ; 0x58
4660: ebfff7ab bl 2514 <free>
free (tty->rawOutBuf.theBuf);
4664: e594007c ldr r0, [r4, #124] ; 0x7c
4668: ebfff7a9 bl 2514 <free>
free (tty->cbuf);
466c: e594001c ldr r0, [r4, #28]
4670: ebfff7a7 bl 2514 <free>
free (tty);
4674: e1a00004 mov r0, r4
4678: ebfff7a5 bl 2514 <free>
} rtems_semaphore_release (rtems_termios_ttyMutex);
467c: e5950000 ldr r0, [r5]
4680: eb000824 bl 6718 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL; }
4684: e3a00000 mov r0, #0
4688: e8bd8070 pop {r4, r5, r6, pc}
rtems_semaphore_delete (tty->isem);
rtems_semaphore_delete (tty->osem);
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
468c: e5940068 ldr r0, [r4, #104] ; 0x68
4690: eb0007ae bl 6550 <rtems_semaphore_delete>
4694: eafffff0 b 465c <rtems_termios_close+0xe0>
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
4698: e59f20a0 ldr r2, [pc, #160] ; 4740 <rtems_termios_close+0x1c4>
if ( rtems_termios_ttyHead != NULL ) {
469c: e3530000 cmp r3, #0
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
46a0: e5823000 str r3, [r2]
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
46a4: 13a02000 movne r2, #0
46a8: 15832004 strne r2, [r3, #4]
46ac: eaffffde b 462c <rtems_termios_close+0xb0>
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;
46b0: e59f108c ldr r1, [pc, #140] ; 4744 <rtems_termios_close+0x1c8>
if ( rtems_termios_ttyTail != NULL ) {
46b4: e3520000 cmp r2, #0
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
46b8: e5812000 str r2, [r1]
if ( rtems_termios_ttyTail != NULL ) {
46bc: 0afffff5 beq 4698 <rtems_termios_close+0x11c>
rtems_termios_ttyTail->forw = NULL;
46c0: e5823000 str r3, [r2] <== NOT EXECUTED
46c4: e5943000 ldr r3, [r4] <== NOT EXECUTED
46c8: eaffffd6 b 4628 <rtems_termios_close+0xac> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
46cc: e5940018 ldr r0, [r4, #24]
46d0: e1a02001 mov r2, r1
46d4: eb0007c6 bl 65f4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
46d8: e3500000 cmp r0, #0
46dc: 1a000011 bne 4728 <rtems_termios_close+0x1ac>
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
46e0: e59430b4 ldr r3, [r4, #180] ; 0xb4
46e4: e3530000 cmp r3, #0
46e8: 1a00000f bne 472c <rtems_termios_close+0x1b0>
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);
46ec: e5940018 ldr r0, [r4, #24]
46f0: eb000808 bl 6718 <rtems_semaphore_release>
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
46f4: e59430b4 ldr r3, [r4, #180] ; 0xb4
46f8: e3530002 cmp r3, #2
46fc: 1affffba bne 45ec <rtems_termios_close+0x70>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
4700: e59400c4 ldr r0, [r4, #196] ; 0xc4
4704: e3a01001 mov r1, #1
4708: eb00069f bl 618c <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
470c: e3500000 cmp r0, #0
4710: 1a000004 bne 4728 <rtems_termios_close+0x1ac>
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
4714: e59400c8 ldr r0, [r4, #200] ; 0xc8
4718: e3a01001 mov r1, #1
471c: eb00069a bl 618c <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
4720: e3500000 cmp r0, #0
4724: 0affffb0 beq 45ec <rtems_termios_close+0x70>
rtems_fatal_error_occurred (sc);
4728: eb00098b bl 6d5c <rtems_fatal_error_occurred> <== NOT EXECUTED
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
472c: e1a00004 mov r0, r4
4730: ebfffe5d bl 40ac <drainOutput.part.0>
4734: eaffffec b 46ec <rtems_termios_close+0x170>
00005b10 <rtems_termios_dequeue_characters>:
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
5b10: e590c090 ldr ip, [r0, #144] ; 0x90
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
5b14: e59020b4 ldr r2, [r0, #180] ; 0xb4
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
5b18: e08c1001 add r1, ip, r1
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
5b1c: e3520002 cmp r2, #2
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
5b20: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
5b24: e5801090 str r1, [r0, #144] ; 0x90
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
5b28: 0a00000c beq 5b60 <rtems_termios_dequeue_characters+0x50>
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
5b2c: e59030cc ldr r3, [r0, #204] ; 0xcc
5b30: e3530005 cmp r3, #5
5b34: 0a000001 beq 5b40 <rtems_termios_dequeue_characters+0x30>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
}
5b38: 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);
5b3c: eafff8c2 b 3e4c <rtems_termios_refill_transmitter>
if (tty->t_line == PPPDISC ) {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
5b40: e59f303c ldr r3, [pc, #60] ; 5b84 <rtems_termios_dequeue_characters+0x74>
5b44: e59330b4 ldr r3, [r3, #180] ; 0xb4
5b48: e3530000 cmp r3, #0
5b4c: 0a00000a beq 5b7c <rtems_termios_dequeue_characters+0x6c>
rtems_termios_linesw[tty->t_line].l_start(tty);
5b50: e1a0e00f mov lr, pc
5b54: e12fff13 bx r3
}
return 0; /* nothing to output in IRQ... */
5b58: e3a00000 mov r0, #0
5b5c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
5b60: e59000c8 ldr r0, [r0, #200] ; 0xc8
5b64: e1a01002 mov r1, r2
5b68: eb000187 bl 618c <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
5b6c: e2503000 subs r3, r0, #0
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
5b70: 01a00003 moveq r0, r3
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
if (sc != RTEMS_SUCCESSFUL)
5b74: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_fatal_error_occurred (sc);
5b78: eb000477 bl 6d5c <rtems_fatal_error_occurred> <== NOT EXECUTED
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
5b7c: e1a00003 mov r0, r3 <== NOT EXECUTED
}
return rtems_termios_refill_transmitter(tty);
}
5b80: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
000057a8 <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)
{
57a8: e92d4ff0 push {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) {
57ac: e59030cc ldr r3, [r0, #204] ; 0xcc
57b0: e59f72c8 ldr r7, [pc, #712] ; 5a80 <rtems_termios_enqueue_raw_characters+0x2d8>
57b4: e0873283 add r3, r7, r3, lsl #5
57b8: e5939010 ldr r9, [r3, #16]
57bc: e3590000 cmp r9, #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)
{
57c0: e24dd008 sub sp, sp, #8
57c4: e1a04000 mov r4, r0
57c8: e1a05001 mov r5, r1
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) {
57cc: 0a00001d beq 5848 <rtems_termios_enqueue_raw_characters+0xa0>
while (len--) {
57d0: e3520000 cmp r2, #0
57d4: 0a00000a beq 5804 <rtems_termios_enqueue_raw_characters+0x5c>
57d8: e1a06002 mov r6, r2
57dc: ea000002 b 57ec <rtems_termios_enqueue_raw_characters+0x44>
57e0: e59430cc ldr r3, [r4, #204] ; 0xcc
57e4: e0873283 add r3, r7, r3, lsl #5
57e8: e5939010 ldr r9, [r3, #16]
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
57ec: e4d50001 ldrb r0, [r5], #1
57f0: e1a01004 mov r1, r4
57f4: e1a0e00f mov lr, pc
57f8: e12fff19 bx r9
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--) {
57fc: e2566001 subs r6, r6, #1
5800: 1afffff6 bne 57e0 <rtems_termios_enqueue_raw_characters+0x38>
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
5804: e594a0e4 ldr sl, [r4, #228] ; 0xe4
5808: e35a0000 cmp sl, #0
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
580c: 13a0a000 movne sl, #0
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
5810: 1a000009 bne 583c <rtems_termios_enqueue_raw_characters+0x94>
5814: e59430dc ldr r3, [r4, #220] ; 0xdc
5818: e3530000 cmp r3, #0
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
581c: 01a0a003 moveq sl, r3
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
5820: 0a000005 beq 583c <rtems_termios_enqueue_raw_characters+0x94>
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
5824: e2840030 add r0, r4, #48 ; 0x30
5828: e59410e0 ldr r1, [r4, #224] ; 0xe0
582c: e1a0e00f mov lr, pc
5830: e12fff13 bx r3
tty->tty_rcvwakeup = 1;
5834: e3a03001 mov r3, #1
5838: e58430e4 str r3, [r4, #228] ; 0xe4
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
}
583c: e1a0000a mov r0, sl
5840: e28dd008 add sp, sp, #8
5844: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* 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);
5848: e2803030 add r3, r0, #48 ; 0x30
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) {
584c: e1a06002 mov r6, r2
/*
* 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);
5850: e58d3000 str r3, [sp]
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
5854: e3560000 cmp r6, #0
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,
5858: e280304a add r3, r0, #74 ; 0x4a
585c: e58d3004 str r3, [sp, #4]
5860: e1a0b009 mov fp, r9
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
5864: 0a000042 beq 5974 <rtems_termios_enqueue_raw_characters+0x1cc>
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
5868: e59430b8 ldr r3, [r4, #184] ; 0xb8
586c: e3130c02 tst r3, #512 ; 0x200
}
return 0;
}
while (len--) {
c = *buf++;
5870: e4d58001 ldrb r8, [r5], #1
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
5874: 0a000005 beq 5890 <rtems_termios_enqueue_raw_characters+0xe8>
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
5878: e5d4304a ldrb r3, [r4, #74] ; 0x4a
587c: e1530008 cmp r3, r8
5880: 0a000056 beq 59e0 <rtems_termios_enqueue_raw_characters+0x238>
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
5884: e5d43049 ldrb r3, [r4, #73] ; 0x49
5888: e1530008 cmp r3, r8
588c: 0a00003f beq 5990 <rtems_termios_enqueue_raw_characters+0x1e8>
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
5890: e3590000 cmp r9, #0
5894: 1a000041 bne 59a0 <rtems_termios_enqueue_raw_characters+0x1f8>
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
5898: e5940060 ldr r0, [r4, #96] ; 0x60
589c: e5941064 ldr r1, [r4, #100] ; 0x64
58a0: e2800001 add r0, r0, #1
58a4: eb004406 bl 168c4 <__umodsi3>
58a8: e1a07000 mov r7, r0
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
58ac: e10fa000 mrs sl, CPSR
58b0: e38a3080 orr r3, sl, #128 ; 0x80
58b4: e129f003 msr CPSR_fc, r3
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
58b8: e594305c ldr r3, [r4, #92] ; 0x5c
58bc: e5940064 ldr r0, [r4, #100] ; 0x64
58c0: e0630000 rsb r0, r3, r0
% tty->rawInBuf.Size) > tty->highwater) &&
58c4: e5941064 ldr r1, [r4, #100] ; 0x64
58c8: e0800007 add r0, r0, r7
58cc: eb0043fc bl 168c4 <__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)
58d0: e59430c0 ldr r3, [r4, #192] ; 0xc0
58d4: e1500003 cmp r0, r3
58d8: 9a00000e bls 5918 <rtems_termios_enqueue_raw_characters+0x170>
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
58dc: 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) &&
58e0: e3130001 tst r3, #1 <== NOT EXECUTED
58e4: 1a00000b bne 5918 <rtems_termios_enqueue_raw_characters+0x170><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
58e8: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
58ec: e3833001 orr r3, r3, #1 <== NOT EXECUTED
58f0: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
58f4: e59f3188 ldr r3, [pc, #392] ; 5a84 <rtems_termios_enqueue_raw_characters+0x2dc><== NOT EXECUTED
58f8: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
58fc: e0023003 and r3, r2, r3 <== NOT EXECUTED
5900: e3530b01 cmp r3, #1024 ; 0x400 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
5904: 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))
5908: 0a000044 beq 5a20 <rtems_termios_enqueue_raw_characters+0x278><== NOT EXECUTED
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
590c: e2033f41 and r3, r3, #260 ; 0x104 <== NOT EXECUTED
5910: e3530c01 cmp r3, #256 ; 0x100 <== NOT EXECUTED
5914: 0a00004f beq 5a58 <rtems_termios_enqueue_raw_characters+0x2b0><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
5918: e129f00a msr CPSR_fc, sl
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
591c: e594305c ldr r3, [r4, #92] ; 0x5c
5920: e1530007 cmp r3, r7
dropped++;
5924: 028bb001 addeq fp, fp, #1
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
5928: 0a00000e beq 5968 <rtems_termios_enqueue_raw_characters+0x1c0>
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
592c: e5943058 ldr r3, [r4, #88] ; 0x58
5930: e7c38007 strb r8, [r3, r7]
tty->rawInBuf.Tail = newTail;
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
5934: e59430e4 ldr r3, [r4, #228] ; 0xe4
5938: e3530000 cmp r3, #0
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
593c: e5847060 str r7, [r4, #96] ; 0x60
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
5940: 1a000008 bne 5968 <rtems_termios_enqueue_raw_characters+0x1c0>
5944: e59430dc ldr r3, [r4, #220] ; 0xdc
5948: e3530000 cmp r3, #0
594c: 0a000005 beq 5968 <rtems_termios_enqueue_raw_characters+0x1c0>
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
5950: e59d0000 ldr r0, [sp] <== NOT EXECUTED
5954: e59410e0 ldr r1, [r4, #224] ; 0xe0 <== NOT EXECUTED
5958: e1a0e00f mov lr, pc <== NOT EXECUTED
595c: e12fff13 bx r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
5960: e3a03001 mov r3, #1 <== NOT EXECUTED
5964: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
5968: e2466001 sub r6, r6, #1
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
596c: e3560000 cmp r6, #0
5970: 1affffbc bne 5868 <rtems_termios_enqueue_raw_characters+0xc0>
}
}
}
}
tty->rawInBufDropped += dropped;
5974: e5943078 ldr r3, [r4, #120] ; 0x78
5978: e083300b add r3, r3, fp
597c: e5843078 str r3, [r4, #120] ; 0x78
rtems_semaphore_release (tty->rawInBuf.Semaphore);
5980: e5940068 ldr r0, [r4, #104] ; 0x68
5984: e1a0a00b mov sl, fp
5988: eb000362 bl 6718 <rtems_semaphore_release>
return dropped;
598c: eaffffaa b 583c <rtems_termios_enqueue_raw_characters+0x94>
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
5990: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
5994: e3c33010 bic r3, r3, #16 <== NOT EXECUTED
5998: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
* 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)
{
599c: e3a09001 mov r9, #1 <== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
59a0: e59430b8 ldr r3, [r4, #184] ; 0xb8
59a4: e2033030 and r3, r3, #48 ; 0x30
59a8: e3530020 cmp r3, #32
59ac: 1affffed bne 5968 <rtems_termios_enqueue_raw_characters+0x1c0>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
59b0: e10f7000 mrs r7, CPSR <== NOT EXECUTED
59b4: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED
59b8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
59bc: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
59c0: e5942094 ldr r2, [r4, #148] ; 0x94 <== NOT EXECUTED
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
59c4: e3c33020 bic r3, r3, #32 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
59c8: e3520000 cmp r2, #0 <== NOT EXECUTED
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
59cc: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
59d0: 1a00000a bne 5a00 <rtems_termios_enqueue_raw_characters+0x258><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
59d4: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
59d8: e2466001 sub r6, r6, #1 <== NOT EXECUTED
59dc: eaffffe2 b 596c <rtems_termios_enqueue_raw_characters+0x1c4><== NOT EXECUTED
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
59e0: e5d42049 ldrb r2, [r4, #73] ; 0x49
59e4: e1520003 cmp r2, r3
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
59e8: e59430b8 ldr r3, [r4, #184] ; 0xb8
59ec: 02233010 eoreq r3, r3, #16
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
59f0: 13833010 orrne r3, r3, #16
59f4: e58430b8 str r3, [r4, #184] ; 0xb8
* 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)
{
59f8: e3a09001 mov r9, #1
59fc: eaffffe7 b 59a0 <rtems_termios_enqueue_raw_characters+0x1f8>
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
5a00: 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)(
5a04: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED
5a08: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
5a0c: e0811003 add r1, r1, r3 <== NOT EXECUTED
5a10: e3a02001 mov r2, #1 <== NOT EXECUTED
5a14: e1a0e00f mov lr, pc <== NOT EXECUTED
5a18: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
5a1c: eaffffec b 59d4 <rtems_termios_enqueue_raw_characters+0x22c><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
5a20: e3130020 tst r3, #32 <== NOT EXECUTED
5a24: 1a000002 bne 5a34 <rtems_termios_enqueue_raw_characters+0x28c><== NOT EXECUTED
5a28: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
5a2c: e3530000 cmp r3, #0 <== NOT EXECUTED
5a30: 1affffb8 bne 5918 <rtems_termios_enqueue_raw_characters+0x170><== 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;
5a34: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
5a38: e3833002 orr r3, r3, #2 <== NOT EXECUTED
5a3c: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
5a40: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
5a44: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
5a48: e3a02001 mov r2, #1 <== NOT EXECUTED
5a4c: e1a0e00f mov lr, pc <== NOT EXECUTED
5a50: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
5a54: eaffffaf b 5918 <rtems_termios_enqueue_raw_characters+0x170><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
5a58: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
5a5c: e59430ac ldr r3, [r4, #172] ; 0xac <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
5a60: e3822004 orr r2, r2, #4 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
5a64: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
5a68: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
5a6c: 0affffa9 beq 5918 <rtems_termios_enqueue_raw_characters+0x170><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
5a70: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
5a74: e1a0e00f mov lr, pc <== NOT EXECUTED
5a78: e12fff13 bx r3 <== NOT EXECUTED
5a7c: eaffffa5 b 5918 <rtems_termios_enqueue_raw_characters+0x170><== NOT EXECUTED
00004760 <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;
4760: e5902000 ldr r2, [r0]
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
4764: e92d41f0 push {r4, r5, r6, r7, r8, lr}
rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
4768: e592402c ldr r4, [r2, #44] ; 0x2c
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
476c: e3a03000 mov r3, #0
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
4770: e1a06000 mov r6, r0
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
4774: e580300c str r3, [r0, #12]
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4778: e1a01003 mov r1, r3
477c: e5940018 ldr r0, [r4, #24]
4780: e1a02003 mov r2, r3
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;
4784: e5967008 ldr r7, [r6, #8]
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4788: eb000799 bl 65f4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
478c: e2505000 subs r5, r0, #0
4790: 1a00001a bne 4800 <rtems_termios_ioctl+0xa0>
return sc;
}
switch (args->command) {
4794: e5963004 ldr r3, [r6, #4]
4798: e3530005 cmp r3, #5
479c: 0a000012 beq 47ec <rtems_termios_ioctl+0x8c>
47a0: 8a000018 bhi 4808 <rtems_termios_ioctl+0xa8>
47a4: e3530002 cmp r3, #2
47a8: 0a00002b beq 485c <rtems_termios_ioctl+0xfc>
47ac: 8a0000ae bhi 4a6c <rtems_termios_ioctl+0x30c>
47b0: e3530001 cmp r3, #1
47b4: 0a0000be beq 4ab4 <rtems_termios_ioctl+0x354>
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
47b8: e59420cc ldr r2, [r4, #204] ; 0xcc
47bc: e59f3408 ldr r3, [pc, #1032] ; 4bcc <rtems_termios_ioctl+0x46c>
47c0: e0833282 add r3, r3, r2, lsl #5
47c4: e5933018 ldr r3, [r3, #24]
47c8: e3530000 cmp r3, #0
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
}
else {
sc = RTEMS_INVALID_NUMBER;
47cc: 03a0500a moveq r5, #10
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
47d0: 0a000008 beq 47f8 <rtems_termios_ioctl+0x98>
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
47d4: e1a00004 mov r0, r4
47d8: e1a01006 mov r1, r6
47dc: e1a0e00f mov lr, pc
47e0: e12fff13 bx r3
47e4: e1a05000 mov r5, r0
47e8: ea000002 b 47f8 <rtems_termios_ioctl+0x98>
break;
}
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
47ec: e897000c ldm r7, {r2, r3}
47f0: e58420d4 str r2, [r4, #212] ; 0xd4
47f4: e58430d8 str r3, [r4, #216] ; 0xd8
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_semaphore_release (tty->osem);
47f8: e5940018 ldr r0, [r4, #24]
47fc: eb0007c5 bl 6718 <rtems_semaphore_release>
return sc; }
4800: e1a00005 mov r0, r5
4804: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
4808: e59f23c0 ldr r2, [pc, #960] ; 4bd0 <rtems_termios_ioctl+0x470>
480c: e1530002 cmp r3, r2
4810: 0a00006c beq 49c8 <rtems_termios_ioctl+0x268>
4814: 8a000077 bhi 49f8 <rtems_termios_ioctl+0x298>
4818: e3530006 cmp r3, #6
481c: 1affffe5 bne 47b8 <rtems_termios_ioctl+0x58>
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_TCFLUSH:
switch ((intptr_t) args->buffer) {
4820: e5963008 ldr r3, [r6, #8]
4824: e3530001 cmp r3, #1
4828: 0a0000bc beq 4b20 <rtems_termios_ioctl+0x3c0>
482c: e3530002 cmp r3, #2
4830: 0a0000c6 beq 4b50 <rtems_termios_ioctl+0x3f0>
4834: e3530000 cmp r3, #0
case TCIOFLUSH:
flushOutput (tty);
flushInput (tty);
break;
default:
sc = RTEMS_INVALID_NAME;
4838: 13a05003 movne r5, #3
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_TCFLUSH:
switch ((intptr_t) args->buffer) {
483c: 1affffed bne 47f8 <rtems_termios_ioctl+0x98>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
4840: e10f3000 mrs r3, CPSR
4844: e3832080 orr r2, r3, #128 ; 0x80
4848: e129f002 msr CPSR_fc, r2
flushInput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
tty->rawInBuf.Tail = 0;
484c: e5845060 str r5, [r4, #96] ; 0x60
tty->rawInBuf.Head = 0;
4850: e584505c str r5, [r4, #92] ; 0x5c
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
4854: e129f003 msr CPSR_fc, r3
4858: eaffffe6 b 47f8 <rtems_termios_ioctl+0x98>
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
485c: e596e008 ldr lr, [r6, #8]
4860: e2846030 add r6, r4, #48 ; 0x30
4864: e8be000f ldm lr!, {r0, r1, r2, r3}
4868: e1a0c006 mov ip, r6
486c: e8ac000f stmia ip!, {r0, r1, r2, r3}
4870: e8be000f ldm lr!, {r0, r1, r2, r3}
4874: e8ac000f stmia ip!, {r0, r1, r2, r3}
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
4878: e59420b8 ldr r2, [r4, #184] ; 0xb8
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
487c: e59e3000 ldr r3, [lr]
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
4880: e3120c02 tst r2, #512 ; 0x200
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
4884: 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) &&
4888: 0a000012 beq 48d8 <rtems_termios_ioctl+0x178>
!(tty->termios.c_iflag & IXON)) {
488c: 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) &&
4890: e3130b01 tst r3, #1024 ; 0x400
4894: 1a00000f bne 48d8 <rtems_termios_ioctl+0x178>
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
4898: e59430b8 ldr r3, [r4, #184] ; 0xb8
489c: e3c33e21 bic r3, r3, #528 ; 0x210
48a0: e58430b8 str r3, [r4, #184] ; 0xb8
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
48a4: e59430b8 ldr r3, [r4, #184] ; 0xb8
48a8: e3130020 tst r3, #32
48ac: 0a000009 beq 48d8 <rtems_termios_ioctl+0x178>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
48b0: e10f7000 mrs r7, CPSR <== NOT EXECUTED
48b4: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED
48b8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
48bc: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
48c0: e5942094 ldr r2, [r4, #148] ; 0x94 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
48c4: e3c33020 bic r3, r3, #32 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
48c8: e3520000 cmp r2, #0 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
48cc: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
48d0: 1a0000b5 bne 4bac <rtems_termios_ioctl+0x44c> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
48d4: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
/* reenable interrupts */
rtems_interrupt_enable(level);
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
48d8: e59430b8 ldr r3, [r4, #184] ; 0xb8
48dc: e3130b01 tst r3, #1024 ; 0x400
48e0: 0a000008 beq 4908 <rtems_termios_ioctl+0x1a8>
48e4: e5943030 ldr r3, [r4, #48] ; 0x30
48e8: e3130a01 tst r3, #4096 ; 0x1000
48ec: 1a000005 bne 4908 <rtems_termios_ioctl+0x1a8>
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
48f0: e59430b8 ldr r3, [r4, #184] ; 0xb8
48f4: e3c33b01 bic r3, r3, #1024 ; 0x400
48f8: e58430b8 str r3, [r4, #184] ; 0xb8
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
48fc: e59430b8 ldr r3, [r4, #184] ; 0xb8
4900: e3c33002 bic r3, r3, #2
4904: 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)) {
4908: e59430b8 ldr r3, [r4, #184] ; 0xb8
490c: e3130c01 tst r3, #256 ; 0x100
4910: e5942038 ldr r2, [r4, #56] ; 0x38
4914: 0a000011 beq 4960 <rtems_termios_ioctl+0x200>
4918: e3520000 cmp r2, #0 <== NOT EXECUTED
491c: ba000087 blt 4b40 <rtems_termios_ioctl+0x3e0> <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
4920: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4924: e3c33c01 bic r3, r3, #256 ; 0x100 <== NOT EXECUTED
4928: 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)) {
492c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4930: e3130004 tst r3, #4 <== NOT EXECUTED
4934: 0a000006 beq 4954 <rtems_termios_ioctl+0x1f4> <== NOT EXECUTED
4938: e59430b0 ldr r3, [r4, #176] ; 0xb0 <== NOT EXECUTED
493c: e3530000 cmp r3, #0 <== NOT EXECUTED
4940: 0a000003 beq 4954 <rtems_termios_ioctl+0x1f4> <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
4944: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
4948: e1a0e00f mov lr, pc <== NOT EXECUTED
494c: e12fff13 bx r3 <== NOT EXECUTED
4950: e5942038 ldr r2, [r4, #56] ; 0x38 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
4954: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4958: e3c33004 bic r3, r3, #4 <== NOT EXECUTED
495c: 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) {
4960: e3520000 cmp r2, #0
4964: ba000075 blt 4b40 <rtems_termios_ioctl+0x3e0>
tty->flow_ctrl |= FL_MDRTS;
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
4968: e5943030 ldr r3, [r4, #48] ; 0x30
496c: e3130a01 tst r3, #4096 ; 0x1000
tty->flow_ctrl |= FL_MDXOF;
4970: 159420b8 ldrne r2, [r4, #184] ; 0xb8
4974: 13822b01 orrne r2, r2, #1024 ; 0x400
4978: 158420b8 strne r2, [r4, #184] ; 0xb8
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
497c: e3130b01 tst r3, #1024 ; 0x400
tty->flow_ctrl |= FL_MDXON;
4980: 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) {
4984: e594703c ldr r7, [r4, #60] ; 0x3c
if (tty->termios.c_iflag & IXOFF) {
tty->flow_ctrl |= FL_MDXOF;
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
tty->flow_ctrl |= FL_MDXON;
4988: 13833c02 orrne r3, r3, #512 ; 0x200
498c: 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) {
4990: e2177002 ands r7, r7, #2
4994: 0a00004f beq 4ad8 <rtems_termios_ioctl+0x378>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
4998: e3a03000 mov r3, #0
499c: e584306c str r3, [r4, #108] ; 0x6c
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
49a0: e5843070 str r3, [r4, #112] ; 0x70
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
49a4: e5843074 str r3, [r4, #116] ; 0x74
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
49a8: e59430a8 ldr r3, [r4, #168] ; 0xa8
49ac: e3530000 cmp r3, #0
49b0: 0affff90 beq 47f8 <rtems_termios_ioctl+0x98>
(*tty->device.setAttributes)(tty->minor, &tty->termios);
49b4: e5940010 ldr r0, [r4, #16]
49b8: e1a01006 mov r1, r6
49bc: e1a0e00f mov lr, pc
49c0: e12fff13 bx r3
49c4: eaffff8b b 47f8 <rtems_termios_ioctl+0x98>
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
49c8: e5942060 ldr r2, [r4, #96] ; 0x60 <== NOT EXECUTED
49cc: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED
if ( rawnc < 0 )
49d0: e0523003 subs r3, r2, r3 <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
49d4: 45942064 ldrmi r2, [r4, #100] ; 0x64 <== NOT EXECUTED
49d8: 40833002 addmi r3, r3, r2 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
49dc: e2841020 add r1, r4, #32 <== NOT EXECUTED
49e0: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
49e4: e0412002 sub r2, r1, r2 <== NOT EXECUTED
49e8: e5961008 ldr r1, [r6, #8] <== NOT EXECUTED
49ec: e0823003 add r3, r2, r3 <== NOT EXECUTED
49f0: e5813000 str r3, [r1] <== NOT EXECUTED
}
break;
49f4: eaffff7f b 47f8 <rtems_termios_ioctl+0x98> <== NOT EXECUTED
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
49f8: e59f21d4 ldr r2, [pc, #468] ; 4bd4 <rtems_termios_ioctl+0x474>
49fc: e1530002 cmp r3, r2
4a00: 0a000027 beq 4aa4 <rtems_termios_ioctl+0x344>
4a04: e2822105 add r2, r2, #1073741825 ; 0x40000001
4a08: e1530002 cmp r3, r2
4a0c: 1affff69 bne 47b8 <rtems_termios_ioctl+0x58>
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
4a10: e59f71b4 ldr r7, [pc, #436] ; 4bcc <rtems_termios_ioctl+0x46c>
4a14: e59430cc ldr r3, [r4, #204] ; 0xcc
4a18: e0873283 add r3, r7, r3, lsl #5
4a1c: e5933004 ldr r3, [r3, #4]
4a20: e3530000 cmp r3, #0
4a24: 0a000003 beq 4a38 <rtems_termios_ioctl+0x2d8>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
4a28: e1a00004 mov r0, r4
4a2c: e1a0e00f mov lr, pc
4a30: e12fff13 bx r3
4a34: e1a05000 mov r5, r0
}
tty->t_line=*(int*)(args->buffer);
4a38: e5963008 ldr r3, [r6, #8]
4a3c: e5932000 ldr r2, [r3]
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
4a40: e7973282 ldr r3, [r7, r2, lsl #5]
* 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);
4a44: e58420cc str r2, [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) {
4a48: e3530000 cmp r3, #0
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
tty->t_sc = NULL; /* ensure that no more valid data */
4a4c: e3a02000 mov r2, #0
4a50: e58420d0 str r2, [r4, #208] ; 0xd0
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
4a54: 0affff67 beq 47f8 <rtems_termios_ioctl+0x98>
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
4a58: e1a00004 mov r0, r4
4a5c: e1a0e00f mov lr, pc
4a60: e12fff13 bx r3
4a64: e1a05000 mov r5, r0
4a68: eaffff62 b 47f8 <rtems_termios_ioctl+0x98>
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
4a6c: e3530003 cmp r3, #3
4a70: 0a000005 beq 4a8c <rtems_termios_ioctl+0x32c>
4a74: e3530004 cmp r3, #4
4a78: 1affff4e bne 47b8 <rtems_termios_ioctl+0x58>
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
break;
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
4a7c: e897000c ldm r7, {r2, r3}
4a80: e58420dc str r2, [r4, #220] ; 0xdc
4a84: e58430e0 str r3, [r4, #224] ; 0xe0
break;
4a88: eaffff5a b 47f8 <rtems_termios_ioctl+0x98>
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
4a8c: e59430b4 ldr r3, [r4, #180] ; 0xb4
4a90: e3530000 cmp r3, #0
4a94: 0affff57 beq 47f8 <rtems_termios_ioctl+0x98>
4a98: e1a00004 mov r0, r4 <== NOT EXECUTED
4a9c: ebfffd82 bl 40ac <drainOutput.part.0> <== NOT EXECUTED
4aa0: eaffff54 b 47f8 <rtems_termios_ioctl+0x98> <== NOT EXECUTED
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
4aa4: e59420cc ldr r2, [r4, #204] ; 0xcc
4aa8: e5963008 ldr r3, [r6, #8]
4aac: e5832000 str r2, [r3]
break;
4ab0: eaffff50 b 47f8 <rtems_termios_ioctl+0x98>
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
4ab4: e284e030 add lr, r4, #48 ; 0x30
4ab8: e8be000f ldm lr!, {r0, r1, r2, r3}
4abc: e596c008 ldr ip, [r6, #8]
4ac0: e8ac000f stmia ip!, {r0, r1, r2, r3}
4ac4: e8be000f ldm lr!, {r0, r1, r2, r3}
4ac8: e8ac000f stmia ip!, {r0, r1, r2, r3}
4acc: e59e3000 ldr r3, [lr]
4ad0: e58c3000 str r3, [ip]
break;
4ad4: eaffff47 b 47f8 <rtems_termios_ioctl+0x98>
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] *
4ad8: e5d48046 ldrb r8, [r4, #70] ; 0x46
rtems_clock_get_ticks_per_second() / 10;
4adc: eb00051f bl 5f60 <rtems_clock_get_ticks_per_second>
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] *
4ae0: e0000098 mul r0, r8, r0
rtems_clock_get_ticks_per_second() / 10;
4ae4: e59f30ec ldr r3, [pc, #236] ; 4bd8 <rtems_termios_ioctl+0x478>
4ae8: e0831390 umull r1, r3, r0, r3
if (tty->termios.c_cc[VTIME]) {
4aec: e5d42046 ldrb r2, [r4, #70] ; 0x46
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
4af0: e1a031a3 lsr r3, r3, #3
if (tty->termios.c_cc[VTIME]) {
4af4: e3520000 cmp r2, #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] *
4af8: e5843054 str r3, [r4, #84] ; 0x54
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
4afc: 0a000022 beq 4b8c <rtems_termios_ioctl+0x42c>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
4b00: e5d42047 ldrb r2, [r4, #71] ; 0x47
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
4b04: e3520000 cmp r2, #0
4b08: 01a02003 moveq r2, r3
4b0c: 13a02000 movne r2, #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;
4b10: e584706c str r7, [r4, #108] ; 0x6c
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
4b14: e5843070 str r3, [r4, #112] ; 0x70
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
4b18: e5842074 str r2, [r4, #116] ; 0x74
4b1c: eaffffa1 b 49a8 <rtems_termios_ioctl+0x248>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
4b20: e10f3000 mrs r3, CPSR
4b24: e3832080 orr r2, r3, #128 ; 0x80
4b28: e129f002 msr CPSR_fc, r2
flushOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
tty->rawOutBuf.Tail = 0;
4b2c: e5845084 str r5, [r4, #132] ; 0x84
tty->rawOutBuf.Head = 0; tty->rawOutBufState = rob_idle;
4b30: e5845094 str r5, [r4, #148] ; 0x94
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
tty->rawOutBuf.Tail = 0;
tty->rawOutBuf.Head = 0;
4b34: e5845080 str r5, [r4, #128] ; 0x80
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
4b38: e129f003 msr CPSR_fc, r3
4b3c: eaffff2d b 47f8 <rtems_termios_ioctl+0x98>
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
tty->flow_ctrl |= FL_MDRTS;
4b40: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4b44: e3833c01 orr r3, r3, #256 ; 0x100 <== NOT EXECUTED
4b48: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4b4c: eaffff85 b 4968 <rtems_termios_ioctl+0x208> <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
4b50: e10f3000 mrs r3, CPSR
4b54: e3832080 orr r2, r3, #128 ; 0x80
4b58: e129f002 msr CPSR_fc, r2
flushOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
tty->rawOutBuf.Tail = 0;
4b5c: e5845084 str r5, [r4, #132] ; 0x84
tty->rawOutBuf.Head = 0; tty->rawOutBufState = rob_idle;
4b60: e5845094 str r5, [r4, #148] ; 0x94
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
tty->rawOutBuf.Tail = 0;
tty->rawOutBuf.Head = 0;
4b64: e5845080 str r5, [r4, #128] ; 0x80
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
4b68: e129f003 msr CPSR_fc, r3
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
4b6c: e10f2000 mrs r2, CPSR
4b70: e3823080 orr r3, r2, #128 ; 0x80
4b74: e129f003 msr CPSR_fc, r3
flushInput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_interrupt_disable (level);
tty->rawInBuf.Tail = 0;
4b78: e3a03000 mov r3, #0
4b7c: e5843060 str r3, [r4, #96] ; 0x60
tty->rawInBuf.Head = 0;
4b80: e584305c str r3, [r4, #92] ; 0x5c
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
4b84: e129f002 msr CPSR_fc, r2
4b88: eaffff1a b 47f8 <rtems_termios_ioctl+0x98>
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
4b8c: e5d43047 ldrb r3, [r4, #71] ; 0x47
4b90: e3530000 cmp r3, #0
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
4b94: 03a03001 moveq r3, #1
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
4b98: 1584206c strne r2, [r4, #108] ; 0x6c
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
4b9c: 15842070 strne r2, [r4, #112] ; 0x70
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
4ba0: 15842074 strne r2, [r4, #116] ; 0x74
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
4ba4: 0584306c streq r3, [r4, #108] ; 0x6c
4ba8: eaffff7e b 49a8 <rtems_termios_ioctl+0x248>
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
4bac: 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)(
4bb0: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED
4bb4: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
4bb8: e0811003 add r1, r1, r3 <== NOT EXECUTED
4bbc: e3a02001 mov r2, #1 <== NOT EXECUTED
4bc0: e1a0e00f mov lr, pc <== NOT EXECUTED
4bc4: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
4bc8: eaffff41 b 48d4 <rtems_termios_ioctl+0x174> <== NOT EXECUTED
0000411c <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
411c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
4120: e59f7414 ldr r7, [pc, #1044] ; 453c <rtems_termios_open+0x420>
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
4124: e1a06001 mov r6, r1
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
4128: e3a01000 mov r1, #0
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
412c: e24dd014 sub sp, sp, #20
4130: e1a05000 mov r5, r0
4134: e1a08002 mov r8, r2
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
4138: e5970000 ldr r0, [r7]
413c: e1a02001 mov r2, r1
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
4140: e58d3010 str r3, [sp, #16]
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
4144: eb00092a bl 65f4 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4148: e250a000 subs sl, r0, #0
414c: 1a000021 bne 41d8 <rtems_termios_open+0xbc>
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
4150: e59fb3e8 ldr fp, [pc, #1000] ; 4540 <rtems_termios_open+0x424>
4154: e59b9000 ldr r9, [fp]
4158: e3590000 cmp r9, #0
415c: 0a00002d beq 4218 <rtems_termios_open+0xfc>
4160: e1a04009 mov r4, r9
4164: ea000002 b 4174 <rtems_termios_open+0x58>
4168: e5944000 ldr r4, [r4]
416c: e3540000 cmp r4, #0
4170: 0a000028 beq 4218 <rtems_termios_open+0xfc>
if ((tty->major == major) && (tty->minor == minor))
4174: e594300c ldr r3, [r4, #12]
4178: e1530005 cmp r3, r5
417c: 1afffff9 bne 4168 <rtems_termios_open+0x4c>
4180: e5943010 ldr r3, [r4, #16]
4184: e1530006 cmp r3, r6
4188: 1afffff6 bne 4168 <rtems_termios_open+0x4c>
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
if (!tty->refcount++) {
418c: e5943008 ldr r3, [r4, #8]
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
4190: e5981000 ldr r1, [r8]
if (!tty->refcount++) {
4194: e2832001 add r2, r3, #1
4198: e3530000 cmp r3, #0
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
419c: e581402c str r4, [r1, #44] ; 0x2c
if (!tty->refcount++) {
41a0: e5842008 str r2, [r4, #8]
41a4: 1a000009 bne 41d0 <rtems_termios_open+0xb4>
if (tty->device.firstOpen)
41a8: e5943098 ldr r3, [r4, #152] ; 0x98
41ac: e3530000 cmp r3, #0
(*tty->device.firstOpen)(major, minor, arg);
41b0: 11a00005 movne r0, r5
41b4: 11a01006 movne r1, r6
41b8: 11a02008 movne r2, r8
41bc: 11a0e00f movne lr, pc
41c0: 112fff13 bxne r3
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
41c4: e59430b4 ldr r3, [r4, #180] ; 0xb4
41c8: e3530002 cmp r3, #2
41cc: 0a000004 beq 41e4 <rtems_termios_open+0xc8>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
41d0: e5970000 ldr r0, [r7]
41d4: eb00094f bl 6718 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL; }
41d8: e1a0000a mov r0, sl
41dc: e28dd014 add sp, sp, #20
41e0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_start(
41e4: e59400c4 ldr r0, [r4, #196] ; 0xc4
41e8: e59f1354 ldr r1, [pc, #852] ; 4544 <rtems_termios_open+0x428>
41ec: e1a02004 mov r2, r4
41f0: eb000a35 bl 6acc <rtems_task_start>
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
41f4: e3500000 cmp r0, #0
41f8: 1a0000b6 bne 44d8 <rtems_termios_open+0x3bc>
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
41fc: e59400c8 ldr r0, [r4, #200] ; 0xc8
4200: e59f1340 ldr r1, [pc, #832] ; 4548 <rtems_termios_open+0x42c>
4204: e1a02004 mov r2, r4
4208: eb000a2f bl 6acc <rtems_task_start>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
420c: e3500000 cmp r0, #0
4210: 0affffee beq 41d0 <rtems_termios_open+0xb4>
4214: ea0000af b 44d8 <rtems_termios_open+0x3bc> <== NOT EXECUTED
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
4218: e3a00001 mov r0, #1
421c: e3a010e8 mov r1, #232 ; 0xe8
4220: ebfff81e bl 22a0 <calloc>
if (tty == NULL) {
4224: e2504000 subs r4, r0, #0
4228: 0a00009a beq 4498 <rtems_termios_open+0x37c>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
422c: e59f0318 ldr r0, [pc, #792] ; 454c <rtems_termios_open+0x430>
4230: e5903000 ldr r3, [r0]
4234: e5843064 str r3, [r4, #100] ; 0x64
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
4238: e5940064 ldr r0, [r4, #100] ; 0x64
423c: ebfff982 bl 284c <malloc>
if (tty->rawInBuf.theBuf == NULL) {
4240: e3500000 cmp r0, #0
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
4244: e1a02000 mov r2, r0
4248: e5840058 str r0, [r4, #88] ; 0x58
if (tty->rawInBuf.theBuf == NULL) {
424c: 0a00008f beq 4490 <rtems_termios_open+0x374>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
4250: e59f12f4 ldr r1, [pc, #756] ; 454c <rtems_termios_open+0x430>
4254: e5913004 ldr r3, [r1, #4]
4258: e5843088 str r3, [r4, #136] ; 0x88
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
425c: e5940088 ldr r0, [r4, #136] ; 0x88
4260: e58d2008 str r2, [sp, #8]
4264: ebfff978 bl 284c <malloc>
if (tty->rawOutBuf.theBuf == NULL) {
4268: e3500000 cmp r0, #0
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
426c: e1a03000 mov r3, r0
4270: e584007c str r0, [r4, #124] ; 0x7c
if (tty->rawOutBuf.theBuf == NULL) {
4274: e59d2008 ldr r2, [sp, #8]
4278: 0a000082 beq 4488 <rtems_termios_open+0x36c>
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
427c: e59f12c8 ldr r1, [pc, #712] ; 454c <rtems_termios_open+0x430>
4280: e5910008 ldr r0, [r1, #8]
4284: e58d300c str r3, [sp, #12]
4288: e58d2008 str r2, [sp, #8]
428c: ebfff96e bl 284c <malloc>
if (tty->cbuf == NULL) {
4290: e3500000 cmp r0, #0
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
4294: e584001c str r0, [r4, #28]
if (tty->cbuf == NULL) {
4298: e59d300c ldr r3, [sp, #12]
429c: 0a000076 beq 447c <rtems_termios_open+0x360>
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
42a0: e3a03000 mov r3, #0
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
42a4: e1590003 cmp r9, r3
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
42a8: e5843004 str r3, [r4, #4]
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
42ac: e58430d4 str r3, [r4, #212] ; 0xd4
tty->tty_snd.sw_arg = NULL;
42b0: e58430d8 str r3, [r4, #216] ; 0xd8
tty->tty_rcv.sw_pfn = NULL;
42b4: e58430dc str r3, [r4, #220] ; 0xdc
tty->tty_rcv.sw_arg = NULL;
42b8: e58430e0 str r3, [r4, #224] ; 0xe0
tty->tty_rcvwakeup = 0;
42bc: e58430e4 str r3, [r4, #228] ; 0xe4
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
42c0: e59f3288 ldr r3, [pc, #648] ; 4550 <rtems_termios_open+0x434>
42c4: e5932000 ldr r2, [r3]
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
42c8: 15894004 strne r4, [r9, #4]
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
42cc: e3520000 cmp r2, #0
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
42d0: e59f2274 ldr r2, [pc, #628] ; 454c <rtems_termios_open+0x430>
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
42d4: 05834000 streq r4, [r3]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
42d8: e59f0274 ldr r0, [pc, #628] ; 4554 <rtems_termios_open+0x438>
rtems_build_name ('T', 'R', 'i', c),
42dc: e5d2300c ldrb r3, [r2, #12]
tty->tty_rcvwakeup = 0;
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
42e0: e5849000 str r9, [r4]
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
42e4: e58b4000 str r4, [fp]
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
42e8: e5846010 str r6, [r4, #16]
tty->major = major;
42ec: e584500c str r5, [r4, #12]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
42f0: e284c014 add ip, r4, #20
42f4: e1830000 orr r0, r3, r0
42f8: e3a01001 mov r1, #1
42fc: e3a03000 mov r3, #0
4300: e3a02054 mov r2, #84 ; 0x54
4304: e58dc000 str ip, [sp]
4308: eb000820 bl 6390 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'i', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
430c: e2503000 subs r3, r0, #0
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
4310: e59f9234 ldr r9, [pc, #564] ; 454c <rtems_termios_open+0x430>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
4314: 1a00006f bne 44d8 <rtems_termios_open+0x3bc>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'o', c),
4318: e5d9200c ldrb r2, [r9, #12]
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
431c: e59f0234 ldr r0, [pc, #564] ; 4558 <rtems_termios_open+0x43c>
4320: e284c018 add ip, r4, #24
4324: e1820000 orr r0, r2, r0
4328: e3a01001 mov r1, #1
432c: e3a02054 mov r2, #84 ; 0x54
4330: e58dc000 str ip, [sp]
4334: eb000815 bl 6390 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'o', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
4338: e2501000 subs r1, r0, #0
433c: 1a000065 bne 44d8 <rtems_termios_open+0x3bc>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'x', c),
4340: e5d9300c ldrb r3, [r9, #12]
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
4344: e59f0210 ldr r0, [pc, #528] ; 455c <rtems_termios_open+0x440>
4348: e284c08c add ip, r4, #140 ; 0x8c
434c: e1830000 orr r0, r3, r0
4350: e3a02020 mov r2, #32
4354: e1a03001 mov r3, r1
4358: e58dc000 str ip, [sp]
435c: eb00080b bl 6390 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'x', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
4360: e250b000 subs fp, r0, #0
4364: 1a00005b bne 44d8 <rtems_termios_open+0x3bc>
tty->rawOutBufState = rob_idle;
/*
* Set callbacks
*/
tty->device = *callbacks;
4368: e59de010 ldr lr, [sp, #16]
436c: e8be000f ldm lr!, {r0, r1, r2, r3}
4370: e284c098 add ip, r4, #152 ; 0x98
4374: e8ac000f stmia ip!, {r0, r1, r2, r3}
4378: e89e000f ldm lr, {r0, r1, r2, r3}
437c: e88c000f stm ip, {r0, r1, r2, r3}
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
4380: e59430b4 ldr r3, [r4, #180] ; 0xb4
4384: e3530002 cmp r3, #2
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
4388: e584b094 str fp, [r4, #148] ; 0x94
tty->device = *callbacks;
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
438c: 0a000052 beq 44dc <rtems_termios_open+0x3c0>
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
4390: e59430a0 ldr r3, [r4, #160] ; 0xa0
4394: e3530000 cmp r3, #0
4398: 0a000042 beq 44a8 <rtems_termios_open+0x38c>
439c: e59430b4 ldr r3, [r4, #180] ; 0xb4
43a0: e3530002 cmp r3, #2
43a4: 0a00003f beq 44a8 <rtems_termios_open+0x38c>
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
43a8: e3a03000 mov r3, #0
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
43ac: e58430b8 str r3, [r4, #184] ; 0xb8
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
43b0: e59f0194 ldr r0, [pc, #404] ; 454c <rtems_termios_open+0x430>
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
43b4: e594c064 ldr ip, [r4, #100] ; 0x64
tty->highwater = tty->rawInBuf.Size * 3/4;
43b8: e5941064 ldr r1, [r4, #100] ; 0x64
/*
* Bump name characer
*/
if (c++ == 'z')
43bc: e5d0200c ldrb r2, [r0, #12]
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
43c0: e0811081 add r1, r1, r1, lsl #1
/*
* Bump name characer
*/
if (c++ == 'z')
43c4: e352007a cmp r2, #122 ; 0x7a
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
43c8: e1a00121 lsr r0, r1, #2
/*
* Bump name characer
*/
if (c++ == 'z')
43cc: e2821001 add r1, r2, #1
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
43d0: e59f2188 ldr r2, [pc, #392] ; 4560 <rtems_termios_open+0x444>
43d4: e5842030 str r2, [r4, #48] ; 0x30
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
43d8: e59f2184 ldr r2, [pc, #388] ; 4564 <rtems_termios_open+0x448>
43dc: e5842034 str r2, [r4, #52] ; 0x34
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
43e0: e59f2180 ldr r2, [pc, #384] ; 4568 <rtems_termios_open+0x44c>
43e4: e5842038 str r2, [r4, #56] ; 0x38
tty->termios.c_lflag =
43e8: e59f217c ldr r2, [pc, #380] ; 456c <rtems_termios_open+0x450>
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
43ec: e5c4304c strb r3, [r4, #76] ; 0x4c
tty->termios.c_cc[VEOL2] = '\000';
43f0: e5c43051 strb r3, [r4, #81] ; 0x51
tty->termios.c_cc[VSTART] = '\021';
43f4: e3a03011 mov r3, #17
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
43f8: e584203c str r2, [r4, #60] ; 0x3c
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
43fc: e5c43049 strb r3, [r4, #73] ; 0x49
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
4400: e3a02003 mov r2, #3
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
4404: e3a03013 mov r3, #19
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
4408: e5c42041 strb r2, [r4, #65] ; 0x41
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
440c: e5c4304a strb r3, [r4, #74] ; 0x4a
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
4410: e3a0201c mov r2, #28
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
4414: e3a0301a mov r3, #26
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
4418: e5c42042 strb r2, [r4, #66] ; 0x42
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
441c: e5c4304b strb r3, [r4, #75] ; 0x4b
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
4420: e3a0207f mov r2, #127 ; 0x7f
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
4424: e3a03012 mov r3, #18
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
4428: e5c42043 strb r2, [r4, #67] ; 0x43
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
442c: e5c4304d strb r3, [r4, #77] ; 0x4d
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
4430: e3a02015 mov r2, #21
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
4434: e3a0300f mov r3, #15
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
4438: e5c42044 strb r2, [r4, #68] ; 0x44
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
443c: e5c4304e strb r3, [r4, #78] ; 0x4e
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
4440: e3a02004 mov r2, #4
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
4444: e3a03017 mov r3, #23
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
4448: e5c42045 strb r2, [r4, #69] ; 0x45
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
444c: e5c4304f strb r3, [r4, #79] ; 0x4f
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
4450: e59f20f4 ldr r2, [pc, #244] ; 454c <rtems_termios_open+0x430>
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
4454: e3a03016 mov r3, #22
4458: e5c43050 strb r3, [r4, #80] ; 0x50
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
445c: 059f30e8 ldreq r3, [pc, #232] ; 454c <rtems_termios_open+0x430>
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
4460: e5c2100c strb r1, [r2, #12]
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
4464: e1a0c0ac lsr ip, ip, #1
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
4468: 03a02061 moveq r2, #97 ; 0x61
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
446c: e584c0bc str ip, [r4, #188] ; 0xbc
tty->highwater = tty->rawInBuf.Size * 3/4;
4470: e58400c0 str r0, [r4, #192] ; 0xc0
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
4474: 05c3200c strbeq r2, [r3, #12]
4478: eaffff43 b 418c <rtems_termios_open+0x70>
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
447c: e1a00003 mov r0, r3
4480: ebfff823 bl 2514 <free>
free((void *)(tty->rawInBuf.theBuf));
4484: e59d2008 ldr r2, [sp, #8]
4488: e1a00002 mov r0, r2
448c: ebfff820 bl 2514 <free>
free(tty);
4490: e1a00004 mov r0, r4
4494: ebfff81e bl 2514 <free>
rtems_semaphore_release (rtems_termios_ttyMutex);
4498: e5970000 ldr r0, [r7]
449c: eb00089d bl 6718 <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
44a0: e3a0a01a mov sl, #26
44a4: eaffff4b b 41d8 <rtems_termios_open+0xbc>
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'r', c),
44a8: e59f009c ldr r0, [pc, #156] ; 454c <rtems_termios_open+0x430>
44ac: e5d0300c ldrb r3, [r0, #12]
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
44b0: e59f00b8 ldr r0, [pc, #184] ; 4570 <rtems_termios_open+0x454>
44b4: e3a01000 mov r1, #0
44b8: e284c068 add ip, r4, #104 ; 0x68
44bc: e1830000 orr r0, r3, r0
44c0: e3a02024 mov r2, #36 ; 0x24
44c4: e1a03001 mov r3, r1
44c8: e58dc000 str ip, [sp]
44cc: eb0007af bl 6390 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'r', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->rawInBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
44d0: e3500000 cmp r0, #0
44d4: 0affffb3 beq 43a8 <rtems_termios_open+0x28c>
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
44d8: eb000a1f bl 6d5c <rtems_fatal_error_occurred>
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
rtems_build_name ('T', 'x', 'T', c),
44dc: e5d9300c ldrb r3, [r9, #12]
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
44e0: e59f008c ldr r0, [pc, #140] ; 4574 <rtems_termios_open+0x458>
44e4: e284c0c8 add ip, r4, #200 ; 0xc8
44e8: e1830000 orr r0, r3, r0
44ec: e3a0100a mov r1, #10
44f0: e3a02b01 mov r2, #1024 ; 0x400
44f4: e3a03c05 mov r3, #1280 ; 0x500
44f8: e88d1800 stm sp, {fp, ip}
44fc: eb0008c4 bl 6814 <rtems_task_create>
TERMIOS_TXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
4500: e250e000 subs lr, r0, #0
4504: 1afffff3 bne 44d8 <rtems_termios_open+0x3bc>
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
rtems_build_name ('R', 'x', 'T', c),
4508: e5d9300c ldrb r3, [r9, #12]
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
450c: e59f0064 ldr r0, [pc, #100] ; 4578 <rtems_termios_open+0x45c>
4510: e284c0c4 add ip, r4, #196 ; 0xc4
4514: e1830000 orr r0, r3, r0
4518: e3a01009 mov r1, #9
451c: e3a02b01 mov r2, #1024 ; 0x400
4520: e3a03c05 mov r3, #1280 ; 0x500
4524: e58de000 str lr, [sp]
4528: e58dc004 str ip, [sp, #4]
452c: eb0008b8 bl 6814 <rtems_task_create>
TERMIOS_RXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
4530: e3500000 cmp r0, #0
4534: 0affff95 beq 4390 <rtems_termios_open+0x274>
4538: eaffffe6 b 44d8 <rtems_termios_open+0x3bc> <== NOT EXECUTED
00004bdc <rtems_termios_puts>:
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
4bdc: e59230b4 ldr r3, [r2, #180] ; 0xb4
4be0: e3530000 cmp r3, #0
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, size_t len, struct rtems_termios_tty *tty)
{
4be4: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
4be8: e1a04002 mov r4, r2
4bec: e1a09000 mov r9, r0
4bf0: e1a0a001 mov sl, r1
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
4bf4: 0a000037 beq 4cd8 <rtems_termios_puts+0xfc>
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
4bf8: e3510000 cmp r1, #0
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
4bfc: e5928080 ldr r8, [r2, #128] ; 0x80
while (len) {
4c00: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc}
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
4c04: e3a07002 mov r7, #2
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
4c08: e5941088 ldr r1, [r4, #136] ; 0x88
4c0c: e2880001 add r0, r8, #1
4c10: eb00472b bl 168c4 <__umodsi3>
4c14: e1a08000 mov r8, r0
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
4c18: e10f5000 mrs r5, CPSR
4c1c: e3853080 orr r3, r5, #128 ; 0x80
4c20: e129f003 msr CPSR_fc, r3
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
4c24: e5946084 ldr r6, [r4, #132] ; 0x84
4c28: e1560000 cmp r6, r0
4c2c: 1a00000d bne 4c68 <rtems_termios_puts+0x8c>
tty->rawOutBufState = rob_wait;
4c30: e5847094 str r7, [r4, #148] ; 0x94
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
4c34: e129f005 msr CPSR_fc, r5
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
4c38: e3a01000 mov r1, #0
4c3c: e594008c ldr r0, [r4, #140] ; 0x8c
4c40: e1a02001 mov r2, r1
4c44: eb00066a bl 65f4 <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4c48: e3500000 cmp r0, #0
4c4c: 1a000027 bne 4cf0 <rtems_termios_puts+0x114>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
4c50: e10f5000 mrs r5, CPSR
4c54: e3853080 orr r3, r5, #128 ; 0x80
4c58: e129f003 msr CPSR_fc, r3
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
4c5c: e5943084 ldr r3, [r4, #132] ; 0x84
4c60: e1530006 cmp r3, r6
4c64: 0afffff1 beq 4c30 <rtems_termios_puts+0x54>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
4c68: e5943080 ldr r3, [r4, #128] ; 0x80
4c6c: e4d91001 ldrb r1, [r9], #1
4c70: e594207c ldr r2, [r4, #124] ; 0x7c
4c74: e7c21003 strb r1, [r2, r3]
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
4c78: e5943094 ldr r3, [r4, #148] ; 0x94
4c7c: e3530000 cmp r3, #0
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
4c80: e5848080 str r8, [r4, #128] ; 0x80
if (tty->rawOutBufState == rob_idle) {
4c84: 1a000007 bne 4ca8 <rtems_termios_puts+0xcc>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
4c88: e59430b8 ldr r3, [r4, #184] ; 0xb8
4c8c: e3130010 tst r3, #16
4c90: 0a000008 beq 4cb8 <rtems_termios_puts+0xdc>
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
4c94: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4c98: e3833020 orr r3, r3, #32 <== NOT EXECUTED
4c9c: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
4ca0: e3a03001 mov r3, #1
4ca4: e5843094 str r3, [r4, #148] ; 0x94
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
4ca8: e129f005 msr CPSR_fc, r5
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
4cac: e25aa001 subs sl, sl, #1
4cb0: 1affffd4 bne 4c08 <rtems_termios_puts+0x2c>
4cb4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
4cb8: e5943084 ldr r3, [r4, #132] ; 0x84
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(
4cbc: e594107c ldr r1, [r4, #124] ; 0x7c
4cc0: e5940010 ldr r0, [r4, #16]
4cc4: e0811003 add r1, r1, r3
4cc8: e3a02001 mov r2, #1
4ccc: e1a0e00f mov lr, pc
4cd0: e594f0a4 ldr pc, [r4, #164] ; 0xa4
4cd4: eafffff1 b 4ca0 <rtems_termios_puts+0xc4>
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
4cd8: e5920010 ldr r0, [r2, #16]
4cdc: e1a01009 mov r1, r9
4ce0: e1a0200a mov r2, sl
4ce4: e1a0e00f mov lr, pc
4ce8: e594f0a4 ldr pc, [r4, #164] ; 0xa4
return;
4cec: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
4cf0: eb000819 bl 6d5c <rtems_fatal_error_occurred> <== NOT EXECUTED
000053f4 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
53f4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
53f8: e5903000 ldr r3, [r0]
53fc: 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);
5400: e3a01000 mov r1, #0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
5404: e1a09000 mov r9, r0
5408: e24dd008 sub sp, sp, #8
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
540c: e5940014 ldr r0, [r4, #20]
5410: e1a02001 mov r2, r1
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
5414: e5998010 ldr r8, [r9, #16]
char *buffer = args->buffer;
5418: e599a00c ldr sl, [r9, #12]
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
541c: eb000474 bl 65f4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
5420: e3500000 cmp r0, #0
5424: e58d0000 str r0, [sp]
5428: 1a00000e bne 5468 <rtems_termios_read+0x74>
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
542c: e59420cc ldr r2, [r4, #204] ; 0xcc
5430: e59f3358 ldr r3, [pc, #856] ; 5790 <rtems_termios_read+0x39c>
5434: e0833282 add r3, r3, r2, lsl #5
5438: e5933008 ldr r3, [r3, #8]
543c: e3530000 cmp r3, #0
5440: 0a00000b beq 5474 <rtems_termios_read+0x80>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
5444: e1a00004 mov r0, r4
5448: e1a01009 mov r1, r9
544c: e1a0e00f mov lr, pc
5450: e12fff13 bx r3
tty->tty_rcvwakeup = 0;
5454: e3a03000 mov r3, #0
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
5458: e58d0000 str r0, [sp]
tty->tty_rcvwakeup = 0;
545c: e58430e4 str r3, [r4, #228] ; 0xe4
rtems_semaphore_release (tty->isem);
5460: e5940014 ldr r0, [r4, #20]
5464: eb0004ab bl 6718 <rtems_semaphore_release>
} args->bytes_moved = args->count - count; tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); return sc; }
5468: e59d0000 ldr r0, [sp]
546c: e28dd008 add sp, sp, #8
5470: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
5474: e5942024 ldr r2, [r4, #36] ; 0x24
5478: e5943020 ldr r3, [r4, #32]
547c: e1520003 cmp r2, r3
5480: 0a000018 beq 54e8 <rtems_termios_read+0xf4>
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
5484: e3580000 cmp r8, #0
5488: 0a00000e beq 54c8 <rtems_termios_read+0xd4>
548c: e2842020 add r2, r4, #32
5490: e892000c ldm r2, {r2, r3}
5494: e1530002 cmp r3, r2
5498: ba000003 blt 54ac <rtems_termios_read+0xb8>
549c: ea000009 b 54c8 <rtems_termios_read+0xd4>
54a0: e5942020 ldr r2, [r4, #32]
54a4: e1520003 cmp r2, r3
54a8: da000006 ble 54c8 <rtems_termios_read+0xd4>
*buffer++ = tty->cbuf[tty->cindex++];
54ac: e594201c ldr r2, [r4, #28]
54b0: e7d22003 ldrb r2, [r2, r3]
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
54b4: e2588001 subs r8, r8, #1
*buffer++ = tty->cbuf[tty->cindex++];
54b8: e2833001 add r3, r3, #1
54bc: e4ca2001 strb r2, [sl], #1
54c0: e5843024 str r3, [r4, #36] ; 0x24
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
54c4: 1afffff5 bne 54a0 <rtems_termios_read+0xac>
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
54c8: e5993010 ldr r3, [r9, #16]
54cc: e0688003 rsb r8, r8, r3
tty->tty_rcvwakeup = 0;
54d0: e3a03000 mov r3, #0
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
54d4: e5898018 str r8, [r9, #24]
tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem);
54d8: e5940014 ldr r0, [r4, #20]
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
tty->tty_rcvwakeup = 0;
54dc: e58430e4 str r3, [r4, #228] ; 0xe4
rtems_semaphore_release (tty->isem);
54e0: eb00048c bl 6718 <rtems_semaphore_release>
return sc;
54e4: eaffffdf b 5468 <rtems_termios_read+0x74>
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL &&
54e8: e59430a0 ldr r3, [r4, #160] ; 0xa0
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
54ec: e59d1000 ldr r1, [sp]
tty->read_start_column = tty->column;
54f0: e5942028 ldr r2, [r4, #40] ; 0x28
if (tty->device.pollRead != NULL &&
54f4: e3530000 cmp r3, #0
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
54f8: e5841020 str r1, [r4, #32]
54fc: e5841024 str r1, [r4, #36] ; 0x24
tty->read_start_column = tty->column;
5500: e584202c str r2, [r4, #44] ; 0x2c
if (tty->device.pollRead != NULL &&
5504: 0a000002 beq 5514 <rtems_termios_read+0x120>
5508: e59420b4 ldr r2, [r4, #180] ; 0xb4
550c: e3520000 cmp r2, #0
5510: 0a000063 beq 56a4 <rtems_termios_read+0x2b0>
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
5514: e5946074 ldr r6, [r4, #116] ; 0x74
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
5518: e59f7274 ldr r7, [pc, #628] ; 5794 <rtems_termios_read+0x3a0>
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
551c: e59fb274 ldr fp, [pc, #628] ; 5798 <rtems_termios_read+0x3a4>
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
rtems_status_code sc;
int wait = 1;
5520: e3a05001 mov r5, #1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
5524: e594205c ldr r2, [r4, #92] ; 0x5c
5528: e5943060 ldr r3, [r4, #96] ; 0x60
552c: e1520003 cmp r2, r3
5530: 0a000046 beq 5650 <rtems_termios_read+0x25c>
(tty->ccount < (CBUFSIZE-1))) {
5534: e5973008 ldr r3, [r7, #8]
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
5538: e5942020 ldr r2, [r4, #32]
(tty->ccount < (CBUFSIZE-1))) {
553c: e2433001 sub r3, r3, #1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
5540: e1520003 cmp r2, r3
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)(
5544: 32843049 addcc r3, r4, #73 ; 0x49
5548: 358d3004 strcc r3, [sp, #4]
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
554c: 3a00000d bcc 5588 <rtems_termios_read+0x194>
5550: ea00003e b 5650 <rtems_termios_read+0x25c> <== NOT EXECUTED
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
5554: ebffff5d bl 52d0 <siproc>
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
5558: e594205c ldr r2, [r4, #92] ; 0x5c
555c: e5943060 ldr r3, [r4, #96] ; 0x60
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
5560: e3500000 cmp r0, #0
5564: 13a05000 movne r5, #0
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
5568: e1520003 cmp r2, r3
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
556c: e5946070 ldr r6, [r4, #112] ; 0x70
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
5570: 0a000036 beq 5650 <rtems_termios_read+0x25c>
(tty->ccount < (CBUFSIZE-1))) {
5574: e5973008 ldr r3, [r7, #8]
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
5578: e5942020 ldr r2, [r4, #32]
(tty->ccount < (CBUFSIZE-1))) {
557c: e2433001 sub r3, r3, #1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
5580: e1520003 cmp r2, r3
5584: 2a000031 bcs 5650 <rtems_termios_read+0x25c>
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
5588: e594005c ldr r0, [r4, #92] ; 0x5c
558c: e5941064 ldr r1, [r4, #100] ; 0x64
5590: e2800001 add r0, r0, #1
5594: eb0044ca bl 168c4 <__umodsi3>
c = tty->rawInBuf.theBuf[newHead];
5598: e5943058 ldr r3, [r4, #88] ; 0x58
559c: e7d36000 ldrb r6, [r3, r0]
tty->rawInBuf.Head = newHead;
55a0: e584005c str r0, [r4, #92] ; 0x5c
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
55a4: e5943060 ldr r3, [r4, #96] ; 0x60
55a8: e5942064 ldr r2, [r4, #100] ; 0x64
55ac: e0823003 add r3, r2, r3
% tty->rawInBuf.Size)
55b0: e0600003 rsb r0, r0, r3
55b4: e5941064 ldr r1, [r4, #100] ; 0x64
55b8: eb0044c1 bl 168c4 <__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)
55bc: e59430bc ldr r3, [r4, #188] ; 0xbc
55c0: e1500003 cmp r0, r3
55c4: 2a000012 bcs 5614 <rtems_termios_read+0x220>
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
55c8: e59430b8 ldr r3, [r4, #184] ; 0xb8
55cc: e3c33001 bic r3, r3, #1
55d0: e58430b8 str r3, [r4, #184] ; 0xb8
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
55d4: e59f31bc ldr r3, [pc, #444] ; 5798 <rtems_termios_read+0x3a4>
55d8: e59420b8 ldr r2, [r4, #184] ; 0xb8
55dc: e0023003 and r3, r2, r3
55e0: e153000b cmp r3, fp
55e4: 0a000022 beq 5674 <rtems_termios_read+0x280>
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
55e8: e59430b8 ldr r3, [r4, #184] ; 0xb8
55ec: e3130c01 tst r3, #256 ; 0x100
55f0: 0a000007 beq 5614 <rtems_termios_read+0x220>
tty->flow_ctrl &= ~FL_IRTSOFF;
55f4: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
55f8: e59430b0 ldr r3, [r4, #176] ; 0xb0 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
tty->flow_ctrl &= ~FL_IRTSOFF;
55fc: e3c22004 bic r2, r2, #4 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
5600: e3530000 cmp r3, #0 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
tty->flow_ctrl &= ~FL_IRTSOFF;
5604: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
tty->device.startRemoteTx(tty->minor);
5608: 15940010 ldrne r0, [r4, #16] <== NOT EXECUTED
560c: 11a0e00f movne lr, pc <== NOT EXECUTED
5610: 112fff13 bxne r3 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
5614: e594303c ldr r3, [r4, #60] ; 0x3c
5618: e3130002 tst r3, #2
if (siproc (c, tty))
561c: e1a00006 mov r0, r6
5620: e1a01004 mov r1, r4
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
5624: 1affffca bne 5554 <rtems_termios_read+0x160>
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
5628: ebffff28 bl 52d0 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
562c: e5d43047 ldrb r3, [r4, #71] ; 0x47 <== NOT EXECUTED
5630: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
wait = 0;
5634: e1520003 cmp r2, r3 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
5638: e594205c ldr r2, [r4, #92] ; 0x5c <== NOT EXECUTED
563c: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
5640: a3a05000 movge r5, #0 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
5644: e1520003 cmp r2, r3 <== NOT EXECUTED
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
5648: e5946070 ldr r6, [r4, #112] ; 0x70 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
564c: 1affffc8 bne 5574 <rtems_termios_read+0x180> <== NOT EXECUTED
}
/*
* Wait for characters
*/
if ( wait ) {
5650: e3550000 cmp r5, #0
5654: 0affff8a beq 5484 <rtems_termios_read+0x90>
sc = rtems_semaphore_obtain(
5658: e2840068 add r0, r4, #104 ; 0x68
565c: e8900003 ldm r0, {r0, r1}
5660: e1a02006 mov r2, r6
5664: eb0003e2 bl 65f4 <rtems_semaphore_obtain>
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
5668: e3500000 cmp r0, #0
566c: 0affffac beq 5524 <rtems_termios_read+0x130>
5670: eaffff83 b 5484 <rtems_termios_read+0x90> <== NOT EXECUTED
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
5674: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
5678: e3530000 cmp r3, #0 <== NOT EXECUTED
567c: 0a000002 beq 568c <rtems_termios_read+0x298> <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
5680: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
5684: e3130020 tst r3, #32 <== NOT EXECUTED
5688: 0affffd6 beq 55e8 <rtems_termios_read+0x1f4> <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
568c: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
5690: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
5694: e3a02001 mov r2, #1 <== NOT EXECUTED
5698: e1a0e00f mov lr, pc <== NOT EXECUTED
569c: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
56a0: eaffffdb b 5614 <rtems_termios_read+0x220> <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
56a4: e594203c ldr r2, [r4, #60] ; 0x3c
56a8: e3120002 tst r2, #2
56ac: 0a00000b beq 56e0 <rtems_termios_read+0x2ec>
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
56b0: e5940010 ldr r0, [r4, #16]
56b4: e1a0e00f mov lr, pc
56b8: e12fff13 bx r3
if (n < 0) {
56bc: e3500000 cmp r0, #0
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
56c0: e1a01004 mov r1, r4
56c4: e20000ff and r0, r0, #255 ; 0xff
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
56c8: ba00002c blt 5780 <rtems_termios_read+0x38c>
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
56cc: ebfffeff bl 52d0 <siproc>
56d0: e3500000 cmp r0, #0
56d4: 1affff6a bne 5484 <rtems_termios_read+0x90>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
56d8: e59430a0 ldr r3, [r4, #160] ; 0xa0
56dc: eafffff3 b 56b0 <rtems_termios_read+0x2bc>
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
56e0: eb000226 bl 5f80 <rtems_clock_get_ticks_since_boot>
56e4: e1a05000 mov r5, r0
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
56e8: e5940010 ldr r0, [r4, #16]
56ec: e1a0e00f mov lr, pc
56f0: e594f0a0 ldr pc, [r4, #160] ; 0xa0
if (n < 0) {
56f4: e3500000 cmp r0, #0
56f8: ba00000c blt 5730 <rtems_termios_read+0x33c>
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
56fc: e20000ff and r0, r0, #255 ; 0xff
5700: e1a01004 mov r1, r4
5704: ebfffef1 bl 52d0 <siproc>
if (tty->ccount >= tty->termios.c_cc[VMIN])
5708: e5d43047 ldrb r3, [r4, #71] ; 0x47
570c: e5942020 ldr r2, [r4, #32]
5710: e1520003 cmp r2, r3
5714: aaffff5a bge 5484 <rtems_termios_read+0x90>
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
5718: e3530000 cmp r3, #0
571c: 0afffff1 beq 56e8 <rtems_termios_read+0x2f4>
5720: e5d43046 ldrb r3, [r4, #70] ; 0x46
5724: e3530000 cmp r3, #0
5728: 0affffee beq 56e8 <rtems_termios_read+0x2f4>
572c: eaffffeb b 56e0 <rtems_termios_read+0x2ec>
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
5730: e5d43047 ldrb r3, [r4, #71] ; 0x47
5734: e3530000 cmp r3, #0
if (tty->termios.c_cc[VTIME] && tty->ccount) {
5738: e5d43046 ldrb r3, [r4, #70] ; 0x46
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
573c: 0a000007 beq 5760 <rtems_termios_read+0x36c>
if (tty->termios.c_cc[VTIME] && tty->ccount) {
5740: e3530000 cmp r3, #0
5744: 0a000002 beq 5754 <rtems_termios_read+0x360>
5748: e5943020 ldr r3, [r4, #32]
574c: e3530000 cmp r3, #0
5750: 1a000004 bne 5768 <rtems_termios_read+0x374>
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
5754: e3a00001 mov r0, #1
5758: eb0004f5 bl 6b34 <rtems_task_wake_after>
575c: eaffffe1 b 56e8 <rtems_termios_read+0x2f4>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
5760: e3530000 cmp r3, #0
5764: 0affff46 beq 5484 <rtems_termios_read+0x90>
break;
now = rtems_clock_get_ticks_since_boot();
5768: eb000204 bl 5f80 <rtems_clock_get_ticks_since_boot>
if ((now - then) > tty->vtimeTicks) {
576c: e5943054 ldr r3, [r4, #84] ; 0x54
5770: e0650000 rsb r0, r5, r0
5774: e1500003 cmp r0, r3
5778: 9afffff5 bls 5754 <rtems_termios_read+0x360>
577c: eaffff40 b 5484 <rtems_termios_read+0x90>
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
rtems_task_wake_after (1);
5780: e3a00001 mov r0, #1
5784: eb0004ea bl 6b34 <rtems_task_wake_after>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
5788: e59430a0 ldr r3, [r4, #160] ; 0xa0
578c: eaffffc7 b 56b0 <rtems_termios_read+0x2bc>
00003e4c <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))
3e4c: e59020b8 ldr r2, [r0, #184] ; 0xb8
3e50: e59f31dc ldr r3, [pc, #476] ; 4034 <rtems_termios_refill_transmitter+0x1e8>
3e54: e0023003 and r3, r2, r3
3e58: e59f21d8 ldr r2, [pc, #472] ; 4038 <rtems_termios_refill_transmitter+0x1ec>
3e5c: 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)
{
3e60: e92d4070 push {r4, r5, r6, lr}
3e64: 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))
3e68: 0a000047 beq 3f8c <rtems_termios_refill_transmitter+0x140>
tty->flow_ctrl |= FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
3e6c: e59030b8 ldr r3, [r0, #184] ; 0xb8
3e70: e2033003 and r3, r3, #3
3e74: e3530002 cmp r3, #2
3e78: 0a000055 beq 3fd4 <rtems_termios_refill_transmitter+0x188>
tty->flow_ctrl &= ~FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
3e7c: e5902080 ldr r2, [r0, #128] ; 0x80
3e80: e5903084 ldr r3, [r0, #132] ; 0x84
3e84: e1520003 cmp r2, r3
3e88: 0a000029 beq 3f34 <rtems_termios_refill_transmitter+0xe8>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3e8c: e10f3000 mrs r3, CPSR
3e90: e3832080 orr r2, r3, #128 ; 0x80
3e94: e129f002 msr CPSR_fc, r2
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
tty->t_dqlen = 0;
3e98: e3a02000 mov r2, #0
}
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
3e9c: e5900090 ldr r0, [r0, #144] ; 0x90
tty->t_dqlen = 0;
3ea0: e5842090 str r2, [r4, #144] ; 0x90
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3ea4: e129f003 msr CPSR_fc, r3
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
3ea8: e5943084 ldr r3, [r4, #132] ; 0x84
3eac: e5941088 ldr r1, [r4, #136] ; 0x88
3eb0: e0800003 add r0, r0, r3
3eb4: eb004a82 bl 168c4 <__umodsi3>
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
3eb8: e5943094 ldr r3, [r4, #148] ; 0x94
3ebc: 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;
3ec0: e1a05000 mov r5, r0
tty->rawOutBuf.Tail = newTail;
3ec4: e5840084 str r0, [r4, #132] ; 0x84
if (tty->rawOutBufState == rob_wait) {
3ec8: 0a00002c beq 3f80 <rtems_termios_refill_transmitter+0x134>
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
if (newTail == tty->rawOutBuf.Head) {
3ecc: e5943080 ldr r3, [r4, #128] ; 0x80
3ed0: e1530005 cmp r3, r5
3ed4: 0a00001e beq 3f54 <rtems_termios_refill_transmitter+0x108>
if ( tty->tty_snd.sw_pfn != NULL) {
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
3ed8: e59430b8 ldr r3, [r4, #184] ; 0xb8
3edc: e2033e21 and r3, r3, #528 ; 0x210
3ee0: e3530e21 cmp r3, #528 ; 0x210
3ee4: 0a000047 beq 4008 <rtems_termios_refill_transmitter+0x1bc>
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
3ee8: e5943080 ldr r3, [r4, #128] ; 0x80
3eec: e1550003 cmp r5, r3
nToSend = tty->rawOutBuf.Size - newTail;
3ef0: 85946088 ldrhi r6, [r4, #136] ; 0x88
else
nToSend = tty->rawOutBuf.Head - newTail;
3ef4: 95946080 ldrls r6, [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)) {
3ef8: e59430b8 ldr r3, [r4, #184] ; 0xb8
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
3efc: e594107c ldr r1, [r4, #124] ; 0x7c
else
nToSend = tty->rawOutBuf.Head - newTail;
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
3f00: e3130c06 tst r3, #1536 ; 0x600
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
3f04: e0656006 rsb r6, r5, r6
/* 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;
}
tty->rawOutBufState = rob_busy; /*apm*/
3f08: e3a03001 mov r3, #1
else
nToSend = tty->rawOutBuf.Head - newTail;
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
3f0c: 13a06001 movne r6, #1
nToSend = 1;
3f10: e1a02006 mov r2, r6
}
tty->rawOutBufState = rob_busy; /*apm*/
3f14: e5843094 str r3, [r4, #148] ; 0x94
(*tty->device.write)(
3f18: e5940010 ldr r0, [r4, #16]
3f1c: e0811005 add r1, r1, r5
3f20: e1a0e00f mov lr, pc
3f24: e594f0a4 ldr pc, [r4, #164] ; 0xa4
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
3f28: e5845084 str r5, [r4, #132] ; 0x84
} return nToSend; }
3f2c: e1a00006 mov r0, r6
3f30: e8bd8070 pop {r4, r5, r6, pc}
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
3f34: e5903094 ldr r3, [r0, #148] ; 0x94
3f38: e3530002 cmp r3, #2
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
3f3c: 13a06000 movne r6, #0
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
3f40: 1afffff9 bne 3f2c <rtems_termios_refill_transmitter+0xe0>
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
3f44: e590008c ldr r0, [r0, #140] ; 0x8c <== NOT EXECUTED
3f48: eb0009f2 bl 6718 <rtems_semaphore_release> <== NOT EXECUTED
}
return 0;
3f4c: e3a06000 mov r6, #0 <== NOT EXECUTED
3f50: eafffff5 b 3f2c <rtems_termios_refill_transmitter+0xe0> <== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
3f54: e59430d4 ldr r3, [r4, #212] ; 0xd4
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
3f58: e3a06000 mov r6, #0
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
3f5c: e1530006 cmp r3, r6
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
3f60: e5846094 str r6, [r4, #148] ; 0x94
nToSend = 0;
3f64: 01a06003 moveq r6, r3
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
3f68: 0affffee beq 3f28 <rtems_termios_refill_transmitter+0xdc>
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
3f6c: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED
3f70: e59410d8 ldr r1, [r4, #216] ; 0xd8 <== NOT EXECUTED
3f74: e1a0e00f mov lr, pc <== NOT EXECUTED
3f78: e12fff13 bx r3 <== NOT EXECUTED
3f7c: eaffffe9 b 3f28 <rtems_termios_refill_transmitter+0xdc> <== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
3f80: e594008c ldr r0, [r4, #140] ; 0x8c
3f84: eb0009e3 bl 6718 <rtems_semaphore_release>
3f88: eaffffcf b 3ecc <rtems_termios_refill_transmitter+0x80>
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
3f8c: e284104a add r1, r4, #74 ; 0x4a <== NOT EXECUTED
3f90: e3a02001 mov r2, #1 <== NOT EXECUTED
3f94: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
3f98: e1a0e00f mov lr, pc <== NOT EXECUTED
3f9c: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3fa0: e10f3000 mrs r3, CPSR <== NOT EXECUTED
3fa4: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
3fa8: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->t_dqlen--;
3fac: e5941090 ldr r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
3fb0: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
3fb4: e2411001 sub r1, r1, #1 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
3fb8: e3822002 orr r2, r2, #2 <== NOT EXECUTED
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
3fbc: e5841090 str r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
3fc0: e58420b8 str r2, [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 (
3fc4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
3fc8: e3a06001 mov r6, #1 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
3fcc: e1a00006 mov r0, r6 <== NOT EXECUTED
3fd0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
* FIXME: this .write call will generate another
* dequeue callback. This will advance the "Tail" in the data
* buffer, although the corresponding data is not yet out!
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
3fd4: e2841049 add r1, r4, #73 ; 0x49 <== NOT EXECUTED
3fd8: e3a02001 mov r2, #1 <== NOT EXECUTED
3fdc: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
3fe0: e1a0e00f mov lr, pc <== NOT EXECUTED
3fe4: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
3fe8: e10f3000 mrs r3, CPSR <== NOT EXECUTED
3fec: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
3ff0: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->t_dqlen--;
3ff4: e5941090 ldr r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
3ff8: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
3ffc: e2411001 sub r1, r1, #1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
4000: e3c22002 bic r2, r2, #2 <== NOT EXECUTED
4004: eaffffec b 3fbc <rtems_termios_refill_transmitter+0x170> <== NOT EXECUTED
4008: e10f3000 mrs r3, CPSR <== NOT EXECUTED
400c: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
4010: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
tty->flow_ctrl |= FL_OSTOP;
4014: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
4018: e3822020 orr r2, r2, #32 <== NOT EXECUTED
401c: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
4020: e3a02001 mov r2, #1 <== NOT EXECUTED
4024: e5842094 str r2, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
4028: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 0;
402c: e3a06000 mov r6, #0 <== NOT EXECUTED
4030: eaffffbc b 3f28 <rtems_termios_refill_transmitter+0xdc> <== NOT EXECUTED
00005a88 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
5a88: e92d4030 push {r4, r5, lr}
5a8c: e1a04000 mov r4, r0
5a90: e24dd008 sub sp, sp, #8
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
5a94: e3a05000 mov r5, #0
5a98: ea000005 b 5ab4 <rtems_termios_rxdaemon+0x2c>
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
5a9c: e5940010 ldr r0, [r4, #16]
5aa0: e1a0e00f mov lr, pc
5aa4: e594f0a0 ldr pc, [r4, #160] ; 0xa0
if (c != EOF) {
5aa8: e3700001 cmn r0, #1
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
5aac: e1a03000 mov r3, r0
if (c != EOF) {
5ab0: 1a000010 bne 5af8 <rtems_termios_rxdaemon+0x70>
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
5ab4: e1a0300d mov r3, sp
5ab8: e3a01002 mov r1, #2
5abc: e3a02000 mov r2, #0
5ac0: e3a00003 mov r0, #3
5ac4: eb00014d bl 6000 <rtems_event_receive>
(TERMIOS_RX_PROC_EVENT | TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
5ac8: e59d3000 ldr r3, [sp]
5acc: e3130001 tst r3, #1
5ad0: 0afffff1 beq 5a9c <rtems_termios_rxdaemon+0x14>
tty->rxTaskId = 0;
5ad4: e58450c4 str r5, [r4, #196] ; 0xc4 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
5ad8: e3a00000 mov r0, #0 <== NOT EXECUTED
5adc: eb00039e bl 695c <rtems_task_delete> <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
5ae0: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
5ae4: e1a0e00f mov lr, pc <== NOT EXECUTED
5ae8: e594f0a0 ldr pc, [r4, #160] ; 0xa0 <== NOT EXECUTED
if (c != EOF) {
5aec: e3700001 cmn r0, #1 <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
5af0: e1a03000 mov r3, r0 <== NOT EXECUTED
if (c != EOF) {
5af4: 0affffee beq 5ab4 <rtems_termios_rxdaemon+0x2c> <== NOT EXECUTED
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
5af8: e1a00004 mov r0, r4
5afc: e28d1007 add r1, sp, #7
5b00: e3a02001 mov r2, #1
c = tty->device.pollRead(tty->minor);
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
5b04: e5cd3007 strb r3, [sp, #7]
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
5b08: ebffff26 bl 57a8 <rtems_termios_enqueue_raw_characters>
5b0c: eaffffe8 b 5ab4 <rtems_termios_rxdaemon+0x2c>
0000403c <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
403c: e92d4070 push {r4, r5, r6, lr}
4040: e59f5060 ldr r5, [pc, #96] ; 40a8 <rtems_termios_txdaemon+0x6c>
4044: e24dd004 sub sp, sp, #4
4048: e1a04000 mov r4, r0
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
404c: e3a06000 mov r6, #0
4050: ea000008 b 4078 <rtems_termios_txdaemon+0x3c>
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
4054: e59430cc ldr r3, [r4, #204] ; 0xcc
4058: e0853283 add r3, r5, r3, lsl #5
405c: e5933014 ldr r3, [r3, #20]
4060: e3530000 cmp r3, #0
rtems_termios_linesw[tty->t_line].l_start(tty);
4064: e1a00004 mov r0, r4
4068: 11a0e00f movne lr, pc
406c: 112fff13 bxne r3
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
4070: e1a00004 mov r0, r4
4074: ebffff74 bl 3e4c <rtems_termios_refill_transmitter>
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
4078: e1a0300d mov r3, sp
407c: e3a01002 mov r1, #2
4080: e3a02000 mov r2, #0
4084: e3a00003 mov r0, #3
4088: eb0007dc bl 6000 <rtems_event_receive>
(TERMIOS_TX_START_EVENT | TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
408c: e59d3000 ldr r3, [sp]
4090: e3130001 tst r3, #1
4094: 0affffee beq 4054 <rtems_termios_txdaemon+0x18>
tty->txTaskId = 0;
4098: e58460c8 str r6, [r4, #200] ; 0xc8 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
409c: e3a00000 mov r0, #0 <== NOT EXECUTED
40a0: eb000a2d bl 695c <rtems_task_delete> <== NOT EXECUTED
40a4: eaffffea b 4054 <rtems_termios_txdaemon+0x18> <== NOT EXECUTED
0000532c <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;
532c: e5903000 ldr r3, [r0]
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
5330: e92d41f0 push {r4, r5, r6, r7, r8, lr}
rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
5334: e593402c ldr r4, [r3, #44] ; 0x2c
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
5338: e3a01000 mov r1, #0
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
533c: e1a05000 mov r5, r0
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
5340: e1a02001 mov r2, r1
5344: e5940018 ldr r0, [r4, #24]
5348: eb0004a9 bl 65f4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
534c: e2506000 subs r6, r0, #0
5350: 1a00000c bne 5388 <rtems_termios_write+0x5c>
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
5354: e59420cc ldr r2, [r4, #204] ; 0xcc
5358: e59f3090 ldr r3, [pc, #144] ; 53f0 <rtems_termios_write+0xc4>
535c: e0833282 add r3, r3, r2, lsl #5
5360: e593300c ldr r3, [r3, #12]
5364: e3530000 cmp r3, #0
5368: 0a000008 beq 5390 <rtems_termios_write+0x64>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
536c: e1a00004 mov r0, r4
5370: e1a01005 mov r1, r5
5374: e1a0e00f mov lr, pc
5378: e12fff13 bx r3
537c: e1a06000 mov r6, r0
rtems_semaphore_release (tty->osem);
5380: e5940018 ldr r0, [r4, #24]
5384: eb0004e3 bl 6718 <rtems_semaphore_release>
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
}
rtems_semaphore_release (tty->osem);
return sc;
}
5388: e1a00006 mov r0, r6
538c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
5390: e5943034 ldr r3, [r4, #52] ; 0x34
5394: e3130001 tst r3, #1
5398: 0a00000f beq 53dc <rtems_termios_write+0xb0>
uint32_t count = args->count;
539c: e5957010 ldr r7, [r5, #16]
char *buffer = args->buffer;
while (count--)
53a0: e3570000 cmp r7, #0
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
53a4: e595800c ldr r8, [r5, #12]
while (count--)
53a8: 01a03006 moveq r3, r6
53ac: 0a000005 beq 53c8 <rtems_termios_write+0x9c>
oproc (*buffer++, tty);
53b0: e4d80001 ldrb r0, [r8], #1
53b4: e1a01004 mov r1, r4
53b8: ebfffe4d bl 4cf4 <oproc>
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
53bc: e2577001 subs r7, r7, #1
53c0: 1afffffa bne 53b0 <rtems_termios_write+0x84>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
53c4: e5953010 ldr r3, [r5, #16]
53c8: e5853018 str r3, [r5, #24]
} rtems_semaphore_release (tty->osem);
53cc: e5940018 ldr r0, [r4, #24]
53d0: eb0004d0 bl 6718 <rtems_semaphore_release>
return sc; }
53d4: e1a00006 mov r0, r6
53d8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
53dc: e285000c add r0, r5, #12 <== NOT EXECUTED
53e0: e8900003 ldm r0, {r0, r1} <== NOT EXECUTED
53e4: e1a02004 mov r2, r4 <== NOT EXECUTED
53e8: ebfffdfb bl 4bdc <rtems_termios_puts> <== NOT EXECUTED
53ec: eafffff4 b 53c4 <rtems_termios_write+0x98> <== NOT EXECUTED
000022f8 <rtems_verror>:
{
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
22f8: e3100202 tst r0, #536870912 ; 0x20000000
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
22fc: e92d41f0 push {r4, r5, r6, r7, r8, lr}
2300: e1a04000 mov r4, r0
2304: e1a08001 mov r8, r1
2308: e1a06002 mov r6, r2
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
230c: 0a00000d beq 2348 <rtems_verror+0x50>
if (rtems_panic_in_progress++)
2310: e59f212c ldr r2, [pc, #300] ; 2444 <rtems_verror+0x14c>
2314: e5921000 ldr r1, [r2]
2318: e2813001 add r3, r1, #1
231c: e3510000 cmp r1, #0
2320: e5823000 str r3, [r2]
2324: 0a000004 beq 233c <rtems_verror+0x44>
*
* 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;
2328: e59f3118 ldr r3, [pc, #280] ; 2448 <rtems_verror+0x150> <== NOT EXECUTED
232c: e5931000 ldr r1, [r3] <== NOT EXECUTED
++level;
2330: e2811001 add r1, r1, #1 <== NOT EXECUTED
_Thread_Dispatch_disable_level = level;
2334: e5831000 str r1, [r3] <== NOT EXECUTED
void _Thread_Disable_dispatch( void );
#else
RTEMS_INLINE_ROUTINE void _Thread_Disable_dispatch( void )
{
_Thread_Dispatch_increment_disable_level();
RTEMS_COMPILER_MEMORY_BARRIER();
2338: e5923000 ldr r3, [r2] <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
233c: e3530002 cmp r3, #2
return 0;
2340: c3a06000 movgt r6, #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)
2344: ca000024 bgt 23dc <rtems_verror+0xe4>
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
2348: e59f50fc ldr r5, [pc, #252] ; 244c <rtems_verror+0x154>
234c: e5953000 ldr r3, [r5]
2350: e5930008 ldr r0, [r3, #8]
2354: eb002e20 bl dbdc <fflush>
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
2358: e2147101 ands r7, r4, #1073741824 ; 0x40000000
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
235c: e3c44207 bic r4, r4, #1879048192 ; 0x70000000
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
2360: 1a00002a bne 2410 <rtems_verror+0x118>
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
2364: e5953000 ldr r3, [r5]
2368: e1a02006 mov r2, r6
236c: e1a01008 mov r1, r8
2370: e593000c ldr r0, [r3, #12]
2374: eb0042e9 bl 12f20 <vfprintf>
if (status)
2378: e3540000 cmp r4, #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);
237c: e1a06000 mov r6, r0
if (status)
2380: 1a000017 bne 23e4 <rtems_verror+0xec>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
2384: e3570000 cmp r7, #0
2388: 0a00000b beq 23bc <rtems_verror+0xc4>
if ((local_errno > 0) && *strerror(local_errno))
238c: da000004 ble 23a4 <rtems_verror+0xac>
2390: e1a00007 mov r0, r7
2394: eb0032c8 bl eebc <strerror>
2398: e5d03000 ldrb r3, [r0]
239c: e3530000 cmp r3, #0
23a0: 1a00001d bne 241c <rtems_verror+0x124>
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
23a4: e5953000 ldr r3, [r5]
23a8: e59f10a0 ldr r1, [pc, #160] ; 2450 <rtems_verror+0x158>
23ac: e593000c ldr r0, [r3, #12]
23b0: e1a02007 mov r2, r7
23b4: eb002ef5 bl df90 <fprintf>
23b8: e0866000 add r6, r6, r0
}
chars_written += fprintf(stderr, "\n");
23bc: e5953000 ldr r3, [r5]
23c0: e59f108c ldr r1, [pc, #140] ; 2454 <rtems_verror+0x15c>
23c4: e593000c ldr r0, [r3, #12]
23c8: eb002ef0 bl df90 <fprintf>
(void) fflush(stderr);
23cc: 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");
23d0: e0806006 add r6, r0, r6
(void) fflush(stderr);
23d4: e593000c ldr r0, [r3, #12]
23d8: eb002dff bl dbdc <fflush>
return chars_written;
}
23dc: e1a00006 mov r0, r6
23e0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
23e4: e59f3060 ldr r3, [pc, #96] ; 244c <rtems_verror+0x154>
23e8: e5933000 ldr r3, [r3]
23ec: e1a00004 mov r0, r4
23f0: e593400c ldr r4, [r3, #12]
23f4: ebffffbb bl 22e8 <rtems_status_text>
23f8: e59f1058 ldr r1, [pc, #88] ; 2458 <rtems_verror+0x160>
23fc: e1a02000 mov r2, r0
2400: e1a00004 mov r0, r4
2404: eb002ee1 bl df90 <fprintf>
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
2408: e0866000 add r6, r6, r0
240c: eaffffdc b 2384 <rtems_verror+0x8c>
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
local_errno = errno;
2410: eb002cf4 bl d7e8 <__errno>
2414: e5907000 ldr r7, [r0]
2418: eaffffd1 b 2364 <rtems_verror+0x6c>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
if ((local_errno > 0) && *strerror(local_errno))
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
241c: e5953000 ldr r3, [r5]
2420: e1a00007 mov r0, r7
2424: e593400c ldr r4, [r3, #12]
2428: eb0032a3 bl eebc <strerror>
242c: e59f1028 ldr r1, [pc, #40] ; 245c <rtems_verror+0x164>
2430: e1a02000 mov r2, r0
2434: e1a00004 mov r0, r4
2438: eb002ed4 bl df90 <fprintf>
243c: e0866000 add r6, r6, r0
2440: eaffffdd b 23bc <rtems_verror+0xc4>
00023434 <scanInt>:
/**
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
23434: 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;
23438: e3a06000 mov r6, #0
int d;
for (;;) {
c = getc(fp);
2343c: e59f90f4 ldr r9, [pc, #244] ; 23538 <scanInt+0x104>
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
23440: e59f80f4 ldr r8, [pc, #244] ; 2353c <scanInt+0x108>
return 0;
d = c - '0';
if ((i > (limit / 10))
23444: e59fa0f4 ldr sl, [pc, #244] ; 23540 <scanInt+0x10c>
/**
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
23448: e1a04000 mov r4, r0 2344c: e1a0b001 mov fp, r1
int c; unsigned int i = 0; unsigned int limit = INT_MAX;
23450: e3e07102 mvn r7, #-2147483648 ; 0x80000000
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
23454: e1a05006 mov r5, r6
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
23458: e5943004 ldr r3, [r4, #4] 2345c: e2433001 sub r3, r3, #1 23460: e3530000 cmp r3, #0 23464: e5843004 str r3, [r4, #4]
23468: ba00001d blt 234e4 <scanInt+0xb0>
2346c: e5943000 ldr r3, [r4] 23470: e4d30001 ldrb r0, [r3], #1
if (c == ':')
23474: e350003a cmp r0, #58 ; 0x3a
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
23478: e5843000 str r3, [r4]
if (c == ':')
2347c: 0a00001d beq 234f8 <scanInt+0xc4>
break;
if (sign == 0) {
23480: e3560000 cmp r6, #0
23484: 1a000004 bne 2349c <scanInt+0x68>
if (c == '-') {
23488: e350002d cmp r0, #45 ; 0x2d
sign = -1;
limit++;
2348c: 02877001 addeq r7, r7, #1
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
23490: 03e06000 mvneq r6, #0
for (;;) {
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
23494: 0affffef beq 23458 <scanInt+0x24>
sign = -1;
limit++;
continue;
}
sign = 1;
23498: e3a06001 mov r6, #1
}
if (!isdigit(c))
2349c: e5983000 ldr r3, [r8] 234a0: e0833000 add r3, r3, r0 234a4: e5d33001 ldrb r3, [r3, #1] 234a8: e2133004 ands r3, r3, #4
234ac: 0a00001d beq 23528 <scanInt+0xf4>
return 0;
d = c - '0';
if ((i > (limit / 10))
234b0: e083279a umull r2, r3, sl, r7 234b4: e15501a3 cmp r5, r3, lsr #3
234b8: 8a000018 bhi 23520 <scanInt+0xec>
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
234bc: e2400030 sub r0, r0, #48 ; 0x30
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
234c0: e1a03105 lsl r3, r5, #2
234c4: 0a000011 beq 23510 <scanInt+0xdc>
return 0;
i = i * 10 + d;
234c8: e0835005 add r5, r3, r5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
234cc: e5943004 ldr r3, [r4, #4] 234d0: e2433001 sub r3, r3, #1 234d4: e3530000 cmp r3, #0
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
234d8: e0805085 add r5, r0, r5, lsl #1
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
234dc: e5843004 str r3, [r4, #4]
234e0: aaffffe1 bge 2346c <scanInt+0x38>
234e4: e5990000 ldr r0, [r9] <== NOT EXECUTED 234e8: e1a01004 mov r1, r4 <== NOT EXECUTED 234ec: eb005fa9 bl 3b398 <__srget_r> <== NOT EXECUTED
if (c == ':')
234f0: e350003a cmp r0, #58 ; 0x3a <== NOT EXECUTED 234f4: 1affffe1 bne 23480 <scanInt+0x4c> <== NOT EXECUTED
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
234f8: e3560000 cmp r6, #0
234fc: 0a00000b beq 23530 <scanInt+0xfc>
return 0;
*val = i * sign;
23500: e0050596 mul r5, r6, r5
return 1;
23504: e3a00001 mov r0, #1
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
*val = i * sign;
23508: e58b5000 str r5, [fp]
return 1;
2350c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
23510: e0832005 add r2, r3, r5 23514: e0472082 sub r2, r7, r2, lsl #1 23518: e1500002 cmp r0, r2
2351c: 9affffe9 bls 234c8 <scanInt+0x94>
return 0;
23520: e3a00000 mov r0, #0
23524: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
continue;
}
sign = 1;
}
if (!isdigit(c))
return 0;
23528: e1a00003 mov r0, r3
2352c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
23530: e1a00006 mov r0, r6 <== NOT EXECUTED
*val = i * sign; return 1; }
23534: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
00023638 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
23638: e92d4070 push {r4, r5, r6, lr}
2363c: e24dd014 sub sp, sp, #20
23640: e58d2008 str r2, [sp, #8]
23644: e58d3004 str r3, [sp, #4]
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
23648: e3a04000 mov r4, #0 2364c: e28d2008 add r2, sp, #8 23650: e28d3004 add r3, sp, #4
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
23654: e1a05000 mov r5, r0 23658: e1a06001 mov r6, r1
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
2365c: e58d4000 str r4, [sp] 23660: ebffffb7 bl 23544 <scanString> 23664: e3500000 cmp r0, #0
23668: 1a000001 bne 23674 <scangr+0x3c>
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
return 1;
}
2366c: e28dd014 add sp, sp, #20
23670: e8bd8070 pop {r4, r5, r6, pc}
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
23674: e1a00005 mov r0, r5 23678: e2861004 add r1, r6, #4 2367c: e28d2008 add r2, sp, #8 23680: e28d3004 add r3, sp, #4 23684: e58d4000 str r4, [sp] 23688: ebffffad bl 23544 <scanString> 2368c: e3500000 cmp r0, #0
23690: 0afffff5 beq 2366c <scangr+0x34> || !scanInt(fp, &grgid)
23694: e1a00005 mov r0, r5 23698: e28d100c add r1, sp, #12 2369c: ebffff64 bl 23434 <scanInt> 236a0: e3500000 cmp r0, #0
236a4: 0afffff0 beq 2366c <scangr+0x34> || !scanString(fp, &grmem, &buffer, &bufsize, 1))
236a8: e3a04001 mov r4, #1 236ac: e1a00005 mov r0, r5 236b0: e28d1010 add r1, sp, #16 236b4: e28d2008 add r2, sp, #8 236b8: e28d3004 add r3, sp, #4 236bc: e58d4000 str r4, [sp] 236c0: ebffff9f bl 23544 <scanString> 236c4: e3500000 cmp r0, #0
236c8: 0affffe7 beq 2366c <scangr+0x34>
return 0;
grp->gr_gid = grgid;
236cc: e59d300c ldr r3, [sp, #12]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
236d0: e59d1010 ldr r1, [sp, #16]
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
grp->gr_gid = grgid;
236d4: e1c630b8 strh r3, [r6, #8]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
236d8: e5d13000 ldrb r3, [r1] 236dc: e3530000 cmp r3, #0 236e0: 03a04017 moveq r4, #23
236e4: 0a000007 beq 23708 <scangr+0xd0>
236e8: e1a02001 mov r2, r1
if(*cp == ',')
236ec: e353002c cmp r3, #44 ; 0x2c
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
236f0: e5f23001 ldrb r3, [r2, #1]!
if(*cp == ',')
memcount++;
236f4: 02844001 addeq r4, r4, #1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
236f8: e3530000 cmp r3, #0
236fc: 1afffffa bne 236ec <scangr+0xb4>
23700: e1a04104 lsl r4, r4, #2 23704: e2844013 add r4, r4, #19
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
23708: e59d3004 ldr r3, [sp, #4] 2370c: e1530004 cmp r3, r4
return 0;
23710: 33a00000 movcc r0, #0
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
23714: 3affffd4 bcc 2366c <scangr+0x34>
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
23718: e59d3008 ldr r3, [sp, #8] 2371c: e283300f add r3, r3, #15 23720: e3c3300f bic r3, r3, #15 23724: e586300c str r3, [r6, #12]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
23728: e5831000 str r1, [r3]
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2372c: e59d1010 ldr r1, [sp, #16] 23730: e5d13000 ldrb r3, [r1] 23734: e3530000 cmp r3, #0
23738: 0a000011 beq 23784 <scangr+0x14c>
}
/**
* Extract a single group record from the database
*/
static int scangr(
2373c: e2812001 add r2, r1, #1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
23740: e3a00001 mov r0, #1
if(*cp == ',') {
*cp = '\0';
23744: e3a0c000 mov ip, #0
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
if(*cp == ',') {
23748: e353002c cmp r3, #44 ; 0x2c
*cp = '\0';
2374c: 0542c001 strbeq ip, [r2, #-1]
grp->gr_mem[memcount++] = cp + 1;
23750: 0596300c ldreq r3, [r6, #12] 23754: 07832100 streq r2, [r3, r0, lsl #2]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
23758: e5f13001 ldrb r3, [r1, #1]!
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
2375c: 02800001 addeq r0, r0, #1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
23760: e3530000 cmp r3, #0 23764: e2822001 add r2, r2, #1
23768: 1afffff6 bne 23748 <scangr+0x110>
2376c: e1a00100 lsl r0, r0, #2
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
23770: e596300c ldr r3, [r6, #12] 23774: e3a02000 mov r2, #0 23778: e7832000 str r2, [r3, r0]
return 1;
2377c: e3a00001 mov r0, #1 23780: eaffffb9 b 2366c <scangr+0x34>
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
23784: e3a00004 mov r0, #4 <== NOT EXECUTED 23788: eafffff8 b 23770 <scangr+0x138> <== NOT EXECUTED
000052d0 <siproc>:
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
52d0: e591203c ldr r2, [r1, #60] ; 0x3c
52d4: e59f304c ldr r3, [pc, #76] ; 5328 <siproc+0x58>
52d8: e0023003 and r3, r2, r3
52dc: e3530000 cmp r3, #0
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
52e0: e92d4030 push {r4, r5, lr}
52e4: e1a04001 mov r4, r1
52e8: 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)) {
52ec: 1a000001 bne 52f8 <siproc+0x28>
}
else {
i = iproc (c, tty);
}
return i;
}
52f0: 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);
52f4: eaffff81 b 5100 <iproc> <== NOT EXECUTED
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
52f8: e3a01000 mov r1, #0
52fc: e1a02001 mov r2, r1
5300: e5940018 ldr r0, [r4, #24]
5304: eb0004ba bl 65f4 <rtems_semaphore_obtain>
i = iproc (c, tty);
5308: e1a01004 mov r1, r4
530c: e1a00005 mov r0, r5
5310: ebffff7a bl 5100 <iproc>
5314: e1a05000 mov r5, r0
rtems_semaphore_release (tty->osem);
5318: e5940018 ldr r0, [r4, #24]
531c: eb0004fd bl 6718 <rtems_semaphore_release>
}
else {
i = iproc (c, tty);
}
return i;
}
5320: e1a00005 mov r0, r5
5324: e8bd8030 pop {r4, r5, pc}
0000db24 <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 )
{
db24: 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 ) {
db28: e59fc2b8 ldr ip, [pc, #696] ; dde8 <sparse_disk_ioctl+0x2c4>
/*
* ioctl handler to be passed to the block device handler
*/
static int sparse_disk_ioctl( rtems_disk_device *dd, uint32_t req, void *argp )
{
db2c: e24dd018 sub sp, sp, #24
rtems_status_code sc;
rtems_sparse_disk *sd = rtems_disk_get_driver_data( dd );
if ( RTEMS_BLKIO_REQUEST == req ) {
db30: 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 )
{
db34: e58d200c str r2, [sp, #12]
static inline void *rtems_disk_get_driver_data(
const rtems_disk_device *dd
)
{
return dd->driver_data;
db38: e590503c ldr r5, [r0, #60] ; 0x3c
rtems_status_code sc;
rtems_sparse_disk *sd = rtems_disk_get_driver_data( dd );
if ( RTEMS_BLKIO_REQUEST == req ) {
db3c: 0a000013 beq db90 <sparse_disk_ioctl+0x6c>
case RTEMS_BLKDEV_REQ_WRITE:
return sparse_disk_read_write( sd, r, r->req == RTEMS_BLKDEV_REQ_READ );
default:
break;
}
} else if ( RTEMS_BLKIO_DELETED == req ) {
db40: e59fc2a4 ldr ip, [pc, #676] ; ddec <sparse_disk_ioctl+0x2c8>
db44: e151000c cmp r1, ip
db48: 0a000002 beq db58 <sparse_disk_ioctl+0x34>
if ( NULL != sd->delete_handler )
( *sd->delete_handler )( sd );
return 0;
} else {
return rtems_blkdev_ioctl( dd, req, argp );
db4c: eb000c22 bl 10bdc <rtems_blkdev_ioctl>
}
errno = EINVAL;
return -1;
}
db50: e28dd018 add sp, sp, #24
db54: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return sparse_disk_read_write( sd, r, r->req == RTEMS_BLKDEV_REQ_READ );
default:
break;
}
} else if ( RTEMS_BLKIO_DELETED == req ) {
sc = rtems_semaphore_delete( sd->mutex );
db58: e5950000 ldr r0, [r5]
db5c: ebffeb0c bl 8794 <rtems_semaphore_delete>
if ( RTEMS_SUCCESSFUL != sc )
db60: e2504000 subs r4, r0, #0
db64: 1a00009d bne dde0 <sparse_disk_ioctl+0x2bc>
rtems_fatal_error_occurred( 0xdeadbeef );
sd->mutex = RTEMS_ID_NONE;
if ( NULL != sd->delete_handler )
db68: e5953010 ldr r3, [r5, #16]
db6c: e3530000 cmp r3, #0
sc = rtems_semaphore_delete( sd->mutex );
if ( RTEMS_SUCCESSFUL != sc )
rtems_fatal_error_occurred( 0xdeadbeef );
sd->mutex = RTEMS_ID_NONE;
db70: e5854000 str r4, [r5]
if ( NULL != sd->delete_handler )
( *sd->delete_handler )( sd );
return 0;
db74: 01a00003 moveq r0, r3
if ( RTEMS_SUCCESSFUL != sc )
rtems_fatal_error_occurred( 0xdeadbeef );
sd->mutex = RTEMS_ID_NONE;
if ( NULL != sd->delete_handler )
db78: 0afffff4 beq db50 <sparse_disk_ioctl+0x2c>
( *sd->delete_handler )( sd );
db7c: e1a00005 mov r0, r5
db80: e1a0e00f mov lr, pc
db84: e12fff13 bx r3
return 0;
db88: e1a00004 mov r0, r4
db8c: eaffffef b db50 <sparse_disk_ioctl+0x2c>
rtems_sparse_disk *sd = rtems_disk_get_driver_data( dd );
if ( RTEMS_BLKIO_REQUEST == req ) {
rtems_blkdev_request *r = argp;
switch ( r->req ) {
db90: e592a000 ldr sl, [r2]
db94: e35a0001 cmp sl, #1
db98: 8a00008b bhi ddcc <sparse_disk_ioctl+0x2a8>
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 );
db9c: e3a01000 mov r1, #0
dba0: e5950000 ldr r0, [r5]
dba4: 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;
dba8: e3a07000 mov r7, #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 );
dbac: ebffeb21 bl 8838 <rtems_semaphore_obtain>
for ( req_buffer = 0;
dbb0: e58d7008 str r7, [sp, #8]
( 0 <= rv ) && ( req_buffer < req->bufnum );
dbb4: e59dc00c ldr ip, [sp, #12]
dbb8: e59c3010 ldr r3, [ip, #16]
dbbc: e59dc008 ldr ip, [sp, #8]
dbc0: e153000c cmp r3, ip
dbc4: 9a000078 bls ddac <sparse_disk_ioctl+0x288>
++req_buffer ) {
scatter_gather = &req->bufs[req_buffer];
dbc8: e59dc008 ldr ip, [sp, #8]
dbcc: e1a0320c lsl r3, ip, #4
dbd0: e59dc00c ldr ip, [sp, #12]
dbd4: e2833018 add r3, r3, #24
dbd8: e08c2003 add r2, ip, r3
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
buff_size = scatter_gather->length;
dbdc: e5924004 ldr r4, [r2, #4]
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
dbe0: e1e01007 mvn r1, r7
dbe4: e3540000 cmp r4, #0
dbe8: e1a01fa1 lsr r1, r1, #31
dbec: 03a01000 moveq r1, #0
dbf0: e3510000 cmp r1, #0
( 0 <= rv ) && ( req_buffer < req->bufnum );
++req_buffer ) {
scatter_gather = &req->bufs[req_buffer];
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
dbf4: e592b008 ldr fp, [r2, #8]
block = scatter_gather->block;
dbf8: e79c8003 ldr r8, [ip, r3]
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
dbfc: 0a00003b beq dcf0 <sparse_disk_ioctl+0x1cc>
dc00: e3a06000 mov r6, #0
const size_t buffer_size )
{
unsigned int i;
bool block_needs_writing = false;
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
dc04: e1a0900a mov r9, sl
dc08: e1a0a006 mov sl, r6
dc0c: ea00001b b dc80 <sparse_disk_ioctl+0x15c>
const rtems_blkdev_bnum block,
uint8_t *buffer,
const size_t buffer_size )
{
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
dc10: e58d9014 str r9, [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(
dc14: e59fc1d4 ldr ip, [pc, #468] ; ddf0 <sparse_disk_ioctl+0x2cc>
dc18: e5952008 ldr r2, [r5, #8]
dc1c: e5951018 ldr r1, [r5, #24]
dc20: e3a03008 mov r3, #8
dc24: e28d0010 add r0, sp, #16
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;
dc28: e595700c ldr r7, [r5, #12]
if ( buffer_size < bytes_to_copy )
bytes_to_copy = buffer_size;
key = bsearch(
dc2c: e58dc000 str ip, [sp]
dc30: eb002f00 bl 19838 <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;
dc34: e1540007 cmp r4, r7
dc38: 31a07004 movcc r7, r4
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL != key )
dc3c: e2503000 subs r3, r0, #0
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
if ( read )
rv = sparse_disk_read_block( sparse_disk,
dc40: e08b000a add r0, fp, sl
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL != key )
dc44: 0a000024 beq dcdc <sparse_disk_ioctl+0x1b8>
memcpy( buffer, key->data, bytes_to_copy );
dc48: e5931004 ldr r1, [r3, #4]
dc4c: e1a02007 mov r2, r7
dc50: eb0031be bl 1a350 <memcpy>
if ( NULL != key )
memcpy( key->data, buffer, bytes_to_copy );
else if ( block_needs_writing )
return -1;
return bytes_to_copy;
dc54: e0544007 subs r4, r4, r7
dc58: 03a02000 moveq r2, #0
dc5c: 13a02001 movne r2, #1
dc60: e1a03007 mov r3, r7
dc64: e3570000 cmp r7, #0
dc68: b3a02000 movlt r2, #0
dc6c: a2022001 andge r2, r2, #1
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
dc70: e3520000 cmp r2, #0
rv = sparse_disk_write_block( sparse_disk,
block,
&buff[bytes_handled],
buff_size );
++block;
dc74: e2888001 add r8, r8, #1
bytes_handled += rv;
dc78: e08aa003 add sl, sl, r3
bytes_handled = 0;
buff = (uint8_t *) scatter_gather->buffer;
block = scatter_gather->block;
buff_size = scatter_gather->length;
while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {
dc7c: 0a00001a beq dcec <sparse_disk_ioctl+0x1c8>
if ( read )
dc80: e3590000 cmp r9, #0
const rtems_blkdev_bnum block,
uint8_t *buffer,
const size_t buffer_size )
{
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
dc84: e58d8010 str r8, [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 )
dc88: 0affffe0 beq dc10 <sparse_disk_ioctl+0xec>
const size_t buffer_size )
{
unsigned int i;
bool block_needs_writing = false;
rtems_sparse_disk_key *key;
rtems_sparse_disk_key block_key = {
dc8c: e3a01000 mov r1, #0
dc90: 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(
dc94: e59fc154 ldr ip, [pc, #340] ; ddf0 <sparse_disk_ioctl+0x2cc>
dc98: e5952008 ldr r2, [r5, #8]
dc9c: e5951018 ldr r1, [r5, #24]
dca0: e28d0010 add r0, sp, #16
dca4: e3a03008 mov r3, #8
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;
dca8: e595700c ldr r7, [r5, #12]
/* 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(
dcac: e58dc000 str ip, [sp]
dcb0: eb002ee0 bl 19838 <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;
dcb4: e1540007 cmp r4, r7
dcb8: 31a07004 movcc r7, r4
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
dcbc: e2506000 subs r6, r0, #0
rv = sparse_disk_read_block( sparse_disk,
block,
&buff[bytes_handled],
buff_size );
else
rv = sparse_disk_write_block( sparse_disk,
dcc0: e08bc00a add ip, fp, sl
sparse_disk->used_count,
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
dcc4: 0a000016 beq dd24 <sparse_disk_ioctl+0x200>
key = sparse_disk_get_new_block( sparse_disk, block );
}
}
if ( NULL != key )
memcpy( key->data, buffer, bytes_to_copy );
dcc8: e5960004 ldr r0, [r6, #4]
dccc: e1a0100c mov r1, ip
dcd0: e1a02007 mov r2, r7
dcd4: eb00319d bl 1a350 <memcpy>
dcd8: eaffffdd b dc54 <sparse_disk_ioctl+0x130>
);
if ( NULL != key )
memcpy( buffer, key->data, bytes_to_copy );
else
memset( buffer, sparse_disk->fill_pattern, buffer_size );
dcdc: e5d51014 ldrb r1, [r5, #20]
dce0: e1a02004 mov r2, r4
dce4: eb0031cf bl 1a428 <memset>
dce8: eaffffd9 b dc54 <sparse_disk_ioctl+0x130>
dcec: e1a0a009 mov sl, r9
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
( 0 <= rv ) && ( req_buffer < req->bufnum );
++req_buffer ) {
dcf0: e59dc008 ldr ip, [sp, #8]
size_t buff_size;
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
dcf4: e3570000 cmp r7, #0
( 0 <= rv ) && ( req_buffer < req->bufnum );
++req_buffer ) {
dcf8: e28cc001 add ip, ip, #1
dcfc: e58dc008 str ip, [sp, #8]
size_t buff_size;
unsigned int bytes_handled;
rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
for ( req_buffer = 0;
dd00: aaffffab bge dbb4 <sparse_disk_ioctl+0x90>
bytes_handled += rv;
buff_size -= rv;
}
}
rtems_semaphore_release( sparse_disk->mutex );
dd04: e5950000 ldr r0, [r5] <== NOT EXECUTED
dd08: ebffeb13 bl 895c <rtems_semaphore_release> <== NOT EXECUTED
static inline void rtems_blkdev_request_done(
rtems_blkdev_request *req,
rtems_status_code status
)
{
(*req->done)(req, status);
dd0c: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED
dd10: e3a0101b mov r1, #27 <== NOT EXECUTED
dd14: e1a0e00f mov lr, pc <== NOT EXECUTED
dd18: e590f004 ldr pc, [r0, #4] <== NOT EXECUTED
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 );
dd1c: e3a00000 mov r0, #0 <== NOT EXECUTED
dd20: eaffff8a b db50 <sparse_disk_ioctl+0x2c> <== NOT EXECUTED
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
dd24: e3570000 cmp r7, #0
dd28: 0affffc9 beq dc54 <sparse_disk_ioctl+0x130>
dd2c: e5dc3000 ldrb r3, [ip]
if ( buffer[i] != sparse_disk->fill_pattern )
dd30: e5d50014 ldrb r0, [r5, #20]
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
dd34: e1530000 cmp r3, r0
dd38: 01a0200c moveq r2, ip
dd3c: 03a03001 moveq r3, #1
dd40: 1a000005 bne dd5c <sparse_disk_ioctl+0x238>
dd44: e1530007 cmp r3, r7
dd48: 0affffc1 beq dc54 <sparse_disk_ioctl+0x130>
if ( buffer[i] != sparse_disk->fill_pattern )
dd4c: e5f21001 ldrb r1, [r2, #1]!
sizeof( rtems_sparse_disk_key ),
sparse_disk_compare
);
if ( NULL == key ) {
for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
dd50: e1510000 cmp r1, r0
dd54: e2833001 add r3, r3, #1
dd58: 0afffff9 beq dd44 <sparse_disk_ioctl+0x220>
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 ) {
dd5c: e9954008 ldmib r5, {r3, lr}
dd60: e15e0003 cmp lr, r3
dd64: 3a000004 bcc dd7c <sparse_disk_ioctl+0x258>
}
}
if ( NULL != key )
memcpy( key->data, buffer, bytes_to_copy );
else if ( block_needs_writing )
dd68: e3e03000 mvn r3, #0 <== NOT EXECUTED
key = sparse_disk_get_new_block( sparse_disk, block );
}
}
if ( NULL != key )
memcpy( key->data, buffer, bytes_to_copy );
dd6c: e2844001 add r4, r4, #1 <== NOT EXECUTED
else if ( block_needs_writing )
dd70: e3a02000 mov r2, #0 <== NOT EXECUTED
return -1;
dd74: e1a07003 mov r7, r3 <== NOT EXECUTED
dd78: eaffffbc b dc70 <sparse_disk_ioctl+0x14c> <== NOT EXECUTED
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];
dd7c: e5956018 ldr r6, [r5, #24]
key->block = block;
++sparse_disk->used_count;
dd80: e28e1001 add r1, lr, #1
{
rtems_sparse_disk_key *key;
if ( sparse_disk->used_count < sparse_disk->blocks_with_buffer ) {
key = &sparse_disk->key_table[sparse_disk->used_count];
key->block = block;
dd84: e786818e str r8, [r6, lr, lsl #3]
++sparse_disk->used_count;
qsort( sparse_disk->key_table, sparse_disk->used_count,
dd88: e1a00006 mov r0, r6
rtems_sparse_disk_key *key;
if ( sparse_disk->used_count < sparse_disk->blocks_with_buffer ) {
key = &sparse_disk->key_table[sparse_disk->used_count];
key->block = block;
++sparse_disk->used_count;
dd8c: e5851008 str r1, [r5, #8]
qsort( sparse_disk->key_table, sparse_disk->used_count,
dd90: e3a02008 mov r2, #8
dd94: e59f3054 ldr r3, [pc, #84] ; ddf0 <sparse_disk_ioctl+0x2cc>
dd98: e58dc004 str ip, [sp, #4]
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];
dd9c: e086618e add r6, r6, lr, lsl #3
key->block = block;
++sparse_disk->used_count;
qsort( sparse_disk->key_table, sparse_disk->used_count,
dda0: eb0031dc bl 1a518 <qsort>
dda4: e59dc004 ldr ip, [sp, #4]
dda8: eaffffc6 b dcc8 <sparse_disk_ioctl+0x1a4>
bytes_handled += rv;
buff_size -= rv;
}
}
rtems_semaphore_release( sparse_disk->mutex );
ddac: e5950000 ldr r0, [r5]
ddb0: ebffeae9 bl 895c <rtems_semaphore_release>
ddb4: e59d000c ldr r0, [sp, #12]
ddb8: e3a01000 mov r1, #0
ddbc: e1a0e00f mov lr, pc
ddc0: e590f004 ldr pc, [r0, #4]
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 );
ddc4: e3a00000 mov r0, #0
ddc8: eaffff60 b db50 <sparse_disk_ioctl+0x2c>
return 0;
} else {
return rtems_blkdev_ioctl( dd, req, argp );
}
errno = EINVAL;
ddcc: eb002eb8 bl 198b4 <__errno> <== NOT EXECUTED
ddd0: e3a03016 mov r3, #22 <== NOT EXECUTED
ddd4: e5803000 str r3, [r0] <== NOT EXECUTED
return -1;
ddd8: e3e00000 mvn r0, #0 <== NOT EXECUTED
dddc: eaffff5b b db50 <sparse_disk_ioctl+0x2c> <== NOT EXECUTED
}
} else if ( RTEMS_BLKIO_DELETED == req ) {
sc = rtems_semaphore_delete( sd->mutex );
if ( RTEMS_SUCCESSFUL != sc )
rtems_fatal_error_occurred( 0xdeadbeef );
dde0: e59f000c ldr r0, [pc, #12] ; ddf4 <sparse_disk_ioctl+0x2d0><== NOT EXECUTED
dde4: ebffec7c bl 8fdc <rtems_fatal_error_occurred> <== NOT EXECUTED
00005f3c <unmount>:
* in some form is supported on most UNIX and POSIX systems. This
* routine is necessary to mount instantiations of a file system
* into the file system name space.
*/
int unmount( const char *path )
{
5f3c: e92d4030 push {r4, r5, lr}
5f40: e24dd03c sub sp, sp, #60 ; 0x3c
5f44: e1a01000 mov r1, r0
int rv = 0; rtems_filesystem_eval_path_context_t ctx; int eval_flags = RTEMS_FS_FOLLOW_LINK; const rtems_filesystem_location_info_t *currentloc =
5f48: e3a02018 mov r2, #24
5f4c: e1a0000d mov r0, sp
5f50: ebfff734 bl 3c28 <rtems_filesystem_eval_path_start>
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
5f54: e5905014 ldr r5, [r0, #20]
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
return (*mt_entry->ops->are_nodes_equal_h)(
5f58: e595300c ldr r3, [r5, #12]
5f5c: e5951024 ldr r1, [r5, #36] ; 0x24
5f60: e1a0e00f mov lr, pc
5f64: e593f010 ldr pc, [r3, #16]
if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {
5f68: e3500000 cmp r0, #0
5f6c: 0a00002d beq 6028 <unmount+0xec>
static bool contains_root_or_current_directory(
const rtems_filesystem_mount_table_entry_t *mt_entry
)
{
const rtems_filesystem_location_info_t *root =
&rtems_filesystem_root->location;
5f70: e59f30c4 ldr r3, [pc, #196] ; 603c <unmount+0x100>
5f74: e5933000 ldr r3, [r3]
const rtems_filesystem_location_info_t *current =
&rtems_filesystem_current->location;
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
5f78: e5932004 ldr r2, [r3, #4]
5f7c: e5922014 ldr r2, [r2, #20]
5f80: e1550002 cmp r5, r2
)
{
const rtems_filesystem_location_info_t *root =
&rtems_filesystem_root->location;
const rtems_filesystem_location_info_t *current =
&rtems_filesystem_current->location;
5f84: e5933000 ldr r3, [r3]
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
5f88: 0a000021 beq 6014 <unmount+0xd8>
5f8c: e5933014 ldr r3, [r3, #20]
5f90: e1550003 cmp r5, r3
5f94: 0a00001e beq 6014 <unmount+0xd8>
rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {
if ( !contains_root_or_current_directory( mt_entry ) ) {
const rtems_filesystem_operations_table *mt_point_ops =
mt_entry->mt_point_node->location.mt_entry->ops;
5f98: e5953020 ldr r3, [r5, #32]
5f9c: e5933014 ldr r3, [r3, #20]
rv = (*mt_point_ops->unmount_h)( mt_entry );
5fa0: e1a00005 mov r0, r5
5fa4: e593300c ldr r3, [r3, #12]
5fa8: e1a0e00f mov lr, pc
5fac: e593f038 ldr pc, [r3, #56] ; 0x38
if ( rv == 0 ) {
5fb0: e2504000 subs r4, r0, #0
5fb4: 0a000004 beq 5fcc <unmount+0x90>
} else {
errno = EACCES;
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
5fb8: e1a0000d mov r0, sp
5fbc: ebfff723 bl 3c50 <rtems_filesystem_eval_path_cleanup>
rtems_fatal_error_occurred( 0xdeadbeef );
}
}
return rv;
}
5fc0: e1a00004 mov r0, r4
5fc4: e28dd03c add sp, sp, #60 ; 0x3c
5fc8: e8bd8030 pop {r4, r5, pc}
const rtems_filesystem_operations_table *mt_point_ops =
mt_entry->mt_point_node->location.mt_entry->ops;
rv = (*mt_point_ops->unmount_h)( mt_entry );
if ( rv == 0 ) {
rtems_id self_task_id = rtems_task_self();
5fcc: eb0003f7 bl 6fb0 <rtems_task_self>
uint32_t level;
#if defined(ARM_MULTILIB_ARCH_V4)
uint32_t arm_switch_reg;
__asm__ volatile (
5fd0: e10f3000 mrs r3, CPSR
5fd4: e3832080 orr r2, r3, #128 ; 0x80
5fd8: e129f002 msr CPSR_fc, r2
rtems_filesystem_mt_entry_declare_lock_context( lock_context );
rtems_filesystem_mt_entry_lock( lock_context );
mt_entry->unmount_task = self_task_id;
5fdc: e585003c str r0, [r5, #60] ; 0x3c
mt_entry->mounted = false;
5fe0: e5c54028 strb r4, [r5, #40] ; 0x28
static inline void arm_interrupt_enable( uint32_t level )
{
#if defined(ARM_MULTILIB_ARCH_V4)
ARM_SWITCH_REGISTERS;
__asm__ volatile (
5fe4: e129f003 msr CPSR_fc, r3
} else {
errno = EACCES;
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
5fe8: e1a0000d mov r0, sp
5fec: ebfff717 bl 3c50 <rtems_filesystem_eval_path_cleanup>
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
5ff0: e3a01000 mov r1, #0
5ff4: e3a00102 mov r0, #-2147483648 ; 0x80000000
5ff8: e1a02001 mov r2, r1
5ffc: e28d3038 add r3, sp, #56 ; 0x38
6000: eb00031c bl 6c78 <rtems_event_system_receive>
rtems_status_code sc = rtems_event_transient_receive(
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if ( sc != RTEMS_SUCCESSFUL ) {
6004: e3500000 cmp r0, #0
6008: 0affffec beq 5fc0 <unmount+0x84>
rtems_fatal_error_occurred( 0xdeadbeef );
600c: e59f002c ldr r0, [pc, #44] ; 6040 <unmount+0x104> <== NOT EXECUTED
6010: eb00048f bl 7254 <rtems_fatal_error_occurred> <== NOT EXECUTED
mt_entry->unmount_task = self_task_id;
mt_entry->mounted = false;
rtems_filesystem_mt_entry_unlock( lock_context );
}
} else {
errno = EBUSY;
6014: eb001f3e bl dd14 <__errno>
6018: e3a03010 mov r3, #16
601c: e5803000 str r3, [r0]
rv = -1;
6020: e3e04000 mvn r4, #0
6024: eaffffe3 b 5fb8 <unmount+0x7c>
}
} else {
errno = EACCES;
6028: eb001f39 bl dd14 <__errno>
602c: e3a0300d mov r3, #13
6030: e5803000 str r3, [r0]
rv = -1;
6034: e3e04000 mvn r4, #0
6038: eaffffde b 5fb8 <unmount+0x7c>
00005c10 <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
5c10: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
5c14: e1a07000 mov r7, r0
for (; *fmt != '\0'; fmt++) {
5c18: e5d00000 ldrb r0, [r0]
*/
void vprintk(
const char *fmt,
va_list ap
)
{
5c1c: e24dd01c sub sp, sp, #28
for (; *fmt != '\0'; fmt++) {
5c20: e3500000 cmp r0, #0
*/
void vprintk(
const char *fmt,
va_list ap
)
{
5c24: e58d1004 str r1, [sp, #4]
for (; *fmt != '\0'; fmt++) {
5c28: 0a00006a beq 5dd8 <vprintk+0x1c8>
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
5c2c: e28d8008 add r8, sp, #8
bool minus = false;
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
5c30: e3500025 cmp r0, #37 ; 0x25
5c34: 1a000069 bne 5de0 <vprintk+0x1d0>
rtems_putc(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
5c38: e5d70001 ldrb r0, [r7, #1]
5c3c: e3500030 cmp r0, #48 ; 0x30
lead = '0';
fmt++;
5c40: 05d70002 ldrbeq r0, [r7, #2]
rtems_putc(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
5c44: 03a03030 moveq r3, #48 ; 0x30
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
5c48: 13a02020 movne r2, #32
if (*fmt != '%') {
rtems_putc(*fmt);
continue;
}
fmt++;
5c4c: 12877001 addne r7, r7, #1
if (*fmt == '0' ) {
lead = '0';
fmt++;
5c50: 02877002 addeq r7, r7, #2
rtems_putc(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
5c54: 058d3000 streq r3, [sp]
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
5c58: 158d2000 strne r2, [sp]
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
5c5c: e350002d cmp r0, #45 ; 0x2d
minus = true;
fmt++;
5c60: 05d70001 ldrbeq r0, [r7, #1]
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
5c64: 03a0a001 moveq sl, #1
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
5c68: e2403030 sub r3, r0, #48 ; 0x30
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
fmt++;
5c6c: 0087700a addeq r7, r7, sl
{
for (; *fmt != '\0'; fmt++) {
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
5c70: 13a0a000 movne sl, #0
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
5c74: e3530009 cmp r3, #9
5c78: 83a04000 movhi r4, #0
5c7c: 8a000009 bhi 5ca8 <vprintk+0x98>
5c80: e1a03007 mov r3, r7
* console is not yet initialized or in ISR's. * * Arguments: * as in printf: fmt - format string, ... - unnamed arguments. */ void vprintk(
5c84: e3a04000 mov r4, #0
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
width *= 10;
5c88: e0844104 add r4, r4, r4, lsl #2
width += ((unsigned) *fmt - '0');
5c8c: e0804084 add r4, r0, r4, lsl #1
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
5c90: e5f30001 ldrb r0, [r3, #1]!
5c94: e2402030 sub r2, r0, #48 ; 0x30
5c98: e3520009 cmp r2, #9
width *= 10;
width += ((unsigned) *fmt - '0');
5c9c: e2444030 sub r4, r4, #48 ; 0x30
fmt++;
5ca0: e2877001 add r7, r7, #1
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
5ca4: 9afffff7 bls 5c88 <vprintk+0x78>
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
5ca8: e350006c cmp r0, #108 ; 0x6c
lflag = true;
c = *++fmt;
5cac: 05d70001 ldrbeq r0, [r7, #1]
width += ((unsigned) *fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
lflag = true;
5cb0: 03a03001 moveq r3, #1
c = *++fmt;
5cb4: 00877003 addeq r7, r7, r3
}
if ( c == 'c' ) {
5cb8: e3500063 cmp r0, #99 ; 0x63
5cbc: 0a000081 beq 5ec8 <vprintk+0x2b8>
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
rtems_putc(chr);
continue;
}
if ( c == 's' ) {
5cc0: e3500073 cmp r0, #115 ; 0x73
5cc4: 0a00004b beq 5df8 <vprintk+0x1e8>
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
5cc8: e350006f cmp r0, #111 ; 0x6f
5ccc: 1350004f cmpne r0, #79 ; 0x4f
base = 8; sign = false;
5cd0: 03a02000 moveq r2, #0
5cd4: 03a09008 moveq r9, #8
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
5cd8: 0a000009 beq 5d04 <vprintk+0xf4>
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
5cdc: e3500069 cmp r0, #105 ; 0x69
5ce0: 13500049 cmpne r0, #73 ; 0x49
5ce4: 0a000004 beq 5cfc <vprintk+0xec>
c == 'd' || c == 'D' ) {
5ce8: e3500064 cmp r0, #100 ; 0x64
5cec: 13500044 cmpne r0, #68 ; 0x44
5cf0: 13a02000 movne r2, #0
5cf4: 03a02001 moveq r2, #1
5cf8: 1a00007c bne 5ef0 <vprintk+0x2e0>
base = 10; sign = true;
5cfc: e3a02001 mov r2, #1
5d00: e3a0900a mov r9, #10
} else {
rtems_putc(c);
continue;
}
printNum(
5d04: e59d3004 ldr r3, [sp, #4]
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
5d08: e3520000 cmp r2, #0
} else {
rtems_putc(c);
continue;
}
printNum(
5d0c: e593a000 ldr sl, [r3]
lflag ? va_arg(ap, long) : (long) va_arg(ap, int),
5d10: e2833004 add r3, r3, #4
5d14: e58d3004 str r3, [sp, #4]
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
5d18: 0a000001 beq 5d24 <vprintk+0x114>
5d1c: e35a0000 cmp sl, #0
5d20: ba000083 blt 5f34 <vprintk+0x324>
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
5d24: e1a0000a mov r0, sl
5d28: e1a01009 mov r1, r9
5d2c: eb00429e bl 167ac <__aeabi_uidiv>
5d30: e3500000 cmp r0, #0
5d34: e1a06000 mov r6, r0
5d38: e1a05000 mov r5, r0
5d3c: 1209b0ff andne fp, r9, #255 ; 0xff
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
5d40: 13a06000 movne r6, #0
while ((n = unsigned_num / base) > 0) {
5d44: 1a000002 bne 5d54 <vprintk+0x144>
5d48: ea00007f b 5f4c <vprintk+0x33c>
5d4c: e1a0a005 mov sl, r5
5d50: e1a05000 mov r5, r0
toPrint[count++] = (char) (unsigned_num - (n * base));
5d54: e0030b95 mul r3, r5, fp
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
5d58: e1a00005 mov r0, r5
toPrint[count++] = (char) (unsigned_num - (n * base));
5d5c: e063a00a rsb sl, r3, sl
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
5d60: e1a01009 mov r1, r9
toPrint[count++] = (char) (unsigned_num - (n * base));
5d64: e7c8a006 strb sl, [r8, r6]
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
5d68: eb00428f bl 167ac <__aeabi_uidiv>
5d6c: e3500000 cmp r0, #0
toPrint[count++] = (char) (unsigned_num - (n * base));
5d70: e2866001 add r6, r6, #1
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
5d74: 1afffff4 bne 5d4c <vprintk+0x13c>
5d78: e286a001 add sl, r6, #1
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
5d7c: e28d201c add r2, sp, #28
5d80: e0826006 add r6, r2, r6
for (n=maxwidth ; n > count; n-- )
5d84: e154000a cmp r4, sl
count = 0;
while ((n = unsigned_num / base) > 0) {
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
5d88: e5465014 strb r5, [r6, #-20]
for (n=maxwidth ; n > count; n-- )
5d8c: 9a000004 bls 5da4 <vprintk+0x194>
rtems_putc(lead);
5d90: e59d0000 ldr r0, [sp]
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
5d94: e2444001 sub r4, r4, #1
rtems_putc(lead);
5d98: eb0014be bl b098 <rtems_putc>
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
5d9c: e154000a cmp r4, sl
5da0: 8afffffa bhi 5d90 <vprintk+0x180>
rtems_putc(lead);
for (n = 0; n < count; n++) {
5da4: e35a0000 cmp sl, #0
5da8: 0a000006 beq 5dc8 <vprintk+0x1b8>
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
5dac: e088400a add r4, r8, sl
for (n=maxwidth ; n > count; n-- )
rtems_putc(lead);
for (n = 0; n < count; n++) {
rtems_putc("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
5db0: e5743001 ldrb r3, [r4, #-1]!
5db4: e59f219c ldr r2, [pc, #412] ; 5f58 <vprintk+0x348>
5db8: e7d20003 ldrb r0, [r2, r3]
5dbc: eb0014b5 bl b098 <rtems_putc>
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
rtems_putc(lead);
for (n = 0; n < count; n++) {
5dc0: e1540008 cmp r4, r8
5dc4: 1afffff9 bne 5db0 <vprintk+0x1a0>
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
5dc8: e5d70001 ldrb r0, [r7, #1]
5dcc: e3500000 cmp r0, #0
5dd0: e2877001 add r7, r7, #1
5dd4: 1affff95 bne 5c30 <vprintk+0x20>
sign,
width,
lead
);
}
}
5dd8: e28dd01c add sp, sp, #28
5ddc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
} else if ( c == 'x' || c == 'X' ) {
base = 16; sign = false;
} else if ( c == 'p' ) {
base = 16; sign = false; lflag = true;
} else {
rtems_putc(c);
5de0: eb0014ac bl b098 <rtems_putc>
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
5de4: e5d70001 ldrb r0, [r7, #1]
5de8: e3500000 cmp r0, #0
5dec: e2877001 add r7, r7, #1
5df0: 1affff8e bne 5c30 <vprintk+0x20>
5df4: eafffff7 b 5dd8 <vprintk+0x1c8>
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
5df8: e59d3004 ldr r3, [sp, #4]
5dfc: e5936000 ldr r6, [r3]
if ( str == NULL ) {
str = "";
5e00: e59f2154 ldr r2, [pc, #340] ; 5f5c <vprintk+0x34c>
5e04: e3560000 cmp r6, #0
5e08: 01a06002 moveq r6, r2
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
5e0c: e5d65000 ldrb r5, [r6]
5e10: e3550000 cmp r5, #0
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
5e14: e2839004 add r9, r3, #4
if ( str == NULL ) {
str = "";
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
5e18: 0a000005 beq 5e34 <vprintk+0x224>
5e1c: e1a03006 mov r3, r6
5e20: e3a05000 mov r5, #0
5e24: e5f32001 ldrb r2, [r3, #1]!
5e28: e3520000 cmp r2, #0
5e2c: e2855001 add r5, r5, #1
5e30: 1afffffb bne 5e24 <vprintk+0x214>
;
/* leading spaces */
if ( !minus )
5e34: e35a0000 cmp sl, #0
5e38: 1a000007 bne 5e5c <vprintk+0x24c>
for ( i=len ; i<width ; i++ )
5e3c: e1550004 cmp r5, r4
5e40: 2a000005 bcs 5e5c <vprintk+0x24c>
5e44: e1a0b005 mov fp, r5 <== NOT EXECUTED
rtems_putc(' ');
5e48: e3a00020 mov r0, #32 <== NOT EXECUTED
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
5e4c: e28bb001 add fp, fp, #1 <== NOT EXECUTED
rtems_putc(' ');
5e50: eb001490 bl b098 <rtems_putc> <== NOT EXECUTED
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
5e54: e15b0004 cmp fp, r4 <== NOT EXECUTED
5e58: 3afffffa bcc 5e48 <vprintk+0x238> <== NOT EXECUTED
rtems_putc(' ');
/* no width option */
if (width == 0) {
5e5c: e3540000 cmp r4, #0
5e60: 1a000002 bne 5e70 <vprintk+0x260>
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
5e64: e3550000 cmp r5, #0
5e68: 0a000007 beq 5e8c <vprintk+0x27c>
5e6c: e1a04005 mov r4, r5
5e70: e5d60000 ldrb r0, [r6]
5e74: e3500000 cmp r0, #0
5e78: 0a000003 beq 5e8c <vprintk+0x27c>
rtems_putc(*str);
5e7c: eb001485 bl b098 <rtems_putc>
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
5e80: e5f60001 ldrb r0, [r6, #1]!
5e84: e3500000 cmp r0, #0
5e88: 1afffffb bne 5e7c <vprintk+0x26c>
rtems_putc(*str);
/* trailing spaces */
if ( minus )
5e8c: e35a0000 cmp sl, #0
5e90: 0a000006 beq 5eb0 <vprintk+0x2a0>
for ( i=len ; i<width ; i++ )
5e94: e1550004 cmp r5, r4
5e98: 2a000004 bcs 5eb0 <vprintk+0x2a0>
rtems_putc(' ');
5e9c: e3a00020 mov r0, #32
for ( i=0 ; i<width && *str ; str++ )
rtems_putc(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
5ea0: e2855001 add r5, r5, #1
rtems_putc(' ');
5ea4: eb00147b bl b098 <rtems_putc>
for ( i=0 ; i<width && *str ; str++ )
rtems_putc(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
5ea8: e1550004 cmp r5, r4
5eac: 3afffffa bcc 5e9c <vprintk+0x28c>
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
5eb0: e5d70001 ldrb r0, [r7, #1]
5eb4: e3500000 cmp r0, #0
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
5eb8: e58d9004 str r9, [sp, #4]
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
5ebc: e2877001 add r7, r7, #1
5ec0: 1affff5a bne 5c30 <vprintk+0x20>
5ec4: eaffffc3 b 5dd8 <vprintk+0x1c8>
c = *++fmt;
}
if ( c == 'c' ) {
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
rtems_putc(chr);
5ec8: e59d2004 ldr r2, [sp, #4]
5ecc: e5d20000 ldrb r0, [r2]
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
5ed0: e2824004 add r4, r2, #4
rtems_putc(chr);
5ed4: eb00146f bl b098 <rtems_putc>
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
5ed8: e5d70001 ldrb r0, [r7, #1]
5edc: e3500000 cmp r0, #0
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
5ee0: e58d4004 str r4, [sp, #4]
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
5ee4: e2877001 add r7, r7, #1
5ee8: 1affff50 bne 5c30 <vprintk+0x20>
5eec: eaffffb9 b 5dd8 <vprintk+0x1c8>
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
5ef0: e3500075 cmp r0, #117 ; 0x75
5ef4: 13500055 cmpne r0, #85 ; 0x55
5ef8: 13a01000 movne r1, #0
5efc: 03a01001 moveq r1, #1
base = 10; sign = false;
5f00: 03a0900a moveq r9, #10
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
5f04: 0affff7e beq 5d04 <vprintk+0xf4>
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
5f08: e3500078 cmp r0, #120 ; 0x78
5f0c: 13500058 cmpne r0, #88 ; 0x58
5f10: 13a02000 movne r2, #0
5f14: 03a02001 moveq r2, #1
base = 16; sign = false;
5f18: 03a09010 moveq r9, #16
5f1c: 01a02001 moveq r2, r1
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
5f20: 0affff77 beq 5d04 <vprintk+0xf4>
base = 16; sign = false;
} else if ( c == 'p' ) {
5f24: e3500070 cmp r0, #112 ; 0x70
5f28: 1affffac bne 5de0 <vprintk+0x1d0>
base = 16; sign = false; lflag = true;
5f2c: e3a09010 mov r9, #16
5f30: eaffff73 b 5d04 <vprintk+0xf4>
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
rtems_putc('-');
5f34: e3a0002d mov r0, #45 ; 0x2d <== NOT EXECUTED
5f38: eb001456 bl b098 <rtems_putc> <== NOT EXECUTED
unsigned_num = (unsigned long) -num;
if (maxwidth) maxwidth--;
5f3c: e3540000 cmp r4, #0 <== NOT EXECUTED
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
rtems_putc('-');
unsigned_num = (unsigned long) -num;
5f40: e26aa000 rsb sl, sl, #0 <== NOT EXECUTED
if (maxwidth) maxwidth--;
5f44: 12444001 subne r4, r4, #1 <== NOT EXECUTED
5f48: eaffff75 b 5d24 <vprintk+0x114> <== NOT EXECUTED
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
5f4c: e1a0500a mov r5, sl
5f50: e3a0a001 mov sl, #1
5f54: eaffff88 b 5d7c <vprintk+0x16c>
00018cd0 <write>:
size_t count
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
18cd0: e59f3080 ldr r3, [pc, #128] ; 18d58 <write+0x88> 18cd4: e5933000 ldr r3, [r3] 18cd8: e1500003 cmp r0, r3
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
18cdc: e92d4010 push {r4, lr}
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
18ce0: 2a000012 bcs 18d30 <write+0x60>
iop = rtems_libio_iop( fd );
18ce4: e59f4070 ldr r4, [pc, #112] ; 18d5c <write+0x8c> 18ce8: e5944000 ldr r4, [r4] 18cec: e0800080 add r0, r0, r0, lsl #1 18cf0: e0840200 add r0, r4, r0, lsl #4
rtems_libio_check_is_open( iop );
18cf4: e590400c ldr r4, [r0, #12] 18cf8: e3140c01 tst r4, #256 ; 0x100
18cfc: 0a00000b beq 18d30 <write+0x60> rtems_libio_check_buffer( buffer );
18d00: e3510000 cmp r1, #0
18d04: 0a00000e beq 18d44 <write+0x74> rtems_libio_check_count( count );
18d08: e3520000 cmp r2, #0
18d0c: 0a000005 beq 18d28 <write+0x58> rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
18d10: e3140004 tst r4, #4
18d14: 0a000005 beq 18d30 <write+0x60>
/*
* Now process the write() request.
*/
return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
18d18: e5903020 ldr r3, [r0, #32]
18d1c: e1a0e00f mov lr, pc
18d20: e593f00c ldr pc, [r3, #12]
18d24: e8bd8010 pop {r4, 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 );
18d28: e1a00002 mov r0, r2
/*
* Now process the write() request.
*/
return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
}
18d2c: e8bd8010 pop {r4, pc}
rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
18d30: ebffd2ac bl d7e8 <__errno>
18d34: e3a03009 mov r3, #9
18d38: e5803000 str r3, [r0]
18d3c: e3e00000 mvn r0, #0
18d40: e8bd8010 pop {r4, pc}
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
18d44: ebffd2a7 bl d7e8 <__errno> <== NOT EXECUTED
18d48: e3a03016 mov r3, #22 <== NOT EXECUTED
18d4c: e5803000 str r3, [r0] <== NOT EXECUTED
18d50: e3e00000 mvn r0, #0 <== NOT EXECUTED
18d54: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00006e14 <writev>:
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
6e14: e59f3138 ldr r3, [pc, #312] ; 6f54 <writev+0x140>
6e18: e5933000 ldr r3, [r3]
6e1c: e1500003 cmp r0, r3
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
6e20: e92d41f0 push {r4, r5, r6, r7, r8, lr}
6e24: e1a04002 mov r4, r2
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
6e28: 2a000042 bcs 6f38 <writev+0x124>
iop = rtems_libio_iop( fd );
6e2c: e59f3124 ldr r3, [pc, #292] ; 6f58 <writev+0x144>
6e30: e5933000 ldr r3, [r3]
6e34: e0800080 add r0, r0, r0, lsl #1
6e38: e0838200 add r8, r3, r0, lsl #4
rtems_libio_check_is_open( iop );
6e3c: e598300c ldr r3, [r8, #12]
6e40: e3130c01 tst r3, #256 ; 0x100
6e44: 0a00003b beq 6f38 <writev+0x124>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
6e48: e3130004 tst r3, #4
6e4c: 0a000039 beq 6f38 <writev+0x124>
/*
* Argument validation on IO vector
*/
if ( !iov )
6e50: e3510000 cmp r1, #0
6e54: 0a000031 beq 6f20 <writev+0x10c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
6e58: e3520000 cmp r2, #0
6e5c: da00002f ble 6f20 <writev+0x10c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
6e60: e3520b01 cmp r2, #1024 ; 0x400
6e64: ca00002d bgt 6f20 <writev+0x10c>
rtems_set_errno_and_return_minus_one( EINVAL );
6e68: e1a05001 mov r5, r1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
6e6c: e3a01000 mov r1, #0
6e70: e1a02005 mov r2, r5
6e74: e3a06001 mov r6, #1
6e78: e1a07001 mov r7, r1
6e7c: ea000000 b 6e84 <writev+0x70>
if ( iov[v].iov_len )
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
6e80: e1a07003 mov r7, r3
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
6e84: e5923000 ldr r3, [r2]
6e88: e3530000 cmp r3, #0
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
6e8c: e2811001 add r1, r1, #1
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
6e90: 0a000022 beq 6f20 <writev+0x10c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
6e94: e5920004 ldr r0, [r2, #4]
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
6e98: e0803007 add r3, r0, r7
if ( total < old || total > SSIZE_MAX )
6e9c: e1570003 cmp r7, r3
6ea0: d3a07000 movle r7, #0
6ea4: c3a07001 movgt r7, #1
*/
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
6ea8: e3500000 cmp r0, #0
6eac: 13a06000 movne r6, #0
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
6eb0: e1977fa3 orrs r7, r7, r3, lsr #31
6eb4: 1a000019 bne 6f20 <writev+0x10c>
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
6eb8: e1510004 cmp r1, r4
6ebc: e2822008 add r2, r2, #8
6ec0: 1affffee bne 6e80 <writev+0x6c>
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
6ec4: e3560000 cmp r6, #0
6ec8: 1a000018 bne 6f30 <writev+0x11c>
6ecc: e1a07006 mov r7, r6
6ed0: ea000002 b 6ee0 <writev+0xcc>
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
6ed4: e1560004 cmp r6, r4
6ed8: e2855008 add r5, r5, #8
6edc: 0a000013 beq 6f30 <writev+0x11c>
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
6ee0: e5952004 ldr r2, [r5, #4]
6ee4: e3520000 cmp r2, #0
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
6ee8: e2866001 add r6, r6, #1
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
6eec: 0afffff8 beq 6ed4 <writev+0xc0>
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
6ef0: e5951000 ldr r1, [r5]
6ef4: e5983020 ldr r3, [r8, #32]
6ef8: e1a00008 mov r0, r8
6efc: e1a0e00f mov lr, pc
6f00: e593f00c ldr pc, [r3, #12]
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
6f04: e3500000 cmp r0, #0
6f08: ba00000f blt 6f4c <writev+0x138>
if ( bytes > 0 ) {
total += bytes;
}
if (bytes != iov[ v ].iov_len)
6f0c: e5953004 ldr r3, [r5, #4]
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
total += bytes;
6f10: 10877000 addne r7, r7, r0
}
if (bytes != iov[ v ].iov_len)
6f14: e1500003 cmp r0, r3
6f18: 0affffed beq 6ed4 <writev+0xc0>
6f1c: ea000003 b 6f30 <writev+0x11c> <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
6f20: eb001d84 bl e538 <__errno>
6f24: e3a03016 mov r3, #22
6f28: e5803000 str r3, [r0]
6f2c: e3e07000 mvn r7, #0
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
6f30: e1a00007 mov r0, r7
6f34: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
6f38: eb001d7e bl e538 <__errno>
6f3c: e3a03009 mov r3, #9
6f40: e5803000 str r3, [r0]
6f44: e3e07000 mvn r7, #0
6f48: eafffff8 b 6f30 <writev+0x11c>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
6f4c: e3e07000 mvn r7, #0 <== NOT EXECUTED
6f50: eafffff6 b 6f30 <writev+0x11c> <== NOT EXECUTED